pyvpmr 240921__tar.gz → 241011__tar.gz

{pyvpmr-240921 → pyvpmr-241011}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyvpmr
-Version: 240921
+Version: 241011
 Summary: The VPMR Algorithm
 Author-email: Theodore Chang <tlcfem@gmail.com>
 Maintainer-email: Theodore Chang <tlcfem@gmail.com>
@@ -694,6 +694,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
@@ -816,6 +817,8 @@ 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

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

@@ -113,6 +113,8 @@ 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

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/ArrayWrapper.h

@@ -65,8 +65,8 @@ class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> > {
     return m_expression.innerStride();
   }
 
-  EIGEN_DEVICE_FUNC inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
-  EIGEN_DEVICE_FUNC inline const Scalar* data() const { return m_expression.data(); }
+  EIGEN_DEVICE_FUNC constexpr ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
+  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const { return m_expression.data(); }
 
   EIGEN_DEVICE_FUNC inline const Scalar& coeffRef(Index rowId, Index colId) const {
     return m_expression.coeffRef(rowId, colId);
@@ -144,8 +144,8 @@ class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> > {
     return m_expression.innerStride();
   }
 
-  EIGEN_DEVICE_FUNC inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
-  EIGEN_DEVICE_FUNC inline const Scalar* data() const { return m_expression.data(); }
+  EIGEN_DEVICE_FUNC constexpr ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
+  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const { return m_expression.data(); }
 
   EIGEN_DEVICE_FUNC inline const Scalar& coeffRef(Index rowId, Index colId) const {
     return m_expression.derived().coeffRef(rowId, colId);

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/Block.h

@@ -278,7 +278,7 @@ class BlockImpl_dense : public internal::dense_xpr_base<Block<XprType, BlockRows
 
 #ifdef EIGEN_PARSED_BY_DOXYGEN
   /** \sa MapBase::data() */
-  EIGEN_DEVICE_FUNC inline const Scalar* data() const;
+  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const;
   EIGEN_DEVICE_FUNC inline Index innerStride() const;
   EIGEN_DEVICE_FUNC inline Index outerStride() const;
 #endif

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

@@ -217,7 +217,7 @@ struct evaluator<PlainObjectBase<Derived>> : evaluator_base<Derived> {
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return const_cast<Scalar*>(m_d.data)[index]; }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     if (IsRowMajor)
       return ploadt<PacketType, LoadMode>(m_d.data + row * m_d.outerStride() + col);
     else
@@ -225,12 +225,12 @@ struct evaluator<PlainObjectBase<Derived>> : evaluator_base<Derived> {
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
     return ploadt<PacketType, LoadMode>(m_d.data + index);
   }
 
   template <int StoreMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
     if (IsRowMajor)
       return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_d.data) + row * m_d.outerStride() + col, x);
     else
@@ -238,7 +238,7 @@ struct evaluator<PlainObjectBase<Derived>> : evaluator_base<Derived> {
   }
 
   template <int StoreMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
     return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_d.data) + index, x);
   }
 
@@ -296,22 +296,22 @@ struct unary_evaluator<Transpose<ArgType>, IndexBased> : evaluator_base<Transpos
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     return m_argImpl.template packet<LoadMode, PacketType>(col, row);
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  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_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
     m_argImpl.template writePacket<StoreMode, PacketType>(col, row, x);
   }
 
   template <int StoreMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
     m_argImpl.template writePacket<StoreMode, PacketType>(index, x);
   }
 
@@ -490,12 +490,12 @@ struct evaluator<CwiseNullaryOp<NullaryOp, PlainObjectType>>
   }
 
   template <int LoadMode, typename PacketType, typename IndexType>
-  EIGEN_STRONG_INLINE PacketType packet(IndexType row, IndexType col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(IndexType row, IndexType col) const {
     return m_wrapper.template packetOp<PacketType>(m_functor, row, col);
   }
 
   template <int LoadMode, typename PacketType, typename IndexType>
-  EIGEN_STRONG_INLINE PacketType packet(IndexType index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(IndexType index) const {
     return m_wrapper.template packetOp<PacketType>(m_functor, index);
   }
 
@@ -534,12 +534,12 @@ struct unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IndexBased> : evaluator_b
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(row, col));
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
     return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(index));
   }
 
@@ -627,7 +627,7 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
   }
 
   template <int LoadMode, typename PacketType = SrcPacketType>
-  EIGEN_STRONG_INLINE PacketType srcPacket(Index row, Index col, Index offset) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType srcPacket(Index row, Index col, Index offset) const {
     constexpr int PacketSize = unpacket_traits<PacketType>::size;
     Index actualRow = IsRowMajor ? row : row + (offset * PacketSize);
     Index actualCol = IsRowMajor ? col + (offset * PacketSize) : col;
@@ -635,7 +635,7 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
     return m_argImpl.template packet<LoadMode, PacketType>(actualRow, actualCol);
   }
   template <int LoadMode, typename PacketType = SrcPacketType>
-  EIGEN_STRONG_INLINE PacketType srcPacket(Index index, Index offset) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType srcPacket(Index index, Index offset) const {
     constexpr int PacketSize = unpacket_traits<PacketType>::size;
     Index actualIndex = index + (offset * PacketSize);
     eigen_assert(check_array_bounds(actualIndex, PacketSize) && "Array index out of bounds");
@@ -652,7 +652,7 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
   // If not, perform full load. Otherwise, revert to a scalar loop to perform a partial load.
   // In either case, perform a vectorized cast of the source packet.
   template <int LoadMode, typename DstPacketType, AltSrcScalarOp<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
     constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size;
     constexpr int SrcBytesIncrement = DstPacketSize * sizeof(SrcType);
     constexpr int SrcLoadMode = plain_enum_min(SrcBytesIncrement, LoadMode);
@@ -669,7 +669,7 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
   }
   // Use the source packet type with the same size as DstPacketType, if it exists
   template <int LoadMode, typename DstPacketType, SrcPacketArgs1<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
     constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size;
     using SizedSrcPacketType = typename find_packet_by_size<SrcType, DstPacketSize>::type;
     constexpr int SrcBytesIncrement = DstPacketSize * sizeof(SrcType);
@@ -678,14 +678,14 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
   }
   // unpacket_traits<DstPacketType>::size == 2 * SrcPacketSize
   template <int LoadMode, typename DstPacketType, SrcPacketArgs2<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
     constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode);
     return pcast<SrcPacketType, DstPacketType>(srcPacket<SrcLoadMode>(row, col, 0),
                                                srcPacket<SrcLoadMode>(row, col, 1));
   }
   // unpacket_traits<DstPacketType>::size == 4 * SrcPacketSize
   template <int LoadMode, typename DstPacketType, SrcPacketArgs4<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
     constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode);
     return pcast<SrcPacketType, DstPacketType>(srcPacket<SrcLoadMode>(row, col, 0), srcPacket<SrcLoadMode>(row, col, 1),
                                                srcPacket<SrcLoadMode>(row, col, 2),
@@ -693,7 +693,7 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
   }
   // unpacket_traits<DstPacketType>::size == 8 * SrcPacketSize
   template <int LoadMode, typename DstPacketType, SrcPacketArgs8<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const {
     constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode);
     return pcast<SrcPacketType, DstPacketType>(
         srcPacket<SrcLoadMode>(row, col, 0), srcPacket<SrcLoadMode>(row, col, 1), srcPacket<SrcLoadMode>(row, col, 2),
@@ -703,7 +703,7 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
 
   // Analogous routines for linear access.
   template <int LoadMode, typename DstPacketType, AltSrcScalarOp<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
     constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size;
     constexpr int SrcBytesIncrement = DstPacketSize * sizeof(SrcType);
     constexpr int SrcLoadMode = plain_enum_min(SrcBytesIncrement, LoadMode);
@@ -719,7 +719,7 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
     return pcast<SrcPacketType, DstPacketType>(src);
   }
   template <int LoadMode, typename DstPacketType, SrcPacketArgs1<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
     constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size;
     using SizedSrcPacketType = typename find_packet_by_size<SrcType, DstPacketSize>::type;
     constexpr int SrcBytesIncrement = DstPacketSize * sizeof(SrcType);
@@ -727,18 +727,18 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
     return pcast<SizedSrcPacketType, DstPacketType>(srcPacket<SrcLoadMode, SizedSrcPacketType>(index, 0));
   }
   template <int LoadMode, typename DstPacketType, SrcPacketArgs2<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
     constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode);
     return pcast<SrcPacketType, DstPacketType>(srcPacket<SrcLoadMode>(index, 0), srcPacket<SrcLoadMode>(index, 1));
   }
   template <int LoadMode, typename DstPacketType, SrcPacketArgs4<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
     constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode);
     return pcast<SrcPacketType, DstPacketType>(srcPacket<SrcLoadMode>(index, 0), srcPacket<SrcLoadMode>(index, 1),
                                                srcPacket<SrcLoadMode>(index, 2), srcPacket<SrcLoadMode>(index, 3));
   }
   template <int LoadMode, typename DstPacketType, SrcPacketArgs8<DstPacketType> = true>
-  EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstPacketType packet(Index index) const {
     constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode);
     return pcast<SrcPacketType, DstPacketType>(srcPacket<SrcLoadMode>(index, 0), srcPacket<SrcLoadMode>(index, 1),
                                                srcPacket<SrcLoadMode>(index, 2), srcPacket<SrcLoadMode>(index, 3),
@@ -810,14 +810,14 @@ struct ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>, IndexBased
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode, PacketType>(row, col),
                                m_d.arg2Impl.template packet<LoadMode, PacketType>(row, col),
                                m_d.arg3Impl.template packet<LoadMode, PacketType>(row, col));
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
     return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode, PacketType>(index),
                                m_d.arg2Impl.template packet<LoadMode, PacketType>(index),
                                m_d.arg3Impl.template packet<LoadMode, PacketType>(index));
@@ -908,13 +908,13 @@ struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IndexBase
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode, PacketType>(row, col),
                                m_d.rhsImpl.template packet<LoadMode, PacketType>(row, col));
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType 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));
   }
@@ -1030,24 +1030,24 @@ struct mapbase_evaluator : evaluator_base<Derived> {
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return m_data[index * m_innerStride.value()]; }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     PointerType ptr = m_data + row * rowStride() + col * colStride();
     return internal::ploadt<PacketType, LoadMode>(ptr);
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
     return internal::ploadt<PacketType, LoadMode>(m_data + index * m_innerStride.value());
   }
 
   template <int StoreMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
     PointerType ptr = m_data + row * rowStride() + col * colStride();
     return internal::pstoret<Scalar, PacketType, StoreMode>(ptr, x);
   }
 
   template <int StoreMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
     internal::pstoret<Scalar, PacketType, StoreMode>(m_data + index * m_innerStride.value(), x);
   }
 
@@ -1217,12 +1217,12 @@ struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBa
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     return m_argImpl.template packet<LoadMode, PacketType>(m_startRow.value() + row, m_startCol.value() + col);
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
     if (ForwardLinearAccess)
       return m_argImpl.template packet<LoadMode, PacketType>(m_linear_offset.value() + index);
     else
@@ -1230,12 +1230,12 @@ struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBa
   }
 
   template <int StoreMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
     return m_argImpl.template writePacket<StoreMode, PacketType>(m_startRow.value() + row, m_startCol.value() + col, x);
   }
 
   template <int StoreMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
     if (ForwardLinearAccess)
       return m_argImpl.template writePacket<StoreMode, PacketType>(m_linear_offset.value() + index, x);
     else
@@ -1378,7 +1378,7 @@ struct unary_evaluator<Replicate<ArgType, RowFactor, ColFactor>>
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     const Index actual_row = internal::traits<XprType>::RowsAtCompileTime == 1 ? 0
                              : RowFactor == 1                                  ? row
                                                                                : row % m_rows.value();
@@ -1390,7 +1390,7 @@ struct unary_evaluator<Replicate<ArgType, RowFactor, ColFactor>>
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
     const Index actual_index = internal::traits<XprType>::RowsAtCompileTime == 1
                                    ? (ColFactor == 1 ? index : index % m_cols.value())
                                    : (RowFactor == 1 ? index : index % m_rows.value());
@@ -1435,22 +1435,22 @@ struct evaluator_wrapper_base : evaluator_base<XprType> {
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return m_argImpl.coeffRef(index); }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     return m_argImpl.template packet<LoadMode, PacketType>(row, col);
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  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_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
     m_argImpl.template writePacket<StoreMode>(row, col, x);
   }
 
   template <int StoreMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
     m_argImpl.template writePacket<StoreMode>(index, x);
   }
 
@@ -1532,7 +1532,7 @@ struct unary_evaluator<Reverse<ArgType, Direction>> : evaluator_base<Reverse<Arg
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
     enum {
       PacketSize = unpacket_traits<PacketType>::size,
       OffsetRow = ReverseRow && IsColMajor ? PacketSize : 1,
@@ -1544,14 +1544,14 @@ struct unary_evaluator<Reverse<ArgType, Direction>> : evaluator_base<Reverse<Arg
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
     enum { PacketSize = unpacket_traits<PacketType>::size };
     return preverse(
         m_argImpl.template packet<LoadMode, PacketType>(m_rows.value() * m_cols.value() - index - PacketSize));
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x) {
     // FIXME we could factorize some code with packet(i,j)
     enum {
       PacketSize = unpacket_traits<PacketType>::size,
@@ -1565,7 +1565,7 @@ struct unary_evaluator<Reverse<ArgType, Direction>> : evaluator_base<Reverse<Arg
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
     enum { PacketSize = unpacket_traits<PacketType>::size };
     m_argImpl.template writePacket<LoadMode>(m_rows.value() * m_cols.value() - index - PacketSize, preverse(x));
   }

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/DenseStorage.h

@@ -258,8 +258,8 @@ class DenseStorage<T, 0, Dynamic, Dynamic, Options_> {
     m_cols = cols;
     eigen_assert(m_rows * m_cols == 0 && "The number of rows times columns must equal the storage size.");
   }
-  EIGEN_DEVICE_FUNC const T* data() const { return nullptr; }
-  EIGEN_DEVICE_FUNC T* data() { return nullptr; }
+  EIGEN_DEVICE_FUNC constexpr const T* data() const { return nullptr; }
+  EIGEN_DEVICE_FUNC constexpr T* data() { return nullptr; }
 };
 
 template <typename T, int Rows_, int Options_>
@@ -288,8 +288,8 @@ class DenseStorage<T, 0, Rows_, Dynamic, Options_> {
     m_cols = cols;
     eigen_assert(Rows_ * m_cols == 0 && "The number of rows times columns must equal the storage size.");
   }
-  EIGEN_DEVICE_FUNC const T* data() const { return nullptr; }
-  EIGEN_DEVICE_FUNC T* data() { return nullptr; }
+  EIGEN_DEVICE_FUNC constexpr const T* data() const { return nullptr; }
+  EIGEN_DEVICE_FUNC constexpr T* data() { return nullptr; }
 };
 
 template <typename T, int Cols_, int Options_>
@@ -318,8 +318,8 @@ class DenseStorage<T, 0, Dynamic, Cols_, Options_> {
     m_rows = rows;
     eigen_assert(m_rows * Cols_ == 0 && "The number of rows times columns must equal the storage size.");
   }
-  EIGEN_DEVICE_FUNC const T* data() const { return nullptr; }
-  EIGEN_DEVICE_FUNC T* data() { return nullptr; }
+  EIGEN_DEVICE_FUNC constexpr const T* data() const { return nullptr; }
+  EIGEN_DEVICE_FUNC constexpr T* data() { return nullptr; }
 };
 
 // dynamic-size matrix with fixed-size storage
@@ -507,8 +507,8 @@ class DenseStorage<T, Dynamic, Dynamic, Dynamic, Options_> {
     m_rows = rows;
     m_cols = cols;
   }
-  EIGEN_DEVICE_FUNC const T* data() const { return m_data; }
-  EIGEN_DEVICE_FUNC T* data() { return m_data; }
+  EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data; }
+  EIGEN_DEVICE_FUNC constexpr T* data() { return m_data; }
 };
 
 // matrix with dynamic width and fixed height (so that matrix has dynamic size).
@@ -574,8 +574,8 @@ class DenseStorage<T, Dynamic, Rows_, Dynamic, Options_> {
     }
     m_cols = cols;
   }
-  EIGEN_DEVICE_FUNC const T* data() const { return m_data; }
-  EIGEN_DEVICE_FUNC T* data() { return m_data; }
+  EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data; }
+  EIGEN_DEVICE_FUNC constexpr T* data() { return m_data; }
 };
 
 // matrix with dynamic height and fixed width (so that matrix has dynamic size).
@@ -641,8 +641,8 @@ class DenseStorage<T, Dynamic, Dynamic, Cols_, Options_> {
     }
     m_rows = rows;
   }
-  EIGEN_DEVICE_FUNC const T* data() const { return m_data; }
-  EIGEN_DEVICE_FUNC T* data() { return m_data; }
+  EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data; }
+  EIGEN_DEVICE_FUNC constexpr T* data() { return m_data; }
 };
 
 }  // end namespace Eigen

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/GeneralProduct.h

@@ -229,7 +229,7 @@ struct gemv_static_vector_if;
 
 template <typename Scalar, int Size, int MaxSize>
 struct gemv_static_vector_if<Scalar, Size, MaxSize, false> {
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Scalar* data() {
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr Scalar* data() {
     eigen_internal_assert(false && "should never be called");
     return 0;
   }
@@ -237,19 +237,19 @@ struct gemv_static_vector_if<Scalar, Size, MaxSize, false> {
 
 template <typename Scalar, int Size>
 struct gemv_static_vector_if<Scalar, Size, Dynamic, true> {
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Scalar* data() { return 0; }
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr Scalar* data() { return 0; }
 };
 
 template <typename Scalar, int Size, int MaxSize>
 struct gemv_static_vector_if<Scalar, Size, MaxSize, true> {
 #if EIGEN_MAX_STATIC_ALIGN_BYTES != 0
   internal::plain_array<Scalar, internal::min_size_prefer_fixed(Size, MaxSize), 0, AlignedMax> m_data;
-  EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
+  EIGEN_STRONG_INLINE constexpr Scalar* data() { return m_data.array; }
 #else
   // Some architectures cannot align on the stack,
   // => let's manually enforce alignment by allocating more data and return the address of the first aligned element.
   internal::plain_array<Scalar, internal::min_size_prefer_fixed(Size, MaxSize) + EIGEN_MAX_ALIGN_BYTES, 0> m_data;
-  EIGEN_STRONG_INLINE Scalar* data() {
+  EIGEN_STRONG_INLINE constexpr Scalar* data() {
     return reinterpret_cast<Scalar*>((std::uintptr_t(m_data.array) & ~(std::size_t(EIGEN_MAX_ALIGN_BYTES - 1))) +
                                      EIGEN_MAX_ALIGN_BYTES);
   }

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/InnerProduct.h

@@ -85,13 +85,13 @@ struct inner_product_evaluator {
   }
 
   template <typename PacketType, int LhsMode = LhsAlignment, int RhsMode = RhsAlignment>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
     return m_func.packet(m_lhs.template packet<LhsMode, PacketType>(index),
                          m_rhs.template packet<RhsMode, PacketType>(index));
   }
 
   template <typename PacketType, int LhsMode = LhsAlignment, int RhsMode = RhsAlignment>
-  EIGEN_STRONG_INLINE PacketType packet(const PacketType& value, Index index) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(const PacketType& value, Index index) const {
     return m_func.packet(value, m_lhs.template packet<LhsMode, PacketType>(index),
                          m_rhs.template packet<RhsMode, PacketType>(index));
   }

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/Inverse.h

@@ -92,7 +92,7 @@ struct unary_evaluator<Inverse<ArgType> > : public evaluator<typename Inverse<Ar
 
   enum { Flags = Base::Flags | EvalBeforeNestingBit };
 
-  unary_evaluator(const InverseType& inv_xpr) : m_result(inv_xpr.rows(), inv_xpr.cols()) {
+  EIGEN_DEVICE_FUNC unary_evaluator(const InverseType& inv_xpr) : m_result(inv_xpr.rows(), inv_xpr.cols()) {
     internal::construct_at<Base>(this, m_result);
     internal::call_assignment_no_alias(m_result, inv_xpr);
   }

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/MapBase.h

@@ -94,7 +94,7 @@ class MapBase<Derived, ReadOnlyAccessors> : public internal::dense_xpr_base<Deri
    *
    * \sa innerStride(), outerStride()
    */
-  EIGEN_DEVICE_FUNC inline const Scalar* data() const { return m_data; }
+  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const { return m_data; }
 
   /** \copydoc PlainObjectBase::coeff(Index,Index) const */
   EIGEN_DEVICE_FUNC inline const Scalar& coeff(Index rowId, Index colId) const {
@@ -233,8 +233,8 @@ class MapBase<Derived, WriteAccessors> : public MapBase<Derived, ReadOnlyAccesso
 
   typedef std::conditional_t<internal::is_lvalue<Derived>::value, Scalar, const Scalar> ScalarWithConstIfNotLvalue;
 
-  EIGEN_DEVICE_FUNC inline const Scalar* data() const { return this->m_data; }
-  EIGEN_DEVICE_FUNC inline ScalarWithConstIfNotLvalue* data() {
+  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const { return this->m_data; }
+  EIGEN_DEVICE_FUNC constexpr ScalarWithConstIfNotLvalue* data() {
     return this->m_data;
   }  // no const-cast here so non-const-correct code will give a compile error
 

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/PlainObjectBase.h

@@ -270,10 +270,10 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
   }
 
   /** \returns a const pointer to the data array of this matrix */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* data() const { return m_storage.data(); }
+  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const { return m_storage.data(); }
 
   /** \returns a pointer to the data array of this matrix */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar* data() { return m_storage.data(); }
+  EIGEN_DEVICE_FUNC constexpr Scalar* data() { return m_storage.data(); }
 
   /** Resizes \c *this to a \a rows x \a cols matrix.
    *

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/Reshaped.h

@@ -173,7 +173,7 @@ class ReshapedImpl_dense<XprType, Rows, Cols, Order, false>
 
 #ifdef EIGEN_PARSED_BY_DOXYGEN
   /** \sa MapBase::data() */
-  EIGEN_DEVICE_FUNC inline const Scalar* data() const;
+  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const;
   EIGEN_DEVICE_FUNC inline Index innerStride() const;
   EIGEN_DEVICE_FUNC inline Index outerStride() const;
 #endif

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/Stride.h

@@ -70,6 +70,13 @@ class Stride {
   /** Copy constructor */
   EIGEN_DEVICE_FUNC Stride(const Stride& other) : m_outer(other.outer()), m_inner(other.inner()) {}
 
+  /** Copy assignment operator */
+  EIGEN_DEVICE_FUNC Stride& operator=(const Stride& other) {
+    m_outer.setValue(other.outer());
+    m_inner.setValue(other.inner());
+    return *this;
+  }
+
   /** \returns the outer stride */
   EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index outer() const { return m_outer.value(); }
   /** \returns the inner stride */

{pyvpmr-240921 → pyvpmr-241011}/eigen/Eigen/src/Core/Transpose.h

@@ -119,10 +119,12 @@ class TransposeImpl<MatrixType, Dense> : public internal::TransposeImpl_base<Mat
 
   typedef std::conditional_t<internal::is_lvalue<MatrixType>::value, Scalar, const Scalar> ScalarWithConstIfNotLvalue;
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ScalarWithConstIfNotLvalue* data() {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr ScalarWithConstIfNotLvalue* data() {
+    return derived().nestedExpression().data();
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr const Scalar* data() const {
     return derived().nestedExpression().data();
   }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 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 {