generalizedeigensolverfactory.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2025 The Ikarus Developers ikarus@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <ikarus/solver/eigenvaluesolver/generalizedeigensolver.hh>
 
namespace Ikarus {
 
template <EigenValueSolverType tag, typename MATA, typename MATB>
requires(Concepts::DenseOrSparseEigenMatrix<std::remove_cvref_t<MATA>> &&
         std::same_as<std::remove_cvref_t<MATA>, std::remove_cvref_t<MATB>> &&
         not(tag == EigenValueSolverType::Eigen && Concepts::SparseEigenMatrix<std::remove_cvref_t<MATA>>))
auto makeGeneralizedSymEigenSolver(MATA&& A, MATB&& B) {
  using MatrixType = std::remove_cvref_t<MATA>;
  return GeneralizedSymEigenSolver<tag, MatrixType>{std::forward<MATA>(A), std::forward<MATB>(B)};
}
 
template <EigenValueSolverType tag, Concepts::FlatAssembler AssemblerA, Concepts::FlatAssembler AssemblerB>
requires(std::same_as<typename AssemblerA::MatrixType, typename AssemblerB::MatrixType> &&
         not(tag == EigenValueSolverType::Eigen && Concepts::SparseEigenMatrix<typename AssemblerA::MatrixType>))
auto makeGeneralizedSymEigenSolver(const std::shared_ptr<AssemblerA> assemblerA,
                                   const std::shared_ptr<AssemblerB> assemblerB) {
  makeGeneralizedSymEigenSolver(assemblerA->matrix(), assemblerB->matrix());
}
 
template <EigenValueSolverType tag, typename MATA>
requires(Concepts::DenseOrSparseEigenMatrix<std::remove_cvref_t<MATA>> &&
         not(tag == EigenValueSolverType::Eigen && Concepts::SparseEigenMatrix<std::remove_cvref_t<MATA>>))
auto makeIdentitySymEigenSolver(MATA&& A) {
  using MatrixType = std::remove_cvref_t<MATA>;
  MatrixType I     = MatrixType(A.rows(), A.cols());
  I.setIdentity();
 
  return GeneralizedSymEigenSolver<tag, MatrixType>{std::forward<MATA>(A), I};
}
 
template <EigenValueSolverType tag, Concepts::FlatAssembler AssemblerA>
requires(Concepts::DenseOrSparseEigenMatrix<typename AssemblerA::MatrixType> &&
         not(tag == EigenValueSolverType::Eigen && Concepts::SparseEigenMatrix<typename AssemblerA::MatrixType>))
auto makeIdentitySymEigenSolver(const std::shared_ptr<AssemblerA>& assemblerA) {
  return makeIdentitySymEigenSolver<tag>(assemblerA->matrix());
}
 
template <Concepts::FlatAssembler AssemblerA, Concepts::FlatAssembler AssemblerB>
requires(std::same_as<typename AssemblerA::MatrixType, typename AssemblerB::MatrixType>)
auto makePartialGeneralizedSymEigenSolver(std::shared_ptr<AssemblerA> assemblerA,
                                          std::shared_ptr<AssemblerB> assemblerB, Eigen::Index nev) {
  return makePartialGeneralizedSymEigenSolver(assemblerA->matrix(), assemblerB->matrix());
}
 
template <typename MATA, typename MATB>
requires(Concepts::DenseOrSparseEigenMatrix<std::remove_cvref_t<MATA>> &&
         std::same_as<std::remove_cvref_t<MATA>, std::remove_cvref_t<MATB>>)
auto makePartialGeneralizedSymEigenSolver(MATA&& A, MATB&& B, Eigen::Index nev) {
  using MatrixType = std::remove_cvref_t<MATA>;
  return PartialGeneralizedSymEigenSolver<MatrixType>{std::forward<MATA>(A), std::forward<MATB>(B), nev};
}
 
template <typename MATA>
requires(Concepts::DenseOrSparseEigenMatrix<std::remove_cvref_t<MATA>>)
auto makePartialIdentitySymEigenSolver(MATA&& A, Eigen::Index nev) {
  using MatrixType = std::remove_cvref_t<MATA>;
  MatrixType I     = MatrixType(A.rows(), A.cols());
  I.setIdentity();
 
  return PartialGeneralizedSymEigenSolver<MatrixType>{std::forward<MATA>(A), I, nev};
}
 
template <Concepts::FlatAssembler AssemblerA>
auto makePartialIdentitySymEigenSolver(const std::shared_ptr<AssemblerA>& assemblerA, Eigen::Index nev) {
  return makePartialIdentitySymEigenSolver(assemblerA->matrix(), nev);
}
 
} // namespace Ikarus