add minres config parsing

Author: MarcelKoch

core/config/config_helper.hpp

@@ -49,6 +49,7 @@ enum class LinOpFactoryType : int {
     Gcr,
     Gmres,
     CbGmres,
+    Minres,
     Direct,
     LowerTrs,
     UpperTrs,

core/config/registry.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -29,6 +29,7 @@ configuration_map generate_config_map()
             {"solver::Gcr", parse<LinOpFactoryType::Gcr>},
             {"solver::Gmres", parse<LinOpFactoryType::Gmres>},
             {"solver::CbGmres", parse<LinOpFactoryType::CbGmres>},
+            {"solver::Minres", parse<LinOpFactoryType::Minres>},
             {"solver::Direct", parse<LinOpFactoryType::Direct>},
             {"solver::LowerTrs", parse<LinOpFactoryType::LowerTrs>},
             {"solver::UpperTrs", parse<LinOpFactoryType::UpperTrs>},

core/config/solver_config.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -18,6 +18,7 @@
 #include <ginkgo/core/solver/gmres.hpp>
 #include <ginkgo/core/solver/idr.hpp>
 #include <ginkgo/core/solver/ir.hpp>
+#include <ginkgo/core/solver/minres.hpp>
 #include <ginkgo/core/solver/multigrid.hpp>
 #include <ginkgo/core/solver/triangular.hpp>
 
@@ -40,6 +41,7 @@ GKO_PARSE_VALUE_TYPE(Idr, gko::solver::Idr);
 GKO_PARSE_VALUE_TYPE(Gcr, gko::solver::Gcr);
 GKO_PARSE_VALUE_TYPE(Gmres, gko::solver::Gmres);
 GKO_PARSE_VALUE_TYPE_BASE(CbGmres, gko::solver::CbGmres);
+GKO_PARSE_VALUE_TYPE(Minres, gko::solver::Minres);
 GKO_PARSE_VALUE_AND_INDEX_TYPE(Direct, gko::experimental::solver::Direct);
 GKO_PARSE_VALUE_AND_INDEX_TYPE(LowerTrs, gko::solver::LowerTrs);
 GKO_PARSE_VALUE_AND_INDEX_TYPE(UpperTrs, gko::solver::UpperTrs);

core/solver/minres.cpp

@@ -12,6 +12,7 @@
 #include <ginkgo/core/base/precision_dispatch.hpp>
 #include <ginkgo/core/solver/minres.hpp>
 
+#include "core/config/solver_config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/minres_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
@@ -58,6 +59,13 @@ std::unique_ptr<LinOp> Minres<ValueType>::conj_transpose() const
 }
 
 
+template <typename ValueType>
+bool Minres<ValueType>::apply_uses_initial_guess() const
+{
+    return true;
+}
+
+
 template <typename ValueType>
 void Minres<ValueType>::apply_impl(const LinOp* b, LinOp* x) const
 {
@@ -72,6 +80,17 @@ void Minres<ValueType>::apply_impl(const LinOp* b, LinOp* x) const
 }
 
 
+template <typename ValueType>
+typename Minres<ValueType>::parameters_type Minres<ValueType>::parse(
+    const config::pnode& config, const config::registry& context,
+    const config::type_descriptor& td_for_child)
+{
+    auto params = Minres::build();
+    common_solver_parse(params, config, context, td_for_child);
+    return params;
+}
+
+
 /**
  * This Minres implementation is based on Anne Grennbaum's 'Iterative Methods
  * for Solving Linear Systems' (DOI: 10.1137/1.9781611970937) Ch. 2 and Ch. 8.
@@ -281,6 +300,23 @@ void Minres<ValueType>::apply_impl(const LinOp* alpha, const LinOp* b,
 }
 
 
+template <typename ValueType>
+Minres<ValueType>::Minres(std::shared_ptr<const Executor> exec)
+    : EnableLinOp<Minres>(std::move(exec))
+{}
+
+
+template <typename ValueType>
+Minres<ValueType>::Minres(const Factory* factory,
+                          std::shared_ptr<const LinOp> system_matrix)
+    : EnableLinOp<Minres>(factory->get_executor(),
+                          gko::transpose(system_matrix->get_size())),
+      EnablePreconditionedIterativeSolver<ValueType, Minres>{
+          std::move(system_matrix), factory->get_parameters()},
+      parameters_{factory->get_parameters()}
+{}
+
+
 template <typename ValueType>
 int workspace_traits<Minres<ValueType>>::num_vectors(const Solver&)
 {

core/test/config/solver.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -20,6 +20,7 @@
 #include <ginkgo/core/solver/gmres.hpp>
 #include <ginkgo/core/solver/idr.hpp>
 #include <ginkgo/core/solver/ir.hpp>
+#include <ginkgo/core/solver/minres.hpp>
 #include <ginkgo/core/solver/triangular.hpp>
 #include <ginkgo/core/stop/iteration.hpp>
 
@@ -340,6 +341,15 @@ struct CbGmres : SolverConfigTest<gko::solver::CbGmres<float>,
 };
 
 
+struct Minres : SolverConfigTest<gko::solver::Minres<float>,
+                                 gko::solver::Minres<double>> {
+    static pnode::map_type setup_base()
+    {
+        return {{"type", pnode{"solver::Minres"}}};
+    }
+};
+
+
 struct Direct
     : SolverConfigTest<gko::experimental::solver::Direct<float, int>,
                        gko::experimental::solver::Direct<double, int>> {
@@ -468,7 +478,8 @@ class Solver : public ::testing::Test {
 
 using SolverTypes =
     ::testing::Types<::Cg, ::Fcg, ::Cgs, ::Bicg, ::Bicgstab, ::Ir, ::Idr, ::Gcr,
-                     ::Gmres, ::CbGmres, ::Direct, ::LowerTrs, ::UpperTrs>;
+                     ::Gmres, ::CbGmres, ::Minres, ::Direct, ::LowerTrs,
+                     ::UpperTrs>;
 
 
 TYPED_TEST_SUITE(Solver, SolverTypes, TypenameNameGenerator);

include/ginkgo/core/solver/minres.hpp

@@ -13,6 +13,9 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/property_tree.hpp>
+#include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/config/type_descriptor.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/solver/solver_base.hpp>
 #include <ginkgo/core/stop/combined.hpp>
@@ -25,7 +28,7 @@ namespace solver {
 
 /**
  * Minres is an iterative type Krylov subspace method, which is suitable for
- * indefinite and full-rank symmetric/hermitian operators. It is an
+ * indefinite and full-rank symmetric/hermitian operators. It is a
  * specialization of the Gmres method for symmetric/hermitian operators, and can
  * be computed using short recurrences, similar to the CG method.
  *
@@ -68,10 +71,8 @@ class Minres
 
     /**
      * Return true as iterative solvers use the data in x as an initial guess.
-     *
-     * @return true as iterative solvers use the data in x as an initial guess.
      */
-    bool apply_uses_initial_guess() const override { return true; }
+    bool apply_uses_initial_guess() const override;
 
     class Factory;
 
@@ -82,6 +83,24 @@ class Minres
     GKO_ENABLE_LIN_OP_FACTORY(Minres, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    /**
+     * Create the parameters from the property_tree.
+     * Because this is directly tied to the specific type, the value/index type
+     * settings within config are ignored and type_descriptor is only used
+     * for children configs.
+     *
+     * @param config  the property tree for setting
+     * @param context  the registry
+     * @param td_for_child  the type descriptor for children configs. The
+     *                      default uses the value type of this class.
+     *
+     * @return parameters
+     */
+    static parameters_type parse(const config::pnode& config,
+                                 const config::registry& context,
+                                 const config::type_descriptor& td_for_child =
+                                     config::make_type_descriptor<ValueType>());
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
@@ -91,18 +110,10 @@ class Minres
     void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
                     LinOp* x) const override;
 
-    explicit Minres(std::shared_ptr<const Executor> exec)
-        : EnableLinOp<Minres>(std::move(exec))
-    {}
+    explicit Minres(std::shared_ptr<const Executor> exec);
 
     explicit Minres(const Factory* factory,
-                    std::shared_ptr<const LinOp> system_matrix)
-        : EnableLinOp<Minres>(factory->get_executor(),
-                              gko::transpose(system_matrix->get_size())),
-          EnablePreconditionedIterativeSolver<ValueType, Minres>{
-              std::move(system_matrix), factory->get_parameters()},
-          parameters_{factory->get_parameters()}
-    {}
+                    std::shared_ptr<const LinOp> system_matrix);
 };