rename matching name and type

ginkgo-project · Nov 2, 2023 · db8963e · db8963e
1 parent 0328da6
commit db8963e
Show file tree

Hide file tree

Showing 7 changed files with 25 additions and 26 deletions.
diff --git a/benchmark/solver/solver_common.hpp b/benchmark/solver/solver_common.hpp
@@ -247,15 +247,14 @@ std::unique_ptr<gko::LinOpFactory> generate_solver(
             .with_factorization(
                 gko::experimental::factorization::Lu<etype, itype>::build()
                     .with_symbolic_algorithm(gko::experimental::factorization::
-                                                 symbolic_algorithm::symmetric))
+                                                 symbolic_type::symmetric))
             .on(exec);
     } else if (description == "near_symm_direct") {
         return gko::experimental::solver::Direct<etype, itype>::build()
             .with_factorization(
                 gko::experimental::factorization::Lu<etype, itype>::build()
-                    .with_symbolic_algorithm(
-                        gko::experimental::factorization::symbolic_algorithm::
-                            near_symmetric))
+                    .with_symbolic_algorithm(gko::experimental::factorization::
+                                                 symbolic_type::near_symmetric))
             .on(exec);
     } else if (description == "direct") {
         return gko::experimental::solver::Direct<etype, itype>::build()

diff --git a/core/factorization/lu.cpp b/core/factorization/lu.cpp
@@ -98,13 +98,13 @@ std::unique_ptr<LinOp> Lu<ValueType, IndexType>::generate_impl(
     std::unique_ptr<matrix_type> factors;
     if (!parameters_.symbolic_factorization) {
         switch (parameters_.symbolic_algorithm) {
-        case symbolic_algorithm::general:
+        case symbolic_type::general:
             exec->run(make_symbolic_lu(mtx.get(), factors));
             break;
-        case symbolic_algorithm::near_symmetric:
+        case symbolic_type::near_symmetric:
             exec->run(make_symbolic_lu_near_symm(mtx.get(), factors));
             break;
-        case symbolic_algorithm::symmetric: {
+        case symbolic_type::symmetric: {
             std::unique_ptr<gko::factorization::elimination_forest<IndexType>>
                 forest;
             exec->run(make_symbolic_cholesky(mtx.get(), true, factors, forest));

diff --git a/include/ginkgo/core/factorization/lu.hpp b/include/ginkgo/core/factorization/lu.hpp
@@ -46,7 +46,7 @@ namespace experimental {
 namespace factorization {
 
 
-enum class symbolic_algorithm {
+enum class symbolic_type {
     /** An LU factorization algorithm that works on all matrices. */
     general,
     /**
@@ -109,8 +109,8 @@ class Lu
          * @note Only use symbolic_factorization_algorithm::symmetric if you are
          *       sure your matrix has a symmetric sparsity pattern!
          */
-        symbolic_algorithm GKO_FACTORY_PARAMETER_SCALAR(
-            symbolic_algorithm, symbolic_algorithm::general);
+        symbolic_type GKO_FACTORY_PARAMETER_SCALAR(symbolic_algorithm,
+                                                   symbolic_type::general);
 
         /**
          * The `system_matrix`, which will be given to this factory, must be

diff --git a/reference/test/factorization/lu_kernels.cpp b/reference/test/factorization/lu_kernels.cpp
@@ -266,7 +266,7 @@ TYPED_TEST(Lu, FactorizeSymmetricWorks)
                 gko::experimental::factorization::Lu<value_type,
                                                      index_type>::build()
                     .with_symbolic_algorithm(gko::experimental::factorization::
-                                                 symbolic_algorithm::symmetric)
+                                                 symbolic_type::symmetric)
                     .on(this->ref);
 
             auto lu = factory->generate(this->mtx);
@@ -292,8 +292,8 @@ TYPED_TEST(Lu, FactorizeNonsymmetricWorks)
         auto factory =
             gko::experimental::factorization::Lu<value_type,
                                                  index_type>::build()
-                .with_symbolic_algorithm(gko::experimental::factorization::
-                                             symbolic_algorithm::general)
+                .with_symbolic_algorithm(
+                    gko::experimental::factorization::symbolic_type::general)
                 .on(this->ref);
 
         auto lu = factory->generate(this->mtx);
@@ -319,7 +319,7 @@ TYPED_TEST(Lu, FactorizeNearSymmetricWorks)
             gko::experimental::factorization::Lu<value_type,
                                                  index_type>::build()
                 .with_symbolic_algorithm(gko::experimental::factorization::
-                                             symbolic_algorithm::near_symmetric)
+                                             symbolic_type::near_symmetric)
                 .on(this->ref);
 
         auto lu = factory->generate(this->mtx);

diff --git a/reference/test/solver/direct.cpp b/reference/test/solver/direct.cpp
@@ -78,8 +78,8 @@ class Direct : public ::testing::Test {
                     gko::experimental::factorization::Lu<value_type,
                                                          index_type>::build()
                         .with_symbolic_algorithm(
-                            gko::experimental::factorization::
-                                symbolic_algorithm::symmetric))
+                            gko::experimental::factorization::symbolic_type::
+                                symmetric))
                 .on(exec);
         solver = factory->generate(mtx);
         std::normal_distribution<gko::remove_complex<value_type>> dist(0, 1);

diff --git a/test/factorization/lu_kernels.cpp b/test/factorization/lu_kernels.cpp
@@ -289,14 +289,14 @@ TYPED_TEST(Lu, GenerateSymmWithUnknownSparsityIsEquivalentToRef)
         auto factory =
             gko::experimental::factorization::Lu<value_type,
                                                  index_type>::build()
-                .with_symbolic_algorithm(gko::experimental::factorization::
-                                             symbolic_algorithm::symmetric)
+                .with_symbolic_algorithm(
+                    gko::experimental::factorization::symbolic_type::symmetric)
                 .on(this->ref);
         auto dfactory =
             gko::experimental::factorization::Lu<value_type,
                                                  index_type>::build()
-                .with_symbolic_algorithm(gko::experimental::factorization::
-                                             symbolic_algorithm::symmetric)
+                .with_symbolic_algorithm(
+                    gko::experimental::factorization::symbolic_type::symmetric)
                 .on(this->exec);
 
         auto lu = factory->generate(this->mtx);
@@ -318,13 +318,13 @@ TYPED_TEST(Lu, GenerateNearSymmWithUnknownSparsityIsEquivalentToRef)
             gko::experimental::factorization::Lu<value_type,
                                                  index_type>::build()
                 .with_symbolic_algorithm(gko::experimental::factorization::
-                                             symbolic_algorithm::near_symmetric)
+                                             symbolic_type::near_symmetric)
                 .on(this->ref);
         auto dfactory =
             gko::experimental::factorization::Lu<value_type,
                                                  index_type>::build()
                 .with_symbolic_algorithm(gko::experimental::factorization::
-                                             symbolic_algorithm::near_symmetric)
+                                             symbolic_type::near_symmetric)
                 .on(this->exec);
 
         auto lu = factory->generate(this->mtx);

diff --git a/test/solver/direct.cpp b/test/solver/direct.cpp
@@ -96,8 +96,8 @@ class Direct : public CommonTestFixture {
         factory = solver_type::build()
                       .with_factorization(
                           factorization_type::build().with_symbolic_algorithm(
-                              gko::experimental::factorization::
-                                  symbolic_algorithm::symmetric))
+                              gko::experimental::factorization::symbolic_type::
+                                  symmetric))
                       .with_num_rhs(static_cast<gko::size_type>(nrhs))
                       .on(ref);
         alpha = gen_mtx(1, 1);
@@ -107,8 +107,8 @@ class Direct : public CommonTestFixture {
         dfactory = solver_type::build()
                        .with_factorization(
                            factorization_type::build().with_symbolic_algorithm(
-                               gko::experimental::factorization::
-                                   symbolic_algorithm::symmetric))
+                               gko::experimental::factorization::symbolic_type::
+                                   symmetric))
                        .with_num_rhs(static_cast<gko::size_type>(nrhs))
                        .on(exec);
         dalpha = gko::clone(exec, alpha);