Integrate Refactor solver sources and dual MSVC CMake builds

include/fesa/solvers/eigen/eigen_solver.h

@@ -0,0 +1,99 @@
+#ifndef FESA_SOLVERS_EIGEN_EIGEN_SOLVER_H_
+#define FESA_SOLVERS_EIGEN_EIGEN_SOLVER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "fesa/core/status.h"
+#include "fesa/math/matrix.h"
+
+namespace fesa {
+
+class SparseMatrix;
+
+/// @brief Records one deterministic private-backend invocation.
+struct FeastBackendCall {
+  std::size_t ordinal;
+  std::string kind;
+  std::string purpose;
+  double lower;
+  double upper;
+  std::size_t allocated_m0;
+  int info;
+  bool count_available;
+  std::size_t count;
+  bool loop_available;
+  int loop;
+  bool epsout_available;
+  double epsout;
+  std::string outcome;
+  std::string decision_reason;
+};
+
+/// @brief Owns the complete validated FEAST interval result before public N
+/// selection.
+struct FeastEigenResult {
+  std::size_t requested_modes;
+  std::vector<double> eigenvalues;
+  Matrix eigenvectors;
+  double operator_scale;
+  std::vector<std::size_t> column_ids;
+  std::vector<bool> backend_res_available;
+  std::vector<double> backend_res;
+  std::vector<double> normalized_eigenvalues;
+  std::vector<double> whitened_residuals;
+  double gram_error;
+  std::vector<FeastBackendCall> backend_calls;
+  std::vector<std::int64_t> base_fpm;
+  std::string runtime_version;
+  std::string integer_abi;
+  std::size_t thread_count;
+  std::uint64_t seed;
+  double enclosure_lower;
+  double enclosure_upper;
+  double solve_lower;
+  double solve_upper;
+  std::string upper_search_termination;
+};
+
+/// @brief Solves symmetric standard or definite generalized eigenproblems.
+/// @note Inputs remain caller-owned and are borrowed only for each call.
+class EigenSolver {
+ public:
+  /// @brief Destroys a backend-neutral eigen solver.
+  virtual ~EigenSolver() = default;
+
+  /// @brief Computes all validated interval pairs for a requested lowest-mode
+  /// prefix.
+  /// @param whitened_operator Symmetric physical-lambda operator after
+  /// whitening.
+  /// @param requested_modes Number of lowest modes eventually exposed by the
+  /// caller.
+  /// @param zero_operator_scale Positive physical scale used only when A is
+  /// exactly zero.
+  /// @return Sorted all-c eigenpairs in physical lambda units or a solver
+  /// failure.
+  virtual Result<FeastEigenResult> Solve(
+      const SparseMatrix& whitened_operator, std::size_t requested_modes,
+      double zero_operator_scale) const = 0;
+
+  /// @brief Solves the original sparse symmetric definite K/M pencil.
+  /// @param mass_lower_bound Certified positive lower spectral bound of M,
+  /// including floating-point assembly uncertainty; never a diagonal estimate.
+  /// @param classification_scale Positive max |Kii|/Mii in physical units.
+  /// @note Eigenvectors are mass-normalized. For this API the historical
+  /// whitened_residuals field contains original-pencil eta_r; no whitening
+  /// is performed. Intervals/eigenvalues in normalized backend evidence use
+  /// classification_scale, while eigenvalues are returned in physical units.
+  virtual Result<FeastEigenResult> SolveGeneralized(
+      const SparseMatrix& stiffness, const SparseMatrix& mass,
+      std::size_t requested_modes, double mass_lower_bound,
+      double classification_scale) const = 0;
+
+};
+
+}  // namespace fesa
+
+#endif  // FESA_SOLVERS_EIGEN_EIGEN_SOLVER_H_