diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt index db7b304ed00..3027908f905 100644 --- a/core/CMakeLists.txt +++ b/core/CMakeLists.txt @@ -28,7 +28,7 @@ target_sources(ginkgo solver/fcg.cpp solver/gmres.cpp solver/ir.cpp - solver/trs.cpp + solver/lower_trs.cpp stop/combined.cpp stop/criterion.cpp stop/iteration.cpp diff --git a/core/device_hooks/common_kernels.inc.cpp b/core/device_hooks/common_kernels.inc.cpp index 3ef0093085b..ee19b5cd594 100644 --- a/core/device_hooks/common_kernels.inc.cpp +++ b/core/device_hooks/common_kernels.inc.cpp @@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "core/solver/fcg_kernels.hpp" #include "core/solver/gmres_kernels.hpp" #include "core/solver/ir_kernels.hpp" -#include "core/solver/trs_kernels.hpp" +#include "core/solver/lower_trs_kernels.hpp" #include "core/stop/criterion_kernels.hpp" #include "core/stop/residual_norm_reduction_kernels.hpp" @@ -182,21 +182,23 @@ GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_CG_STEP_2_KERNEL); } // namespace cg -namespace trs { +namespace lower_trs { template -GKO_DECLARE_TRS_GENERATE_KERNEL(ValueType, IndexType) +GKO_DECLARE_LOWER_TRS_GENERATE_KERNEL(ValueType, IndexType) GKO_NOT_COMPILED(GKO_HOOK_MODULE); -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS_GENERATE_KERNEL); +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( + GKO_DECLARE_LOWER_TRS_GENERATE_KERNEL); template -GKO_DECLARE_TRS_SOLVE_KERNEL(ValueType, IndexType) +GKO_DECLARE_LOWER_TRS_SOLVE_KERNEL(ValueType, IndexType) GKO_NOT_COMPILED(GKO_HOOK_MODULE); -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS_SOLVE_KERNEL); +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( + GKO_DECLARE_LOWER_TRS_SOLVE_KERNEL); -} // namespace trs +} // namespace lower_trs namespace fcg { diff --git a/core/solver/trs.cpp b/core/solver/lower_trs.cpp similarity index 75% rename from core/solver/trs.cpp rename to core/solver/lower_trs.cpp index 878b8e018f8..f2e1389452b 100644 --- a/core/solver/trs.cpp +++ b/core/solver/lower_trs.cpp @@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#include +#include #include @@ -43,26 +43,26 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -#include "core/solver/trs_kernels.hpp" +#include "core/solver/lower_trs_kernels.hpp" namespace gko { namespace solver { -namespace trs { +namespace lower_trs { -GKO_REGISTER_OPERATION(generate, trs::generate); -GKO_REGISTER_OPERATION(solve, trs::solve); +GKO_REGISTER_OPERATION(generate, lower_trs::generate); +GKO_REGISTER_OPERATION(solve, lower_trs::solve); -} // namespace trs +} // namespace lower_trs template -void Trs::generate(const LinOp *system_matrix, - const LinOp *b) +void LowerTrs::generate(const LinOp *system_matrix, + const LinOp *b) { using CsrMatrix = matrix::Csr; using Vector = matrix::Dense; @@ -77,12 +77,12 @@ void Trs::generate(const LinOp *system_matrix, copy_and_convert_to(exec, system_matrix); } auto dense_b = as(b); - exec->run(trs::make_generate(gko::lend(csr_system_matrix_), dense_b)); + exec->run(lower_trs::make_generate(gko::lend(csr_system_matrix_), dense_b)); } template -void Trs::apply_impl(const LinOp *b, LinOp *x) const +void LowerTrs::apply_impl(const LinOp *b, LinOp *x) const { using Vector = matrix::Dense; const auto exec = this->get_executor(); @@ -90,13 +90,16 @@ void Trs::apply_impl(const LinOp *b, LinOp *x) const auto dense_b = as(b); auto dense_x = as(x); - exec->run(trs::make_solve(gko::lend(csr_system_matrix_), dense_b, dense_x)); + exec->run( + lower_trs::make_solve(gko::lend(csr_system_matrix_), dense_b, dense_x)); } template -void Trs::apply_impl(const LinOp *alpha, const LinOp *b, - const LinOp *beta, LinOp *x) const +void LowerTrs::apply_impl(const LinOp *alpha, + const LinOp *b, + const LinOp *beta, + LinOp *x) const { auto dense_x = as>(x); @@ -107,8 +110,8 @@ void Trs::apply_impl(const LinOp *alpha, const LinOp *b, } -#define GKO_DECLARE_TRS(_vtype, _itype) class Trs<_vtype, _itype> -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS); +#define GKO_DECLARE_LOWER_TRS(_vtype, _itype) class LowerTrs<_vtype, _itype> +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_LOWER_TRS); } // namespace solver diff --git a/core/solver/trs_kernels.hpp b/core/solver/lower_trs_kernels.hpp similarity index 76% rename from core/solver/trs_kernels.hpp rename to core/solver/lower_trs_kernels.hpp index 42812f95379..611c898ae44 100644 --- a/core/solver/trs_kernels.hpp +++ b/core/solver/lower_trs_kernels.hpp @@ -30,8 +30,8 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#ifndef GKO_CORE_SOLVER_TRS_KERNELS_HPP_ -#define GKO_CORE_SOLVER_TRS_KERNELS_HPP_ +#ifndef GKO_CORE_SOLVER_LOWER_TRS_KERNELS_HPP_ +#define GKO_CORE_SOLVER_LOWER_TRS_KERNELS_HPP_ #include @@ -44,55 +44,55 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace gko { namespace kernels { -namespace trs { +namespace lower_trs { -#define GKO_DECLARE_TRS_GENERATE_KERNEL(_vtype, _itype) \ +#define GKO_DECLARE_LOWER_TRS_GENERATE_KERNEL(_vtype, _itype) \ void generate(std::shared_ptr exec, \ const matrix::Csr<_vtype, _itype> *matrix, \ const matrix::Dense<_vtype> *b) -#define GKO_DECLARE_TRS_SOLVE_KERNEL(_vtype, _itype) \ +#define GKO_DECLARE_LOWER_TRS_SOLVE_KERNEL(_vtype, _itype) \ void solve(std::shared_ptr exec, \ const matrix::Csr<_vtype, _itype> *matrix, \ const matrix::Dense<_vtype> *b, matrix::Dense<_vtype> *x) -#define GKO_DECLARE_ALL_AS_TEMPLATES \ - template \ - GKO_DECLARE_TRS_SOLVE_KERNEL(ValueType, IndexType); \ - template \ - GKO_DECLARE_TRS_GENERATE_KERNEL(ValueType, IndexType) +#define GKO_DECLARE_ALL_AS_TEMPLATES \ + template \ + GKO_DECLARE_LOWER_TRS_SOLVE_KERNEL(ValueType, IndexType); \ + template \ + GKO_DECLARE_LOWER_TRS_GENERATE_KERNEL(ValueType, IndexType) -} // namespace trs +} // namespace lower_trs namespace omp { -namespace trs { +namespace lower_trs { GKO_DECLARE_ALL_AS_TEMPLATES; -} // namespace trs +} // namespace lower_trs } // namespace omp namespace cuda { -namespace trs { +namespace lower_trs { GKO_DECLARE_ALL_AS_TEMPLATES; -} // namespace trs +} // namespace lower_trs } // namespace cuda namespace reference { -namespace trs { +namespace lower_trs { GKO_DECLARE_ALL_AS_TEMPLATES; -} // namespace trs +} // namespace lower_trs } // namespace reference @@ -103,4 +103,4 @@ GKO_DECLARE_ALL_AS_TEMPLATES; } // namespace gko -#endif // GKO_CORE_SOLVER_TRS_KERNELS_HPP +#endif // GKO_CORE_SOLVER_LOWER_TRS_KERNELS_HPP diff --git a/core/test/solver/CMakeLists.txt b/core/test/solver/CMakeLists.txt index a35552a7f6d..b9ac50f2a3a 100644 --- a/core/test/solver/CMakeLists.txt +++ b/core/test/solver/CMakeLists.txt @@ -4,4 +4,4 @@ ginkgo_create_test(cgs) ginkgo_create_test(fcg) ginkgo_create_test(gmres) ginkgo_create_test(ir) -ginkgo_create_test(trs) +ginkgo_create_test(lower_trs) diff --git a/core/test/solver/trs.cpp b/core/test/solver/lower_trs.cpp similarity index 80% rename from core/test/solver/trs.cpp rename to core/test/solver/lower_trs.cpp index 846eca734e3..599558a61fc 100644 --- a/core/test/solver/trs.cpp +++ b/core/test/solver/lower_trs.cpp @@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#include +#include #include @@ -46,33 +46,34 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace { -class Trs : public ::testing::Test { +class LowerTrs : public ::testing::Test { protected: - using Solver = gko::solver::Trs<>; + using Solver = gko::solver::LowerTrs<>; using CGSolver = gko::solver::Cg<>; - Trs() + LowerTrs() : exec(gko::ReferenceExecutor::create()), prec_fac(CGSolver::build().on(exec)), - trs_factory(Solver::build().with_preconditioner(prec_fac).on(exec)) + lower_trs_factory( + Solver::build().with_preconditioner(prec_fac).on(exec)) {} std::shared_ptr exec; std::shared_ptr prec_fac; - std::unique_ptr trs_factory; + std::unique_ptr lower_trs_factory; }; -TEST_F(Trs, TrsFactoryKnowsItsExecutor) +TEST_F(LowerTrs, LowerTrsFactoryKnowsItsExecutor) { - ASSERT_EQ(trs_factory->get_executor(), exec); + ASSERT_EQ(lower_trs_factory->get_executor(), exec); } -TEST_F(Trs, TrsFactoryKnowsItsPrecond) +TEST_F(LowerTrs, LowerTrsFactoryKnowsItsPrecond) { ASSERT_EQ(static_cast( - trs_factory->get_parameters().preconditioner.get()), + lower_trs_factory->get_parameters().preconditioner.get()), prec_fac.get()); } diff --git a/cuda/CMakeLists.txt b/cuda/CMakeLists.txt index 10585a79139..28c265860f6 100644 --- a/cuda/CMakeLists.txt +++ b/cuda/CMakeLists.txt @@ -47,7 +47,7 @@ target_sources(ginkgo_cuda solver/fcg_kernels.cu solver/gmres_kernels.cu solver/ir_kernels.cu - solver/trs_kernels.cu + solver/lower_trs_kernels.cu stop/criterion_kernels.cu stop/residual_norm_reduction_kernels.cu) diff --git a/cuda/solver/trs_kernels.cu b/cuda/solver/lower_trs_kernels.cu similarity index 88% rename from cuda/solver/trs_kernels.cu rename to cuda/solver/lower_trs_kernels.cu index 887c02612e3..f032d7880e4 100644 --- a/cuda/solver/trs_kernels.cu +++ b/cuda/solver/lower_trs_kernels.cu @@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#include "core/solver/trs_kernels.hpp" +#include "core/solver/lower_trs_kernels.hpp" #include @@ -46,11 +46,11 @@ namespace gko { namespace kernels { namespace cuda { /** - * @brief The TRS solver namespace. + * @brief The LOWER_TRS solver namespace. * - * @ingroup trs + * @ingroup lower_trs */ -namespace trs { +namespace lower_trs { template @@ -58,7 +58,8 @@ void generate(std::shared_ptr exec, const matrix::Csr *matrix, const matrix::Dense *b) GKO_NOT_IMPLEMENTED; -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS_GENERATE_KERNEL); +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( + GKO_DECLARE_LOWER_TRS_GENERATE_KERNEL); template @@ -67,10 +68,11 @@ void solve(std::shared_ptr exec, const matrix::Dense *b, matrix::Dense *x) GKO_NOT_IMPLEMENTED; -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS_SOLVE_KERNEL); +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( + GKO_DECLARE_LOWER_TRS_SOLVE_KERNEL); -} // namespace trs +} // namespace lower_trs } // namespace cuda } // namespace kernels } // namespace gko diff --git a/include/ginkgo/core/solver/trs.hpp b/include/ginkgo/core/solver/lower_trs.hpp similarity index 70% rename from include/ginkgo/core/solver/trs.hpp rename to include/ginkgo/core/solver/lower_trs.hpp index 037d1f5a5a2..8f425cf5191 100644 --- a/include/ginkgo/core/solver/trs.hpp +++ b/include/ginkgo/core/solver/lower_trs.hpp @@ -30,8 +30,8 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#ifndef GKO_CORE_SOLVER_TRS_HPP_ -#define GKO_CORE_SOLVER_TRS_HPP_ +#ifndef GKO_CORE_SOLVER_LOWER_TRS_HPP_ +#define GKO_CORE_SOLVER_LOWER_TRS_HPP_ #include @@ -56,67 +56,68 @@ namespace solver { template -class Trs; +class LowerTrs; /** * This struct is used to pass parameters to the - * EnableDefaultTrsFactory::generate() method. It is the - * ComponentsType of TrsFactory. + * EnableDefaultLowerTrsFactory::generate() method. It is the + * ComponentsType of LowerTrsFactory. * */ -struct TrsArgs { +struct LowerTrsArgs { std::shared_ptr system_matrix; std::shared_ptr b; - TrsArgs(std::shared_ptr system_matrix, - std::shared_ptr b) + LowerTrsArgs(std::shared_ptr system_matrix, + std::shared_ptr b) : system_matrix{system_matrix}, b{b} {} }; /** - * Declares an Abstract Factory specialized for Trs solver. + * Declares an Abstract Factory specialized for LowerTrs solver. * * @tparam ValueType precision of matrix elements * @tparam IndexType precision of matrix indexes */ template -using TrsFactory = AbstractFactory, TrsArgs>; +using LowerTrsFactory = + AbstractFactory, LowerTrsArgs>; /** * This is an alias for the EnableDefaultFactory mixin, which correctly sets the - * template parameters to enable a subclass of TrsFactory. + * template parameters to enable a subclass of LowerTrsFactory. * * @tparam ConcreteFactory the concrete factory which is being implemented * [CRTP parmeter] - * @tparam ConcreteTrs the concrete Trs type which this factory + * @tparam ConcreteLowerTrs the concrete LowerTrs type which this factory * produces, needs to have a constructor which takes * a const ConcreteFactory *, and a - * const TrsArgs * as parameters. + * const LowerTrsArgs * as parameters. * @tparam ParametersType a subclass of enable_parameters_type template which * defines all of the parameters of the factory * @tparam ValueType precision of matrix elements * @tparam IndexType precision of matrix indexes */ -template -using EnableDefaultTrsFactory = - EnableDefaultFactory>; +using EnableDefaultLowerTrsFactory = + EnableDefaultFactory>; /** - * This macro will generate a default implementation of a TrsFactory for - * the Trs subclass it is defined in. + * This macro will generate a default implementation of a LowerTrsFactory for + * the LowerTrs subclass it is defined in. * * This macro is very similar to the macro #ENABLE_LIN_OP_FACTORY(). A more * detailed description of the use of these type of macros can be found there. * - * @param _trs concrete operator for which the factory is to be created + * @param _lower_trs concrete operator for which the factory is to be created * [CRTP parameter] * @param _parameters_name name of the parameters member in the class * (its type is `<_parameters_name>_type`, the @@ -127,39 +128,42 @@ using EnableDefaultTrsFactory = * * @ingroup solvers */ -#define GKO_ENABLE_TRS_FACTORY(_trs, _parameters_name, _factory_name) \ -public: \ - const _parameters_name##_type &get_##_parameters_name() const \ - { \ - return _parameters_name##_; \ - } \ - \ - class _factory_name : public ::gko::solver::EnableDefaultTrsFactory< \ - _factory_name, _trs, _parameters_name##_type, \ - ValueType, IndexType> { \ - friend class ::gko::EnablePolymorphicObject< \ - _factory_name, ::gko::solver::TrsFactory>; \ - friend class ::gko::enable_parameters_type<_parameters_name##_type, \ - _factory_name>; \ - using ::gko::solver::EnableDefaultTrsFactory< \ - _factory_name, _trs, _parameters_name##_type, ValueType, \ - IndexType>::EnableDefaultTrsFactory; \ - }; \ - friend ::gko::solver::EnableDefaultTrsFactory< \ - _factory_name, _trs, _parameters_name##_type, ValueType, IndexType>; \ - \ -private: \ - _parameters_name##_type _parameters_name##_; \ - \ -public: \ - static_assert(true, \ - "This assert is used to counter the false positive extra " \ +#define GKO_ENABLE_LOWER_TRS_FACTORY(_lower_trs, _parameters_name, \ + _factory_name) \ +public: \ + const _parameters_name##_type &get_##_parameters_name() const \ + { \ + return _parameters_name##_; \ + } \ + \ + class _factory_name : public ::gko::solver::EnableDefaultLowerTrsFactory< \ + _factory_name, _lower_trs, \ + _parameters_name##_type, ValueType, IndexType> { \ + friend class ::gko::EnablePolymorphicObject< \ + _factory_name, \ + ::gko::solver::LowerTrsFactory>; \ + friend class ::gko::enable_parameters_type<_parameters_name##_type, \ + _factory_name>; \ + using ::gko::solver::EnableDefaultLowerTrsFactory< \ + _factory_name, _lower_trs, _parameters_name##_type, ValueType, \ + IndexType>::EnableDefaultLowerTrsFactory; \ + }; \ + friend ::gko::solver::EnableDefaultLowerTrsFactory< \ + _factory_name, _lower_trs, _parameters_name##_type, ValueType, \ + IndexType>; \ + \ +private: \ + _parameters_name##_type _parameters_name##_; \ + \ +public: \ + static_assert(true, \ + "This assert is used to counter the false positive extra " \ "semi-colon warnings") /** - * TRS is the triangular solver which solves the system L x = b, when L is a - * lower triangular matrix. It works best when passing in a matrix in CSR + * LOWER_TRS is the triangular solver which solves the system L x = b, when L is + * a lower triangular matrix. It works best when passing in a matrix in CSR * format. If the matrix is not in CSR, then the generate step converts it into * a CSR matrix. * @@ -174,10 +178,10 @@ public: \ * @ingroup LinOp */ template -class Trs : public EnableLinOp>, - public Preconditionable { - friend class EnableLinOp; - friend class EnablePolymorphicObject; +class LowerTrs : public EnableLinOp>, + public Preconditionable { + friend class EnableLinOp; + friend class EnablePolymorphicObject; public: using value_type = ValueType; @@ -219,8 +223,8 @@ class Trs : public EnableLinOp>, preconditioner, nullptr); }; #define GKO_COMMA , - GKO_ENABLE_TRS_FACTORY(Trs, parameters, - Factory); + GKO_ENABLE_LOWER_TRS_FACTORY(LowerTrs, + parameters, Factory); #undef GKO_COMMA GKO_ENABLE_BUILD_METHOD(Factory); @@ -238,14 +242,14 @@ class Trs : public EnableLinOp>, */ void generate(const LinOp *system_matrix, const LinOp *b); - explicit Trs(std::shared_ptr exec) - : EnableLinOp(std::move(exec)) + explicit LowerTrs(std::shared_ptr exec) + : EnableLinOp(std::move(exec)) {} - explicit Trs(const Factory *factory, const TrsArgs &args) + explicit LowerTrs(const Factory *factory, const LowerTrsArgs &args) : parameters_{factory->get_parameters()}, - EnableLinOp(factory->get_executor(), - transpose(args.system_matrix->get_size())), + EnableLinOp(factory->get_executor(), + transpose(args.system_matrix->get_size())), system_matrix_{std::move(args.system_matrix)}, b_{std::move(args.b)} { @@ -272,4 +276,4 @@ class Trs : public EnableLinOp>, } // namespace gko -#endif // GKO_CORE_SOLVER_TRS_HPP +#endif // GKO_CORE_SOLVER_LOWER_TRS_HPP diff --git a/omp/CMakeLists.txt b/omp/CMakeLists.txt index 55d94b19afa..8887c6e39ad 100644 --- a/omp/CMakeLists.txt +++ b/omp/CMakeLists.txt @@ -18,7 +18,7 @@ target_sources(ginkgo_omp solver/fcg_kernels.cpp solver/gmres_kernels.cpp solver/ir_kernels.cpp - solver/trs_kernels.cpp + solver/lower_trs_kernels.cpp stop/criterion_kernels.cpp stop/residual_norm_reduction_kernels.cpp) diff --git a/omp/solver/trs_kernels.cpp b/omp/solver/lower_trs_kernels.cpp similarity index 91% rename from omp/solver/trs_kernels.cpp rename to omp/solver/lower_trs_kernels.cpp index 4edf80bbbfa..b444cb96d40 100644 --- a/omp/solver/trs_kernels.cpp +++ b/omp/solver/lower_trs_kernels.cpp @@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#include "core/solver/trs_kernels.hpp" +#include "core/solver/lower_trs_kernels.hpp" #include @@ -51,11 +51,11 @@ namespace gko { namespace kernels { namespace omp { /** - * @brief The TRS solver namespace. + * @brief The LOWER_TRS solver namespace. * - * @ingroup trs + * @ingroup lower_trs */ -namespace trs { +namespace lower_trs { template @@ -68,7 +68,8 @@ void generate(std::shared_ptr exec, // "analysis" phase for the triangular matrix. } -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS_GENERATE_KERNEL); +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( + GKO_DECLARE_LOWER_TRS_GENERATE_KERNEL); template @@ -95,10 +96,11 @@ void solve(std::shared_ptr exec, } } -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS_SOLVE_KERNEL); +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( + GKO_DECLARE_LOWER_TRS_SOLVE_KERNEL); -} // namespace trs +} // namespace lower_trs } // namespace omp } // namespace kernels } // namespace gko diff --git a/omp/test/solver/CMakeLists.txt b/omp/test/solver/CMakeLists.txt index c6a0ab0c6da..ede4999a510 100644 --- a/omp/test/solver/CMakeLists.txt +++ b/omp/test/solver/CMakeLists.txt @@ -4,4 +4,4 @@ ginkgo_create_test(cgs_kernels) ginkgo_create_test(fcg_kernels) ginkgo_create_test(gmres_kernels) ginkgo_create_test(ir_kernels) -ginkgo_create_test(trs_kernels) +ginkgo_create_test(lower_trs_kernels) diff --git a/omp/test/solver/trs_kernels.cpp b/omp/test/solver/lower_trs_kernels.cpp similarity index 82% rename from omp/test/solver/trs_kernels.cpp rename to omp/test/solver/lower_trs_kernels.cpp index 9206eeea547..0a21674f8e8 100644 --- a/omp/test/solver/trs_kernels.cpp +++ b/omp/test/solver/lower_trs_kernels.cpp @@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#include +#include #include @@ -46,19 +46,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -#include "core/solver/trs_kernels.hpp" +#include "core/solver/lower_trs_kernels.hpp" #include "core/test/utils.hpp" namespace { -class Trs : public ::testing::Test { +class LowerTrs : public ::testing::Test { protected: using Mtx = gko::matrix::Dense<>; using CsrMtx = gko::matrix::Csr; - Trs() : rand_engine(30) {} + LowerTrs() : rand_engine(30) {} void SetUp() { @@ -114,24 +114,26 @@ class Trs : public ::testing::Test { }; -TEST_F(Trs, OmpTrsSolveIsEquivalentToRef) +TEST_F(LowerTrs, OmpLowerTrsSolveIsEquivalentToRef) { initialize_data(59, 43); - gko::kernels::reference::trs::solve(ref, csr_mat.get(), b.get(), x.get()); - gko::kernels::omp::trs::solve(omp, d_csr_mat.get(), d_b.get(), d_x.get()); + gko::kernels::reference::lower_trs::solve(ref, csr_mat.get(), b.get(), + x.get()); + gko::kernels::omp::lower_trs::solve(omp, d_csr_mat.get(), d_b.get(), + d_x.get()); GKO_ASSERT_MTX_NEAR(d_x, x, 1e-14); } -TEST_F(Trs, ApplyIsEquivalentToRef) +TEST_F(LowerTrs, ApplyIsEquivalentToRef) { initialize_data(59, 3); - auto trs_factory = gko::solver::Trs<>::build().on(ref); - auto d_trs_factory = gko::solver::Trs<>::build().on(omp); - auto solver = trs_factory->generate(csr_mat, b); - auto d_solver = d_trs_factory->generate(d_csr_mat, d_b); + auto lower_trs_factory = gko::solver::LowerTrs<>::build().on(ref); + auto d_lower_trs_factory = gko::solver::LowerTrs<>::build().on(omp); + auto solver = lower_trs_factory->generate(csr_mat, b); + auto d_solver = d_lower_trs_factory->generate(d_csr_mat, d_b); solver->apply(b.get(), x.get()); d_solver->apply(d_b.get(), d_x.get()); diff --git a/reference/CMakeLists.txt b/reference/CMakeLists.txt index e3edb5e6c1f..5806dc3e186 100644 --- a/reference/CMakeLists.txt +++ b/reference/CMakeLists.txt @@ -16,7 +16,7 @@ target_sources(ginkgo_reference solver/fcg_kernels.cpp solver/gmres_kernels.cpp solver/ir_kernels.cpp - solver/trs_kernels.cpp + solver/lower_trs_kernels.cpp stop/criterion_kernels.cpp stop/residual_norm_reduction_kernels.cpp) diff --git a/reference/solver/trs_kernels.cpp b/reference/solver/lower_trs_kernels.cpp similarity index 90% rename from reference/solver/trs_kernels.cpp rename to reference/solver/lower_trs_kernels.cpp index a272f13adc6..3f3b313ca1d 100644 --- a/reference/solver/trs_kernels.cpp +++ b/reference/solver/lower_trs_kernels.cpp @@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#include "core/solver/trs_kernels.hpp" +#include "core/solver/lower_trs_kernels.hpp" #include @@ -47,11 +47,11 @@ namespace gko { namespace kernels { namespace reference { /** - * @brief The TRS solver namespace. + * @brief The LOWER_TRS solver namespace. * - * @ingroup trs + * @ingroup lower_trs */ -namespace trs { +namespace lower_trs { template @@ -64,7 +64,8 @@ void generate(std::shared_ptr exec, // "analysis" phase for the triangular matrix. } -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS_GENERATE_KERNEL); +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( + GKO_DECLARE_LOWER_TRS_GENERATE_KERNEL); template @@ -90,10 +91,11 @@ void solve(std::shared_ptr exec, } } -GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_TRS_SOLVE_KERNEL); +GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE( + GKO_DECLARE_LOWER_TRS_SOLVE_KERNEL); -} // namespace trs +} // namespace lower_trs } // namespace reference } // namespace kernels } // namespace gko diff --git a/reference/test/solver/CMakeLists.txt b/reference/test/solver/CMakeLists.txt index aceb5d8ebcc..a580309f72e 100644 --- a/reference/test/solver/CMakeLists.txt +++ b/reference/test/solver/CMakeLists.txt @@ -4,5 +4,5 @@ ginkgo_create_test(cgs_kernels) ginkgo_create_test(fcg_kernels) ginkgo_create_test(gmres_kernels) ginkgo_create_test(ir_kernels) -ginkgo_create_test(trs) -ginkgo_create_test(trs_kernels) +ginkgo_create_test(lower_trs) +ginkgo_create_test(lower_trs_kernels) diff --git a/reference/test/solver/trs.cpp b/reference/test/solver/lower_trs.cpp similarity index 76% rename from reference/test/solver/trs.cpp rename to reference/test/solver/lower_trs.cpp index 9f3d8bb63b8..4f6fe13b4ec 100644 --- a/reference/test/solver/trs.cpp +++ b/reference/test/solver/lower_trs.cpp @@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#include +#include #include @@ -51,28 +51,28 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace { -class Trs : public ::testing::Test { +class LowerTrs : public ::testing::Test { protected: using CsrMtx = gko::matrix::Csr; using Mtx = gko::matrix::Dense<>; - using Solver = gko::solver::Trs<>; + using Solver = gko::solver::LowerTrs<>; - Trs() + LowerTrs() : exec(gko::ReferenceExecutor::create()), mtx(gko::initialize( {{2, 0.0, 0.0}, {3.0, 1, 0.0}, {1.0, 2.0, 3}}, exec)), b(gko::initialize({{2, 0.0, 0.0}}, exec)), csr_mtx(gko::copy_and_convert_to(exec, mtx.get())), - trs_factory(Solver::build().on(exec)), - trs_solver(trs_factory->generate(mtx, b)) + lower_trs_factory(Solver::build().on(exec)), + lower_trs_solver(lower_trs_factory->generate(mtx, b)) {} std::shared_ptr exec; std::shared_ptr mtx; std::shared_ptr b; std::shared_ptr csr_mtx; - std::unique_ptr trs_factory; - std::unique_ptr trs_solver; + std::unique_ptr lower_trs_factory; + std::unique_ptr lower_trs_solver; static void assert_same_matrices(const Mtx *m1, const Mtx *m2) { @@ -87,22 +87,22 @@ class Trs : public ::testing::Test { }; -TEST_F(Trs, TrsFactoryCreatesCorrectSolver) +TEST_F(LowerTrs, LowerTrsFactoryCreatesCorrectSolver) { - ASSERT_EQ(trs_solver->get_size(), gko::dim<2>(3, 3)); - ASSERT_NE(trs_solver->get_system_matrix(), nullptr); - ASSERT_NE(trs_solver->get_rhs(), nullptr); - ASSERT_EQ(trs_solver->get_system_matrix(), mtx); - ASSERT_EQ(trs_solver->get_rhs(), b); + ASSERT_EQ(lower_trs_solver->get_size(), gko::dim<2>(3, 3)); + ASSERT_NE(lower_trs_solver->get_system_matrix(), nullptr); + ASSERT_NE(lower_trs_solver->get_rhs(), nullptr); + ASSERT_EQ(lower_trs_solver->get_system_matrix(), mtx); + ASSERT_EQ(lower_trs_solver->get_rhs(), b); } -TEST_F(Trs, CanBeCopied) +TEST_F(LowerTrs, CanBeCopied) { auto copy = Solver::build().on(exec)->generate(Mtx::create(exec), Mtx::create(exec)); - copy->copy_from(lend(trs_solver)); + copy->copy_from(lend(lower_trs_solver)); ASSERT_EQ(copy->get_size(), gko::dim<2>(3, 3)); auto copy_mtx = copy.get()->get_system_matrix(); @@ -112,11 +112,12 @@ TEST_F(Trs, CanBeCopied) } -TEST_F(Trs, CanBeMoved) +TEST_F(LowerTrs, CanBeMoved) { - auto copy = trs_factory->generate(Mtx::create(exec), Mtx::create(exec)); + auto copy = + lower_trs_factory->generate(Mtx::create(exec), Mtx::create(exec)); - copy->copy_from(std::move(trs_solver)); + copy->copy_from(std::move(lower_trs_solver)); ASSERT_EQ(copy->get_size(), gko::dim<2>(3, 3)); auto copy_mtx = copy.get()->get_system_matrix(); @@ -126,9 +127,9 @@ TEST_F(Trs, CanBeMoved) } -TEST_F(Trs, CanBeCloned) +TEST_F(LowerTrs, CanBeCloned) { - auto clone = trs_solver->clone(); + auto clone = lower_trs_solver->clone(); ASSERT_EQ(clone->get_size(), gko::dim<2>(3, 3)); auto clone_mtx = clone.get()->get_system_matrix(); @@ -138,13 +139,13 @@ TEST_F(Trs, CanBeCloned) } -TEST_F(Trs, CanBeCleared) +TEST_F(LowerTrs, CanBeCleared) { - trs_solver->clear(); + lower_trs_solver->clear(); - ASSERT_EQ(trs_solver->get_size(), gko::dim<2>(0, 0)); - auto solver_mtx = trs_solver.get()->get_system_matrix(); - auto solver_b = trs_solver.get()->get_rhs(); + ASSERT_EQ(lower_trs_solver->get_size(), gko::dim<2>(0, 0)); + auto solver_mtx = lower_trs_solver.get()->get_system_matrix(); + auto solver_b = lower_trs_solver.get()->get_rhs(); ASSERT_EQ(solver_mtx, nullptr); ASSERT_EQ(solver_b, nullptr); } diff --git a/reference/test/solver/trs_kernels.cpp b/reference/test/solver/lower_trs_kernels.cpp similarity index 82% rename from reference/test/solver/trs_kernels.cpp rename to reference/test/solver/lower_trs_kernels.cpp index 558b689c930..4fecffe9680 100644 --- a/reference/test/solver/trs_kernels.cpp +++ b/reference/test/solver/lower_trs_kernels.cpp @@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ -#include +#include #include @@ -52,39 +52,39 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace { -class Trs : public ::testing::Test { +class LowerTrs : public ::testing::Test { protected: using Mtx = gko::matrix::Dense<>; - Trs() + LowerTrs() : exec(gko::ReferenceExecutor::create()), mtx(gko::initialize( {{1, 0.0, 0.0}, {3.0, 1, 0.0}, {1.0, 2.0, 1}}, exec)), mtx2(gko::initialize( {{2, 0.0, 0.0}, {3.0, 3, 0.0}, {1.0, 2.0, 4}}, exec)), - trs_factory(gko::solver::Trs<>::build().on(exec)), + lower_trs_factory(gko::solver::LowerTrs<>::build().on(exec)), mtx_big(gko::initialize({{124.0, 0.0, 0.0, 0.0, 0.0}, {43.0, -789.0, 0.0, 0.0, 0.0}, {134.5, -651.0, 654.0, 0.0, 0.0}, {-642.0, 684.0, 68.0, 387.0, 0.0}, {365.0, 97.0, -654.0, 8.0, 91.0}}, exec)), - trs_factory_big(gko::solver::Trs<>::build().on(exec)) + lower_trs_factory_big(gko::solver::LowerTrs<>::build().on(exec)) {} std::shared_ptr exec; std::shared_ptr mtx; std::shared_ptr mtx2; std::shared_ptr mtx_big; - std::unique_ptr::Factory> trs_factory; - std::unique_ptr::Factory> trs_factory_big; + std::unique_ptr::Factory> lower_trs_factory; + std::unique_ptr::Factory> lower_trs_factory_big; }; -TEST_F(Trs, SolvesTriangularSystem) +TEST_F(LowerTrs, SolvesTriangularSystem) { std::shared_ptr b = gko::initialize({1.0, 2.0, 1.0}, exec); auto x = gko::initialize({0.0, 0.0, 0.0}, exec); - auto solver = trs_factory->generate(mtx, b); + auto solver = lower_trs_factory->generate(mtx, b); solver->apply(b.get(), x.get()); @@ -92,12 +92,12 @@ TEST_F(Trs, SolvesTriangularSystem) } -TEST_F(Trs, SolvesMultipleTriangularSystems) +TEST_F(LowerTrs, SolvesMultipleTriangularSystems) { std::shared_ptr b = gko::initialize({{3.0, 4.0}, {1.0, 0.0}, {1.0, -1.0}}, exec); auto x = gko::initialize({{0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0}}, exec); - auto solver = trs_factory->generate(mtx, b); + auto solver = lower_trs_factory->generate(mtx, b); solver->apply(b.get(), x.get()); @@ -105,24 +105,24 @@ TEST_F(Trs, SolvesMultipleTriangularSystems) } -TEST_F(Trs, SolvesNonUnitTriangularSystem) +TEST_F(LowerTrs, SolvesNonUnitTriangularSystem) { std::shared_ptr b = gko::initialize({2.0, 12.0, 3.0}, exec); auto x = gko::initialize({0.0, 0.0, 0.0}, exec); - auto solver = trs_factory->generate(mtx2, b); + auto solver = lower_trs_factory->generate(mtx2, b); solver->apply(b.get(), x.get()); GKO_ASSERT_MTX_NEAR(x, l({1.0, 3.0, -1.0}), 1e-14); } -TEST_F(Trs, SolvesTriangularSystemUsingAdvancedApply) +TEST_F(LowerTrs, SolvesTriangularSystemUsingAdvancedApply) { auto alpha = gko::initialize({2.0}, exec); auto beta = gko::initialize({-1.0}, exec); std::shared_ptr b = gko::initialize({1.0, 2.0, 1.0}, exec); auto x = gko::initialize({1.0, -1.0, 1.0}, exec); - auto solver = trs_factory->generate(mtx, b); + auto solver = lower_trs_factory->generate(mtx, b); solver->apply(alpha.get(), b.get(), beta.get(), x.get()); @@ -130,7 +130,7 @@ TEST_F(Trs, SolvesTriangularSystemUsingAdvancedApply) } -TEST_F(Trs, SolvesMultipleTriangularSystemsUsingAdvancedApply) +TEST_F(LowerTrs, SolvesMultipleTriangularSystemsUsingAdvancedApply) { auto alpha = gko::initialize({-1.0}, exec); auto beta = gko::initialize({2.0}, exec); @@ -138,7 +138,7 @@ TEST_F(Trs, SolvesMultipleTriangularSystemsUsingAdvancedApply) gko::initialize({{3.0, 4.0}, {1.0, 0.0}, {1.0, -1.0}}, exec); auto x = gko::initialize({{1.0, 2.0}, {-1.0, -1.0}, {0.0, -2.0}}, exec); - auto solver = trs_factory->generate(mtx, b); + auto solver = lower_trs_factory->generate(mtx, b); solver->apply(alpha.get(), b.get(), beta.get(), x.get()); @@ -147,12 +147,12 @@ TEST_F(Trs, SolvesMultipleTriangularSystemsUsingAdvancedApply) } -TEST_F(Trs, SolvesBigDenseSystem1) +TEST_F(LowerTrs, SolvesBigDenseSystem1) { std::shared_ptr b = gko::initialize({-124.0, -3199.0, 3147.5, 5151.0, -6021.0}, exec); auto x = gko::initialize({0.0, 0.0, 0.0, 0.0, 0.0}, exec); - auto solver = trs_factory_big->generate(mtx_big, b); + auto solver = lower_trs_factory_big->generate(mtx_big, b); solver->apply(b.get(), x.get());