pyvpmr 241011__tar.gz → 241217__tar.gz

{pyvpmr-241011/pyvpmr.egg-info → pyvpmr-241217}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyvpmr
-Version: 241011
+Version: 241217
 Summary: The VPMR Algorithm
 Author-email: Theodore Chang <tlcfem@gmail.com>
 Maintainer-email: Theodore Chang <tlcfem@gmail.com>
@@ -704,6 +704,8 @@ Requires-Dist: matplotlib
 
 # VPMR C++ Implementation
 
+<img src="https://raw.githubusercontent.com/TLCFEM/vpmr/master/resource/vpmr.svg" width="150" align="middle"/>
+
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7770193.svg)](https://doi.org/10.5281/zenodo.7770193)
 [![codecov](https://codecov.io/gh/TLCFEM/vpmr/branch/master/graph/badge.svg?token=9QE6SQC3ZG)](https://codecov.io/gh/TLCFEM/vpmr)
 [![PyPI version](https://badge.fury.io/py/pyvpmr.svg)](https://pypi.org/project/pyvpmr/)
@@ -766,13 +768,13 @@ On RPM-based Linux distributions (using `dnf`), if you are:
    available), `sudo dnf install -y gcc-c++ tbb-devel mpfr-devel gmp-devel`
 2. using the packaged binary (wheels are available), `sudo dnf install -y gmp mpfr tbb`
 
-On DEB-based Linux distributions (using `apt`), you need to `sudo apt install -y libtbb-dev libmpfr-dev libgmp-dev`.
+On DEB-based Linux distributions (using `apt`), you need to `sudo apt install -y g++ libtbb-dev libmpfr-dev libgmp-dev`.
 
 On macOS, you need to `brew install tbb mpfr gmp`.
 
 Then install the package with `pip`.
 
-```
+```bash
 pip install pyvpmr
 ```
 
@@ -796,66 +798,6 @@ if __name__ == '__main__':
     plot(m, s, kernel)
 ```
 
-### Compile Binary
-
-> [!WARNING]
-> The application relies on `eigen` and `exprtk`, which depend on very heavy usage of templates.
-> The compilation would take minutes and around 2 GB memory.
-> You need to install libraries `gmp`, `mpfr` and `tbb` before compiling.
-
-#### Docker
-
-To avoid the hassle of installing dependencies, you can use the provided `Dockerfile`.
-For example,
-
-```bash
-wget -q https://raw.githubusercontent.com/TLCFEM/vpmr/master/Dockerfile
-docker build -t vpmr -f Dockerfile .
-```
-
-Or you simply pull using the following command.
-
-```bash
-docker pull tlcfem/vpmr
-# or using GitHub Container Registry
-docker pull ghcr.io/tlcfem/vmpr
-```
-
-#### Windows
-
-Use the following instructions based on [MSYS2](https://www.msys2.org/), or follow the Linux instructions below with
-WSL.
-
-```bash
-# install necessary packages
-pacman -S git mingw-w64-x86_64-cmake mingw-w64-x86_64-tbb mingw-w64-x86_64-gcc mingw-w64-x86_64-ninja mingw-w64-x86_64-gmp mingw-w64-x86_64-mpfr
-# clone the repository
-git clone --depth 1 https://github.com/TLCFEM/vpmr.git
-# initialise submodules
-cd vpmr
-git submodule update --init --recursive
-# apply patch to enable parallel evaluation of some loops in SVD
-cd eigen && git apply --ignore-space-change --ignore-whitespace ../patch_size.patch && cd ..
-# configure and compile
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .
-ninja
-```
-
-#### Linux
-
-The following is based on Fedora.
-
-```bash
-sudo dnf install gcc g++ gfortran cmake git -y
-sudo dnf install tbb-devel mpfr-devel gmp-devel -y
-git clone --depth 1 https://github.com/TLCFEM/vpmr.git
-cd vpmr
-git submodule update --init --recursive
-cd eigen && git apply --ignore-space-change --ignore-whitespace ../patch_size.patch && cd ..
-cmake -DCMAKE_BUILD_TYPE=Release .
-make
-```
-
 ### Usage
 
 All available options are:
@@ -942,6 +884,7 @@ The file should contain the kernel expressed as a function of variable `t`.
 
 The `exprtk` is used to parse the expression and compute the value.
 The provided kernel function must be valid and supported by `exprtk`.
+Check the [documentation](https://www.partow.net/programming/exprtk/) regarding how to write a valid expression.
 
 For example, to compute the approximation of `exp(-t^2/10)`, one can create a file `kernel.txt` with the following
 content:
@@ -959,6 +902,73 @@ echo "exp(-t*t/10)" > kernel.txt
 
 ![exp(-t^2/10)](https://raw.githubusercontent.com/TLCFEM/vpmr/master/resource/arbitrary.png)
 
+## Performance
+
+The computation of weights, that involves integrals, and SVD are parallelised.
+A typical profiling would yield something similar to the following.
+
+![profiling](https://raw.githubusercontent.com/TLCFEM/vpmr/master/resource/profile.png)
+
+## Compilation
+
+> [!WARNING]
+> The application relies on `eigen` and `exprtk`, which depend on very heavy usage of templates.
+> The compilation would take minutes and around 2 GB memory.
+> You need to install libraries `gmp`, `mpfr` and `tbb` before compiling.
+
+### Docker
+
+To avoid the hassle of installing dependencies, you can use the provided `Dockerfile`.
+For example,
+
+```bash
+wget -q https://raw.githubusercontent.com/TLCFEM/vpmr/master/Dockerfile
+docker build -t vpmr -f Dockerfile .
+```
+
+Or you simply pull using the following command.
+
+```bash
+docker pull tlcfem/vpmr
+# or using GitHub Container Registry
+docker pull ghcr.io/tlcfem/vmpr
+```
+
+### Windows
+
+Use the following instructions based on [MSYS2](https://www.msys2.org/), or follow the Linux instructions below with
+WSL.
+
+```bash
+# install necessary packages
+pacman -S git mingw-w64-x86_64-cmake mingw-w64-x86_64-tbb mingw-w64-x86_64-gcc mingw-w64-x86_64-ninja mingw-w64-x86_64-gmp mingw-w64-x86_64-mpfr
+# clone the repository
+git clone --depth 1 https://github.com/TLCFEM/vpmr.git
+# initialise submodules
+cd vpmr
+git submodule update --init --recursive
+# apply patch to enable parallel evaluation of some loops in SVD
+cd eigen && git apply --ignore-space-change --ignore-whitespace ../patch_size.patch && cd ..
+# configure and compile
+cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .
+ninja
+```
+
+### Linux
+
+The following is based on Fedora.
+
+```bash
+sudo dnf install gcc g++ gfortran cmake git -y
+sudo dnf install tbb-devel mpfr-devel gmp-devel -y
+git clone --depth 1 https://github.com/TLCFEM/vpmr.git
+cd vpmr
+git submodule update --init --recursive
+cd eigen && git apply --ignore-space-change --ignore-whitespace ../patch_size.patch && cd ..
+cmake -DCMAKE_BUILD_TYPE=Release .
+make
+```
+
 ## Binary
 
 The binary requires available `gmp`, `mpfr` and `tbb` libraries.

{pyvpmr-241011 → pyvpmr-241217}/README.md

@@ -1,5 +1,7 @@
 # VPMR C++ Implementation
 
+<img src="resource/vpmr.svg" width="150" align="middle"/>
+
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7770193.svg)](https://doi.org/10.5281/zenodo.7770193)
 [![codecov](https://codecov.io/gh/TLCFEM/vpmr/branch/master/graph/badge.svg?token=9QE6SQC3ZG)](https://codecov.io/gh/TLCFEM/vpmr)
 [![PyPI version](https://badge.fury.io/py/pyvpmr.svg)](https://pypi.org/project/pyvpmr/)
@@ -62,13 +64,13 @@ On RPM-based Linux distributions (using `dnf`), if you are:
    available), `sudo dnf install -y gcc-c++ tbb-devel mpfr-devel gmp-devel`
 2. using the packaged binary (wheels are available), `sudo dnf install -y gmp mpfr tbb`
 
-On DEB-based Linux distributions (using `apt`), you need to `sudo apt install -y libtbb-dev libmpfr-dev libgmp-dev`.
+On DEB-based Linux distributions (using `apt`), you need to `sudo apt install -y g++ libtbb-dev libmpfr-dev libgmp-dev`.
 
 On macOS, you need to `brew install tbb mpfr gmp`.
 
 Then install the package with `pip`.
 
-```
+```bash
 pip install pyvpmr
 ```
 
@@ -92,66 +94,6 @@ if __name__ == '__main__':
     plot(m, s, kernel)
 ```
 
-### Compile Binary
-
-> [!WARNING]
-> The application relies on `eigen` and `exprtk`, which depend on very heavy usage of templates.
-> The compilation would take minutes and around 2 GB memory.
-> You need to install libraries `gmp`, `mpfr` and `tbb` before compiling.
-
-#### Docker
-
-To avoid the hassle of installing dependencies, you can use the provided `Dockerfile`.
-For example,
-
-```bash
-wget -q https://raw.githubusercontent.com/TLCFEM/vpmr/master/Dockerfile
-docker build -t vpmr -f Dockerfile .
-```
-
-Or you simply pull using the following command.
-
-```bash
-docker pull tlcfem/vpmr
-# or using GitHub Container Registry
-docker pull ghcr.io/tlcfem/vmpr
-```
-
-#### Windows
-
-Use the following instructions based on [MSYS2](https://www.msys2.org/), or follow the Linux instructions below with
-WSL.
-
-```bash
-# install necessary packages
-pacman -S git mingw-w64-x86_64-cmake mingw-w64-x86_64-tbb mingw-w64-x86_64-gcc mingw-w64-x86_64-ninja mingw-w64-x86_64-gmp mingw-w64-x86_64-mpfr
-# clone the repository
-git clone --depth 1 https://github.com/TLCFEM/vpmr.git
-# initialise submodules
-cd vpmr
-git submodule update --init --recursive
-# apply patch to enable parallel evaluation of some loops in SVD
-cd eigen && git apply --ignore-space-change --ignore-whitespace ../patch_size.patch && cd ..
-# configure and compile
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .
-ninja
-```
-
-#### Linux
-
-The following is based on Fedora.
-
-```bash
-sudo dnf install gcc g++ gfortran cmake git -y
-sudo dnf install tbb-devel mpfr-devel gmp-devel -y
-git clone --depth 1 https://github.com/TLCFEM/vpmr.git
-cd vpmr
-git submodule update --init --recursive
-cd eigen && git apply --ignore-space-change --ignore-whitespace ../patch_size.patch && cd ..
-cmake -DCMAKE_BUILD_TYPE=Release .
-make
-```
-
 ### Usage
 
 All available options are:
@@ -238,6 +180,7 @@ The file should contain the kernel expressed as a function of variable `t`.
 
 The `exprtk` is used to parse the expression and compute the value.
 The provided kernel function must be valid and supported by `exprtk`.
+Check the [documentation](https://www.partow.net/programming/exprtk/) regarding how to write a valid expression.
 
 For example, to compute the approximation of `exp(-t^2/10)`, one can create a file `kernel.txt` with the following
 content:
@@ -255,6 +198,73 @@ echo "exp(-t*t/10)" > kernel.txt
 
 ![exp(-t^2/10)](resource/arbitrary.png)
 
+## Performance
+
+The computation of weights, that involves integrals, and SVD are parallelised.
+A typical profiling would yield something similar to the following.
+
+![profiling](resource/profile.png)
+
+## Compilation
+
+> [!WARNING]
+> The application relies on `eigen` and `exprtk`, which depend on very heavy usage of templates.
+> The compilation would take minutes and around 2 GB memory.
+> You need to install libraries `gmp`, `mpfr` and `tbb` before compiling.
+
+### Docker
+
+To avoid the hassle of installing dependencies, you can use the provided `Dockerfile`.
+For example,
+
+```bash
+wget -q https://raw.githubusercontent.com/TLCFEM/vpmr/master/Dockerfile
+docker build -t vpmr -f Dockerfile .
+```
+
+Or you simply pull using the following command.
+
+```bash
+docker pull tlcfem/vpmr
+# or using GitHub Container Registry
+docker pull ghcr.io/tlcfem/vmpr
+```
+
+### Windows
+
+Use the following instructions based on [MSYS2](https://www.msys2.org/), or follow the Linux instructions below with
+WSL.
+
+```bash
+# install necessary packages
+pacman -S git mingw-w64-x86_64-cmake mingw-w64-x86_64-tbb mingw-w64-x86_64-gcc mingw-w64-x86_64-ninja mingw-w64-x86_64-gmp mingw-w64-x86_64-mpfr
+# clone the repository
+git clone --depth 1 https://github.com/TLCFEM/vpmr.git
+# initialise submodules
+cd vpmr
+git submodule update --init --recursive
+# apply patch to enable parallel evaluation of some loops in SVD
+cd eigen && git apply --ignore-space-change --ignore-whitespace ../patch_size.patch && cd ..
+# configure and compile
+cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .
+ninja
+```
+
+### Linux
+
+The following is based on Fedora.
+
+```bash
+sudo dnf install gcc g++ gfortran cmake git -y
+sudo dnf install tbb-devel mpfr-devel gmp-devel -y
+git clone --depth 1 https://github.com/TLCFEM/vpmr.git
+cd vpmr
+git submodule update --init --recursive
+cd eigen && git apply --ignore-space-change --ignore-whitespace ../patch_size.patch && cd ..
+cmake -DCMAKE_BUILD_TYPE=Release .
+make
+```
+
 ## Binary
 
 The binary requires available `gmp`, `mpfr` and `tbb` libraries.

{pyvpmr-241011 → pyvpmr-241217}/eigen/Eigen/Core

@@ -318,6 +318,7 @@ using std::ptrdiff_t;
 #include "src/Core/PlainObjectBase.h"
 #include "src/Core/Matrix.h"
 #include "src/Core/Array.h"
+#include "src/Core/Fill.h"
 #include "src/Core/CwiseTernaryOp.h"
 #include "src/Core/CwiseBinaryOp.h"
 #include "src/Core/CwiseUnaryOp.h"

{pyvpmr-241011 → pyvpmr-241217}/eigen/Eigen/src/Core/Array.h

@@ -102,8 +102,13 @@ class Array : public PlainObjectBase<Array<Scalar_, Rows_, Cols_, Options_, MaxR
     return Base::_set(other);
   }
 
-  /** This is a special case of the templated operator=. Its purpose is to
-   * prevent a default operator= from hiding the templated operator=.
+  /**
+   * \brief Assigns arrays to each other.
+   *
+   * \note This is a special case of the templated operator=. Its purpose is
+   * to prevent a default operator= from hiding the templated operator=.
+   *
+   * \callgraph
    */
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array& operator=(const Array& other) { return Base::_set(other); }
 
@@ -117,16 +122,13 @@ class Array : public PlainObjectBase<Array<Scalar_, Rows_, Cols_, Options_, MaxR
    *
    * \sa resize(Index,Index)
    */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array() : Base() { EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED }
-
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-  // FIXME is it still needed ??
-  /** \internal */
-  EIGEN_DEVICE_FUNC Array(internal::constructor_without_unaligned_array_assert)
-      : Base(internal::constructor_without_unaligned_array_assert()){EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED}
+#ifdef EIGEN_INITIALIZE_COEFFS
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array() : Base() { EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED }
+#else
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array() = default;
 #endif
-
-        EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array(Array && other) = default;
+  /** \brief Move constructor */
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array(Array&&) = default;
   EIGEN_DEVICE_FUNC Array& operator=(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value) {
     Base::operator=(std::move(other));
     return *this;
@@ -230,7 +232,7 @@ class Array : public PlainObjectBase<Array<Scalar_, Rows_, Cols_, Options_, MaxR
   }
 
   /** Copy constructor */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array(const Array& other) = default;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array(const Array&) = default;
 
  private:
   struct PrivateType {};

{pyvpmr-241011 → pyvpmr-241217}/eigen/Eigen/src/Core/AssignEvaluator.h

@@ -737,18 +737,6 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR void call_dense_assignment
   dense_assignment_loop<Kernel>::run(kernel);
 }
 
-// Specialization for filling the destination with a constant value.
-#ifndef EIGEN_GPU_COMPILE_PHASE
-template <typename DstXprType>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(
-    DstXprType& dst,
-    const Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<typename DstXprType::Scalar>, DstXprType>& src,
-    const internal::assign_op<typename DstXprType::Scalar, typename DstXprType::Scalar>& func) {
-  resize_if_allowed(dst, src, func);
-  std::fill_n(dst.data(), dst.size(), src.functor()());
-}
-#endif
-
 template <typename DstXprType, typename SrcXprType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src) {
   call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>());
@@ -900,6 +888,32 @@ struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Weak> {
   }
 };
 
+template <typename DstXprType, typename SrcPlainObject, typename Weak>
+struct Assignment<DstXprType, CwiseNullaryOp<scalar_constant_op<typename DstXprType::Scalar>, SrcPlainObject>,
+                  assign_op<typename DstXprType::Scalar, typename DstXprType::Scalar>, Dense2Dense, Weak> {
+  using Scalar = typename DstXprType::Scalar;
+  using NullaryOp = scalar_constant_op<Scalar>;
+  using SrcXprType = CwiseNullaryOp<NullaryOp, SrcPlainObject>;
+  using Functor = assign_op<Scalar, Scalar>;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(DstXprType& dst, const SrcXprType& src,
+                                                        const Functor& /*func*/) {
+    eigen_fill_impl<DstXprType>::run(dst, src);
+  }
+};
+
+template <typename DstXprType, typename SrcPlainObject, typename Weak>
+struct Assignment<DstXprType, CwiseNullaryOp<scalar_zero_op<typename DstXprType::Scalar>, SrcPlainObject>,
+                  assign_op<typename DstXprType::Scalar, typename DstXprType::Scalar>, Dense2Dense, Weak> {
+  using Scalar = typename DstXprType::Scalar;
+  using NullaryOp = scalar_zero_op<Scalar>;
+  using SrcXprType = CwiseNullaryOp<NullaryOp, SrcPlainObject>;
+  using Functor = assign_op<Scalar, Scalar>;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(DstXprType& dst, const SrcXprType& src,
+                                                        const Functor& /*func*/) {
+    eigen_zero_impl<DstXprType>::run(dst, src);
+  }
+};
+
 // Generic assignment through evalTo.
 // TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.
 // Note that the last template argument "Weak" is needed to make it possible to perform

{pyvpmr-241011 → pyvpmr-241217}/eigen/Eigen/src/Core/Assign_MKL.h

@@ -89,7 +89,7 @@ class vml_assign_traits {
     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 == LinearTraversal) {                     \
+      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 {                                                                                             \

{pyvpmr-241011 → pyvpmr-241217}/eigen/Eigen/src/Core/CoreEvaluators.h

@@ -124,8 +124,7 @@ struct evaluator_base {
   // 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.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator_base() {}
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ~evaluator_base() {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr evaluator_base() = default;
 
  private:
   EIGEN_DEVICE_FUNC evaluator_base(const evaluator_base&);
@@ -143,7 +142,7 @@ struct evaluator_base {
 template <typename Scalar, int OuterStride>
 class plainobjectbase_evaluator_data {
  public:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride)
       : data(ptr) {
 #ifndef EIGEN_INTERNAL_DEBUGGING
     EIGEN_UNUSED_VARIABLE(outerStride);
@@ -157,9 +156,9 @@ class plainobjectbase_evaluator_data {
 template <typename Scalar>
 class plainobjectbase_evaluator_data<Scalar, Dynamic> {
  public:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride)
       : data(ptr), m_outerStride(outerStride) {}
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outerStride() const { return m_outerStride; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Index outerStride() const { return m_outerStride; }
   const Scalar* data;
 
  protected:
@@ -189,32 +188,34 @@ struct evaluator<PlainObjectBase<Derived>> : evaluator_base<Derived> {
                                                      : RowsAtCompileTime
   };
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator() : m_d(0, OuterStrideAtCompileTime) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr evaluator() : m_d(0, OuterStrideAtCompileTime) {
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const PlainObjectType& m)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr explicit evaluator(const PlainObjectType& m)
       : m_d(m.data(), IsVectorAtCompileTime ? 0 : m.outerStride()) {
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr CoeffReturnType coeff(Index row, Index col) const {
     if (IsRowMajor)
       return m_d.data[row * m_d.outerStride() + col];
     else
       return m_d.data[row + col * m_d.outerStride()];
   }
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_d.data[index]; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr CoeffReturnType coeff(Index index) const { return m_d.data[index]; }
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Scalar& coeffRef(Index row, Index col) {
     if (IsRowMajor)
       return const_cast<Scalar*>(m_d.data)[row * m_d.outerStride() + col];
     else
       return const_cast<Scalar*>(m_d.data)[row + col * m_d.outerStride()];
   }
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return const_cast<Scalar*>(m_d.data)[index]; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Scalar& coeffRef(Index index) {
+    return const_cast<Scalar*>(m_d.data)[index];
+  }
 
   template <int LoadMode, typename PacketType>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
@@ -251,9 +252,10 @@ 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;
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator() {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr evaluator() = default;
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& m) : evaluator<PlainObjectBase<XprType>>(m) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr explicit evaluator(const XprType& m)
+      : evaluator<PlainObjectBase<XprType>>(m) {}
 };
 
 template <typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
@@ -261,9 +263,10 @@ 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;
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator() {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr evaluator() = default;
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& m) : evaluator<PlainObjectBase<XprType>>(m) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr explicit evaluator(const XprType& m)
+      : evaluator<PlainObjectBase<XprType>>(m) {}
 };
 
 // -------------------- Transpose --------------------

{pyvpmr-241011 → pyvpmr-241217}/eigen/Eigen/src/Core/CwiseNullaryOp.h

@@ -71,6 +71,10 @@ class CwiseNullaryOp : public internal::dense_xpr_base<CwiseNullaryOp<NullaryOp,
     eigen_assert(rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && cols >= 0 &&
                  (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
   }
+  EIGEN_DEVICE_FUNC CwiseNullaryOp(Index size, const NullaryOp& func = NullaryOp())
+      : CwiseNullaryOp(RowsAtCompileTime == 1 ? 1 : size, RowsAtCompileTime == 1 ? size : 1, func) {
+    EIGEN_STATIC_ASSERT(CwiseNullaryOp::IsVectorAtCompileTime, YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX);
+  }
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index rows() const { return m_rows.value(); }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index cols() const { return m_cols.value(); }
@@ -343,7 +347,8 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void DenseBase<Derived>::fill(const Scalar
  */
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& val) {
-  return derived() = Constant(rows(), cols(), val);
+  internal::eigen_fill_impl<Derived>::run(derived(), val);
+  return derived();
 }
 
 /** Resizes to the given \a size, and sets all coefficients in this expression to the given value \a val.
@@ -479,9 +484,9 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setEqualSpace
  * \sa Zero(), Zero(Index)
  */
 template <typename Derived>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType DenseBase<Derived>::Zero(
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ZeroReturnType DenseBase<Derived>::Zero(
     Index rows, Index cols) {
-  return Constant(rows, cols, Scalar(0));
+  return ZeroReturnType(rows, cols);
 }
 
 /** \returns an expression of a zero vector.
@@ -501,9 +506,9 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::Constan
  * \sa Zero(), Zero(Index,Index)
  */
 template <typename Derived>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType DenseBase<Derived>::Zero(
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ZeroReturnType DenseBase<Derived>::Zero(
     Index size) {
-  return Constant(size, Scalar(0));
+  return ZeroReturnType(size);
 }
 
 /** \returns an expression of a fixed-size zero matrix or vector.
@@ -517,8 +522,8 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::Constan
  * \sa Zero(Index), Zero(Index,Index)
  */
 template <typename Derived>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType DenseBase<Derived>::Zero() {
-  return Constant(Scalar(0));
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ZeroReturnType DenseBase<Derived>::Zero() {
+  return ZeroReturnType(RowsAtCompileTime, ColsAtCompileTime);
 }
 
 /** \returns true if *this is approximately equal to the zero matrix,
@@ -547,7 +552,8 @@ EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isZero(const RealScalar& prec) const
  */
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero() {
-  return setConstant(Scalar(0));
+  internal::eigen_zero_impl<Derived>::run(derived());
+  return derived();
 }
 
 /** Resizes to the given \a size, and sets all coefficients in this expression to zero.
@@ -562,7 +568,7 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero() {
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& PlainObjectBase<Derived>::setZero(Index newSize) {
   resize(newSize);
-  return setConstant(Scalar(0));
+  return setZero();
 }
 
 /** Resizes to the given size, and sets all coefficients in this expression to zero.
@@ -578,7 +584,7 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& PlainObjectBase<Derived>::setZero
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& PlainObjectBase<Derived>::setZero(Index rows, Index cols) {
   resize(rows, cols);
-  return setConstant(Scalar(0));
+  return setZero();
 }
 
 /** Resizes to the given size, changing only the number of columns, and sets all