基于Eigen3的无矩阵算子特征值求解及实现验证咨询

Great question! Let's break this down clearly based on what you're trying to do:

First off: Eigen3's core, supported modules don't offer out-of-the-box matrix-free full eigenvalue solving. All its standard eigenvalue solvers (like Eigen::EigenSolver or Eigen::SelfAdjointEigenSolver) are built to work with explicitly stored matrices. That said, there's a workaround if you only need a subset of eigenvalues (like the largest/smallest in magnitude, or extreme values for symmetric matrices):

Eigen's unsupported module includes ArnoldiMethod (for general matrices) and SymmetricArnoldiMethod (for symmetric/Hermitian cases), which do support matrix-free operations. You just need to define how your linear transformation acts on a vector—either by overloading operator* for a custom type, or writing a function that takes a vector and returns the transformed result. Here's a quick code sketch to illustrate:

// Define your matrix-free linear transformation
struct MyCustomTransform {
    template <typename VectorType>
    VectorType operator*(const VectorType& v) const {
        VectorType result(v.size());
        // Replace this with your actual Ax computation logic
        // No explicit matrix storage needed here!
        result(0) = 2*v(0) + v(1);
        result(1) = v(0) + 3*v(1);
        return result;
    }
};

int main() {
    const int dim = 2;
    MyCustomTransform my_transform;

    // Use Arnoldi to compute 2 eigenvalues
    Eigen::ArnoldiMethod<MyCustomTransform> arnoldi(dim);
    arnoldi.compute(my_transform, 2);
    
    auto computed_eigs = arnoldi.eigenvalues();
    // Compare these to your analytical solution here
    return 0;
}

If you need full eigenvalue computation in a matrix-free setup, Eigen isn't the right tool—full eigenvalue solvers rely heavily on matrix decomposition operations that are hard to implement efficiently without explicit storage. For that, here are my top recommendations:

• SLEPc: A specialized library for large-scale sparse and matrix-free linear algebra, with a huge range of eigenvalue solvers (both partial and full). It only requires you to implement the matrix-vector multiply operation, making it perfect for scientific computing use cases.
• PETSc: Often paired with SLEPc, PETSc has its own eigenvalue modules and robust support for matrix-free operations. It's a mature, well-documented ecosystem for large-scale numerical problems.
• ARPACK: A classic, lightweight iterative eigenvalue library that's focused on partial eigenvalue solving in matrix-free scenarios. Many tools (including Eigen's Arnoldi implementation) draw inspiration from ARPACK, and it's easy to integrate if you don't need the full feature set of SLEPc/PETSc.

One quick side note: For small-dimensional problems, it's usually easier and more efficient to just construct an explicit matrix and use Eigen's standard solvers—storage overhead is negligible, and you'll get exact (or near-exact) eigenvalues faster than iterative methods.

内容的提问来源于stack exchange，提问作者user5224720