From b54d5a293cced655147f56ec7dae4d17b9a2bb8f Mon Sep 17 00:00:00 2001 From: Tobias Ribizel Date: Mon, 16 Oct 2023 10:42:21 +0200 Subject: [PATCH 1/3] refactor tests to use index_type template param --- reference/test/matrix/dense_kernels.cpp | 2219 +++++++---------------- 1 file changed, 630 insertions(+), 1589 deletions(-) diff --git a/reference/test/matrix/dense_kernels.cpp b/reference/test/matrix/dense_kernels.cpp index 9edab89e382..3a4cfb6826b 100644 --- a/reference/test/matrix/dense_kernels.cpp +++ b/reference/test/matrix/dense_kernels.cpp @@ -97,7 +97,6 @@ class Dense : public ::testing::Test { std::unique_ptr mtx6; std::unique_ptr mtx7; std::unique_ptr mtx8; - gko::int32 invalid_index = gko::invalid_index(); std::default_random_engine rand_engine; template @@ -115,6 +114,23 @@ class Dense : public ::testing::Test { TYPED_TEST_SUITE(Dense, gko::test::ValueTypes, TypenameNameGenerator); +template +class DenseWithIndexType + : public Dense< + typename std::tuple_element<0, decltype(ValueIndexType())>::type> { +public: + using value_type = + typename std::tuple_element<0, decltype(ValueIndexType())>::type; + using index_type = + typename std::tuple_element<1, decltype(ValueIndexType())>::type; + + index_type invalid_index = gko::invalid_index(); +}; + +TYPED_TEST_SUITE(DenseWithIndexType, gko::test::ValueIndexTypes, + PairTypenameNameGenerator); + + TYPED_TEST(Dense, CopyRespectsStride) { using value_type = typename TestFixture::value_type; @@ -780,41 +796,9 @@ TYPED_TEST(Dense, MovesToPrecision) } -TYPED_TEST(Dense, ConvertsToCoo32) -{ - using T = typename TestFixture::value_type; - using Coo = typename gko::matrix::Coo; - auto coo_mtx = Coo::create(this->mtx4->get_executor()); - - this->mtx4->convert_to(coo_mtx); - auto v = coo_mtx->get_const_values(); - auto c = coo_mtx->get_const_col_idxs(); - auto r = coo_mtx->get_const_row_idxs(); - - ASSERT_EQ(coo_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(coo_mtx->get_num_stored_elements(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); -} - - -TYPED_TEST(Dense, MovesToCoo32) +template +void assert_coo_eq_mtx4(const gko::matrix::Coo* coo_mtx) { - using T = typename TestFixture::value_type; - using Coo = typename gko::matrix::Coo; - auto coo_mtx = Coo::create(this->mtx4->get_executor()); - - this->mtx4->move_to(coo_mtx); auto v = coo_mtx->get_const_values(); auto c = coo_mtx->get_const_col_idxs(); auto r = coo_mtx->get_const_row_idxs(); @@ -829,121 +813,47 @@ TYPED_TEST(Dense, MovesToCoo32) EXPECT_EQ(c[1], 1); EXPECT_EQ(c[2], 2); EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{3.0}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{5.0}); } -TYPED_TEST(Dense, ConvertsToCoo64) +TYPED_TEST(DenseWithIndexType, ConvertsToCoo) { - using T = typename TestFixture::value_type; - using Coo = typename gko::matrix::Coo; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Coo = typename gko::matrix::Coo; auto coo_mtx = Coo::create(this->mtx4->get_executor()); this->mtx4->convert_to(coo_mtx); - auto v = coo_mtx->get_const_values(); - auto c = coo_mtx->get_const_col_idxs(); - auto r = coo_mtx->get_const_row_idxs(); - ASSERT_EQ(coo_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(coo_mtx->get_num_stored_elements(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); + assert_coo_eq_mtx4(coo_mtx.get()); } -TYPED_TEST(Dense, MovesToCoo64) +TYPED_TEST(DenseWithIndexType, MovesToCoo) { - using T = typename TestFixture::value_type; - using Coo = typename gko::matrix::Coo; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Coo = typename gko::matrix::Coo; auto coo_mtx = Coo::create(this->mtx4->get_executor()); this->mtx4->move_to(coo_mtx); - auto v = coo_mtx->get_const_values(); - auto c = coo_mtx->get_const_col_idxs(); - auto r = coo_mtx->get_const_row_idxs(); - - ASSERT_EQ(coo_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(coo_mtx->get_num_stored_elements(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); -} - -TYPED_TEST(Dense, ConvertsToCsr32) -{ - using T = typename TestFixture::value_type; - using Csr = typename gko::matrix::Csr; - auto csr_s_classical = std::make_shared(); - auto csr_s_merge = std::make_shared(); - auto csr_mtx_c = Csr::create(this->mtx4->get_executor(), csr_s_classical); - auto csr_mtx_m = Csr::create(this->mtx4->get_executor(), csr_s_merge); - - this->mtx4->convert_to(csr_mtx_c); - this->mtx4->convert_to(csr_mtx_m); - - auto v = csr_mtx_c->get_const_values(); - auto c = csr_mtx_c->get_const_col_idxs(); - auto r = csr_mtx_c->get_const_row_ptrs(); - ASSERT_EQ(csr_mtx_c->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(csr_mtx_c->get_num_stored_elements(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 3); - EXPECT_EQ(r[2], 4); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); - ASSERT_EQ(csr_mtx_c->get_strategy()->get_name(), "classical"); - GKO_ASSERT_MTX_NEAR(csr_mtx_c, csr_mtx_m, 0.0); - ASSERT_EQ(csr_mtx_m->get_strategy()->get_name(), "merge_path"); + assert_coo_eq_mtx4(coo_mtx.get()); } -TYPED_TEST(Dense, MovesToCsr32) +template +void assert_csr_eq_mtx4(const gko::matrix::Csr* csr_mtx) { - using T = typename TestFixture::value_type; - using Csr = typename gko::matrix::Csr; - auto csr_s_classical = std::make_shared(); - auto csr_s_merge = std::make_shared(); - auto csr_mtx_c = Csr::create(this->mtx4->get_executor(), csr_s_classical); - auto csr_mtx_m = Csr::create(this->mtx4->get_executor(), csr_s_merge); - auto mtx_clone = this->mtx4->clone(); - - this->mtx4->move_to(csr_mtx_c); - mtx_clone->move_to(csr_mtx_m); - - auto v = csr_mtx_c->get_const_values(); - auto c = csr_mtx_c->get_const_col_idxs(); - auto r = csr_mtx_c->get_const_row_ptrs(); - ASSERT_EQ(csr_mtx_c->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(csr_mtx_c->get_num_stored_elements(), 4); + auto v = csr_mtx->get_const_values(); + auto c = csr_mtx->get_const_col_idxs(); + auto r = csr_mtx->get_const_row_ptrs(); + ASSERT_EQ(csr_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(csr_mtx->get_num_stored_elements(), 4); EXPECT_EQ(r[0], 0); EXPECT_EQ(r[1], 3); EXPECT_EQ(r[2], 4); @@ -951,20 +861,18 @@ TYPED_TEST(Dense, MovesToCsr32) EXPECT_EQ(c[1], 1); EXPECT_EQ(c[2], 2); EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); - ASSERT_EQ(csr_mtx_c->get_strategy()->get_name(), "classical"); - GKO_ASSERT_MTX_NEAR(csr_mtx_c, csr_mtx_m, 0.0); - ASSERT_EQ(csr_mtx_m->get_strategy()->get_name(), "merge_path"); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{3.0}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{5.0}); } -TYPED_TEST(Dense, ConvertsToCsr64) +TYPED_TEST(DenseWithIndexType, ConvertsToCsr) { - using T = typename TestFixture::value_type; - using Csr = typename gko::matrix::Csr; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Csr = typename gko::matrix::Csr; auto csr_s_classical = std::make_shared(); auto csr_s_merge = std::make_shared(); auto csr_mtx_c = Csr::create(this->mtx4->get_executor(), csr_s_classical); @@ -973,32 +881,18 @@ TYPED_TEST(Dense, ConvertsToCsr64) this->mtx4->convert_to(csr_mtx_c); this->mtx4->convert_to(csr_mtx_m); - auto v = csr_mtx_c->get_const_values(); - auto c = csr_mtx_c->get_const_col_idxs(); - auto r = csr_mtx_c->get_const_row_ptrs(); - ASSERT_EQ(csr_mtx_c->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(csr_mtx_c->get_num_stored_elements(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 3); - EXPECT_EQ(r[2], 4); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); + assert_csr_eq_mtx4(csr_mtx_c.get()); ASSERT_EQ(csr_mtx_c->get_strategy()->get_name(), "classical"); GKO_ASSERT_MTX_NEAR(csr_mtx_c, csr_mtx_m, 0.0); ASSERT_EQ(csr_mtx_m->get_strategy()->get_name(), "merge_path"); } -TYPED_TEST(Dense, MovesToCsr64) +TYPED_TEST(DenseWithIndexType, MovesToCsr) { - using T = typename TestFixture::value_type; - using Csr = typename gko::matrix::Csr; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Csr = typename gko::matrix::Csr; auto csr_s_classical = std::make_shared(); auto csr_s_merge = std::make_shared(); auto csr_mtx_c = Csr::create(this->mtx4->get_executor(), csr_s_classical); @@ -1008,59 +902,17 @@ TYPED_TEST(Dense, MovesToCsr64) this->mtx4->move_to(csr_mtx_c); mtx_clone->move_to(csr_mtx_m); - auto v = csr_mtx_c->get_const_values(); - auto c = csr_mtx_c->get_const_col_idxs(); - auto r = csr_mtx_c->get_const_row_ptrs(); - ASSERT_EQ(csr_mtx_c->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(csr_mtx_c->get_num_stored_elements(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 3); - EXPECT_EQ(r[2], 4); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); + assert_csr_eq_mtx4(csr_mtx_c.get()); ASSERT_EQ(csr_mtx_c->get_strategy()->get_name(), "classical"); GKO_ASSERT_MTX_NEAR(csr_mtx_c, csr_mtx_m, 0.0); ASSERT_EQ(csr_mtx_m->get_strategy()->get_name(), "merge_path"); } -TYPED_TEST(Dense, ConvertsToSparsityCsr32) -{ - using T = typename TestFixture::value_type; - using SparsityCsr = typename gko::matrix::SparsityCsr; - auto sparsity_csr_mtx = SparsityCsr::create(this->mtx4->get_executor()); - - this->mtx4->convert_to(sparsity_csr_mtx); - auto v = sparsity_csr_mtx->get_const_value(); - auto c = sparsity_csr_mtx->get_const_col_idxs(); - auto r = sparsity_csr_mtx->get_const_row_ptrs(); - - ASSERT_EQ(sparsity_csr_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sparsity_csr_mtx->get_num_nonzeros(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 3); - EXPECT_EQ(r[2], 4); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); -} - - -TYPED_TEST(Dense, MovesToSparsityCsr32) +template +void assert_sparsity_csr_eq_mtx4( + const gko::matrix::SparsityCsr* sparsity_csr_mtx) { - using T = typename TestFixture::value_type; - using SparsityCsr = typename gko::matrix::SparsityCsr; - auto sparsity_csr_mtx = SparsityCsr::create(this->mtx4->get_executor()); - - this->mtx4->move_to(sparsity_csr_mtx); auto v = sparsity_csr_mtx->get_const_value(); auto c = sparsity_csr_mtx->get_const_col_idxs(); auto r = sparsity_csr_mtx->get_const_row_ptrs(); @@ -1074,65 +926,41 @@ TYPED_TEST(Dense, MovesToSparsityCsr32) EXPECT_EQ(c[1], 1); EXPECT_EQ(c[2], 2); EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); + EXPECT_EQ(v[0], ValueType{1.0}); } -TYPED_TEST(Dense, ConvertsToSparsityCsr64) +TYPED_TEST(DenseWithIndexType, ConvertsToSparsityCsr) { - using T = typename TestFixture::value_type; - using SparsityCsr = typename gko::matrix::SparsityCsr; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using SparsityCsr = + typename gko::matrix::SparsityCsr; auto sparsity_csr_mtx = SparsityCsr::create(this->mtx4->get_executor()); this->mtx4->convert_to(sparsity_csr_mtx); - auto v = sparsity_csr_mtx->get_const_value(); - auto c = sparsity_csr_mtx->get_const_col_idxs(); - auto r = sparsity_csr_mtx->get_const_row_ptrs(); - ASSERT_EQ(sparsity_csr_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sparsity_csr_mtx->get_num_nonzeros(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 3); - EXPECT_EQ(r[2], 4); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); + assert_sparsity_csr_eq_mtx4(sparsity_csr_mtx.get()); } -TYPED_TEST(Dense, MovesToSparsityCsr64) +TYPED_TEST(DenseWithIndexType, MovesToSparsityCsr) { - using T = typename TestFixture::value_type; - using SparsityCsr = typename gko::matrix::SparsityCsr; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using SparsityCsr = + typename gko::matrix::SparsityCsr; auto sparsity_csr_mtx = SparsityCsr::create(this->mtx4->get_executor()); this->mtx4->move_to(sparsity_csr_mtx); - auto v = sparsity_csr_mtx->get_const_value(); - auto c = sparsity_csr_mtx->get_const_col_idxs(); - auto r = sparsity_csr_mtx->get_const_row_ptrs(); - ASSERT_EQ(sparsity_csr_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sparsity_csr_mtx->get_num_nonzeros(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 3); - EXPECT_EQ(r[2], 4); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); + assert_sparsity_csr_eq_mtx4(sparsity_csr_mtx.get()); } -TYPED_TEST(Dense, ConvertsToEll32) +template +void assert_ell_eq_mtx6(const gko::matrix::Ell* ell_mtx) { - using T = typename TestFixture::value_type; - using Ell = typename gko::matrix::Ell; - auto ell_mtx = Ell::create(this->mtx6->get_executor()); - - this->mtx6->convert_to(ell_mtx); auto v = ell_mtx->get_const_values(); auto c = ell_mtx->get_const_col_idxs(); @@ -1143,156 +971,99 @@ TYPED_TEST(Dense, ConvertsToEll32) EXPECT_EQ(c[0], 0); EXPECT_EQ(c[1], 1); EXPECT_EQ(c[2], 1); - EXPECT_EQ(c[3], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{0.0}); + EXPECT_EQ(c[3], gko::invalid_index()); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{1.5}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{0.0}); } -TYPED_TEST(Dense, MovesToEll32) +TYPED_TEST(DenseWithIndexType, ConvertsToEll) { - using T = typename TestFixture::value_type; - using Ell = typename gko::matrix::Ell; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Ell = typename gko::matrix::Ell; auto ell_mtx = Ell::create(this->mtx6->get_executor()); - this->mtx6->move_to(ell_mtx); - auto v = ell_mtx->get_const_values(); - auto c = ell_mtx->get_const_col_idxs(); + this->mtx6->convert_to(ell_mtx); - ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); - ASSERT_EQ(ell_mtx->get_num_stored_elements(), 4); - ASSERT_EQ(ell_mtx->get_stride(), 2); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 1); - EXPECT_EQ(c[3], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{0.0}); + assert_ell_eq_mtx6(ell_mtx.get()); } -TYPED_TEST(Dense, ConvertsToEll64) +TYPED_TEST(DenseWithIndexType, MovesToEll) { - using T = typename TestFixture::value_type; - using Ell = typename gko::matrix::Ell; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Ell = typename gko::matrix::Ell; auto ell_mtx = Ell::create(this->mtx6->get_executor()); - this->mtx6->convert_to(ell_mtx); - auto v = ell_mtx->get_const_values(); - auto c = ell_mtx->get_const_col_idxs(); + this->mtx6->move_to(ell_mtx); - ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); - ASSERT_EQ(ell_mtx->get_num_stored_elements(), 4); - ASSERT_EQ(ell_mtx->get_stride(), 2); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 1); - EXPECT_EQ(c[3], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{0.0}); + assert_ell_eq_mtx6(ell_mtx.get()); } -TYPED_TEST(Dense, MovesToEll64) +template +void assert_strided_ell_eq_mtx6( + const gko::matrix::Ell* ell_mtx) { - using T = typename TestFixture::value_type; - using Ell = typename gko::matrix::Ell; - auto ell_mtx = Ell::create(this->mtx6->get_executor()); - - this->mtx6->move_to(ell_mtx); + constexpr auto invalid_index = gko::invalid_index(); auto v = ell_mtx->get_const_values(); auto c = ell_mtx->get_const_col_idxs(); ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); - ASSERT_EQ(ell_mtx->get_num_stored_elements(), 4); - ASSERT_EQ(ell_mtx->get_stride(), 2); + ASSERT_EQ(ell_mtx->get_num_stored_elements(), 6); + ASSERT_EQ(ell_mtx->get_stride(), 3); EXPECT_EQ(c[0], 0); EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 1); - EXPECT_EQ(c[3], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{0.0}); + EXPECT_EQ(c[2], invalid_index); + EXPECT_EQ(c[3], 1); + EXPECT_EQ(c[4], invalid_index); + EXPECT_EQ(c[5], invalid_index); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{1.5}); + EXPECT_EQ(v[2], ValueType{0.0}); + EXPECT_EQ(v[3], ValueType{2.0}); + EXPECT_EQ(v[4], ValueType{0.0}); + EXPECT_EQ(v[5], ValueType{0.0}); } -TYPED_TEST(Dense, ConvertsToEllWithStride) +TYPED_TEST(DenseWithIndexType, ConvertsToEllWithStride) { - using T = typename TestFixture::value_type; - using Ell = typename gko::matrix::Ell; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Ell = typename gko::matrix::Ell; auto ell_mtx = Ell::create(this->mtx6->get_executor(), gko::dim<2>{2, 3}, 2, 3); this->mtx6->convert_to(ell_mtx); - auto v = ell_mtx->get_const_values(); - auto c = ell_mtx->get_const_col_idxs(); - ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); - ASSERT_EQ(ell_mtx->get_num_stored_elements(), 6); - ASSERT_EQ(ell_mtx->get_stride(), 3); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], this->invalid_index); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(c[4], this->invalid_index); - EXPECT_EQ(c[5], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[2], T{0.0}); - EXPECT_EQ(v[3], T{2.0}); - EXPECT_EQ(v[4], T{0.0}); - EXPECT_EQ(v[5], T{0.0}); + assert_strided_ell_eq_mtx6(ell_mtx.get()); } -TYPED_TEST(Dense, MovesToEllWithStride) +TYPED_TEST(DenseWithIndexType, MovesToEllWithStride) { - using T = typename TestFixture::value_type; - using Ell = typename gko::matrix::Ell; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Ell = typename gko::matrix::Ell; auto ell_mtx = Ell::create(this->mtx6->get_executor(), gko::dim<2>{2, 3}, 2, 3); this->mtx6->move_to(ell_mtx); - auto v = ell_mtx->get_const_values(); - auto c = ell_mtx->get_const_col_idxs(); - ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); - ASSERT_EQ(ell_mtx->get_num_stored_elements(), 6); - ASSERT_EQ(ell_mtx->get_stride(), 3); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], this->invalid_index); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(c[4], this->invalid_index); - EXPECT_EQ(c[5], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[2], T{0.0}); - EXPECT_EQ(v[3], T{2.0}); - EXPECT_EQ(v[4], T{0.0}); - EXPECT_EQ(v[5], T{0.0}); + assert_strided_ell_eq_mtx6(ell_mtx.get()); } -TYPED_TEST(Dense, MovesToHybridAutomatically32) +template +void assert_hybrid_auto_eq_mtx4( + const gko::matrix::Hybrid* hybrid_mtx) { - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); - - this->mtx4->move_to(hybrid_mtx); auto v = hybrid_mtx->get_const_coo_values(); auto c = hybrid_mtx->get_const_coo_col_idxs(); auto r = hybrid_mtx->get_const_coo_row_idxs(); @@ -1312,20 +1083,43 @@ TYPED_TEST(Dense, MovesToHybridAutomatically32) EXPECT_EQ(c[1], 1); EXPECT_EQ(c[2], 2); EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{3.0}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{5.0}); } -TYPED_TEST(Dense, ConvertsToHybridAutomatically32) +TYPED_TEST(DenseWithIndexType, MovesToHybridAutomatically) { - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); + + this->mtx4->move_to(hybrid_mtx); + + assert_hybrid_auto_eq_mtx4(hybrid_mtx.get()); +} + + +TYPED_TEST(DenseWithIndexType, ConvertsToHybridAutomatically) +{ + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); this->mtx4->convert_to(hybrid_mtx); + + assert_hybrid_auto_eq_mtx4(hybrid_mtx.get()); +} + + +template +void assert_hybrid_strided_eq_mtx4( + const gko::matrix::Hybrid* hybrid_mtx) +{ auto v = hybrid_mtx->get_const_coo_values(); auto c = hybrid_mtx->get_const_coo_col_idxs(); auto r = hybrid_mtx->get_const_coo_row_idxs(); @@ -1336,7 +1130,7 @@ TYPED_TEST(Dense, ConvertsToHybridAutomatically32) ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); EXPECT_EQ(n, 0); - EXPECT_EQ(p, 2); + EXPECT_EQ(p, 3); EXPECT_EQ(r[0], 0); EXPECT_EQ(r[1], 0); EXPECT_EQ(r[2], 0); @@ -1345,156 +1139,46 @@ TYPED_TEST(Dense, ConvertsToHybridAutomatically32) EXPECT_EQ(c[1], 1); EXPECT_EQ(c[2], 2); EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{3.0}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{5.0}); } -TYPED_TEST(Dense, MovesToHybridAutomatically64) +TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideAutomatically) { - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); - - this->mtx4->move_to(hybrid_mtx); - auto v = hybrid_mtx->get_const_coo_values(); - auto c = hybrid_mtx->get_const_coo_col_idxs(); - auto r = hybrid_mtx->get_const_coo_row_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); - - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); - EXPECT_EQ(n, 0); - EXPECT_EQ(p, 2); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); -} - - -TYPED_TEST(Dense, ConvertsToHybridAutomatically64) -{ - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); - - this->mtx4->convert_to(hybrid_mtx); - auto v = hybrid_mtx->get_const_coo_values(); - auto c = hybrid_mtx->get_const_coo_col_idxs(); - auto r = hybrid_mtx->get_const_coo_row_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); - - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); - EXPECT_EQ(n, 0); - EXPECT_EQ(p, 2); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); -} - - -TYPED_TEST(Dense, MovesToHybridWithStrideAutomatically) -{ - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 0, 3); this->mtx4->move_to(hybrid_mtx); - auto v = hybrid_mtx->get_const_coo_values(); - auto c = hybrid_mtx->get_const_coo_col_idxs(); - auto r = hybrid_mtx->get_const_coo_row_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); - EXPECT_EQ(n, 0); - EXPECT_EQ(p, 3); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); + assert_hybrid_strided_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(Dense, ConvertsToHybridWithStrideAutomatically) +TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideAutomatically) { - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 0, 3); this->mtx4->convert_to(hybrid_mtx); - auto v = hybrid_mtx->get_const_coo_values(); - auto c = hybrid_mtx->get_const_coo_col_idxs(); - auto r = hybrid_mtx->get_const_coo_row_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); - EXPECT_EQ(n, 0); - EXPECT_EQ(p, 3); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{3.0}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{5.0}); + assert_hybrid_strided_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(Dense, MovesToHybridWithStrideAndCooLengthByColumns2) +template +void assert_hybrid_limited_eq_mtx4( + const gko::matrix::Hybrid* hybrid_mtx) { - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = - Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 2, 3, 3, - std::make_shared(2)); - - this->mtx4->move_to(hybrid_mtx); + constexpr auto invalid_index = gko::invalid_index(); auto v = hybrid_mtx->get_const_ell_values(); auto c = hybrid_mtx->get_const_ell_col_idxs(); auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); @@ -1507,68 +1191,56 @@ TYPED_TEST(Dense, MovesToHybridWithStrideAndCooLengthByColumns2) EXPECT_EQ(p, 3); EXPECT_EQ(c[0], 0); EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], this->invalid_index); + EXPECT_EQ(c[2], invalid_index); EXPECT_EQ(c[3], 1); - EXPECT_EQ(c[4], this->invalid_index); - EXPECT_EQ(c[5], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{5.0}); - EXPECT_EQ(v[2], T{0.0}); - EXPECT_EQ(v[3], T{3.0}); - EXPECT_EQ(v[4], T{0.0}); - EXPECT_EQ(v[5], T{0.0}); - EXPECT_EQ(hybrid_mtx->get_const_coo_values()[0], T{2.0}); + EXPECT_EQ(c[4], invalid_index); + EXPECT_EQ(c[5], invalid_index); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{5.0}); + EXPECT_EQ(v[2], ValueType{0.0}); + EXPECT_EQ(v[3], ValueType{3.0}); + EXPECT_EQ(v[4], ValueType{0.0}); + EXPECT_EQ(v[5], ValueType{0.0}); + EXPECT_EQ(hybrid_mtx->get_const_coo_values()[0], ValueType{2.0}); EXPECT_EQ(hybrid_mtx->get_const_coo_row_idxs()[0], 0); EXPECT_EQ(hybrid_mtx->get_const_coo_col_idxs()[0], 2); } -TYPED_TEST(Dense, ConvertsToHybridWithStrideAndCooLengthByColumns2) +TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideAndCooLengthByColumns2) { - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 2, 3, 3, std::make_shared(2)); - this->mtx4->convert_to(hybrid_mtx); - auto v = hybrid_mtx->get_const_ell_values(); - auto c = hybrid_mtx->get_const_ell_col_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); + this->mtx4->move_to(hybrid_mtx); - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 6); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 1); - EXPECT_EQ(n, 2); - EXPECT_EQ(p, 3); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], this->invalid_index); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(c[4], this->invalid_index); - EXPECT_EQ(c[5], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{5.0}); - EXPECT_EQ(v[2], T{0.0}); - EXPECT_EQ(v[3], T{3.0}); - EXPECT_EQ(v[4], T{0.0}); - EXPECT_EQ(v[5], T{0.0}); - EXPECT_EQ(hybrid_mtx->get_const_coo_row_idxs()[0], 0); - EXPECT_EQ(hybrid_mtx->get_const_coo_col_idxs()[0], 2); - EXPECT_EQ(hybrid_mtx->get_const_coo_values()[0], T{2.0}); + assert_hybrid_limited_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(Dense, MovesToHybridWithStrideByPercent40) +TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideAndCooLengthByColumns2) { - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; auto hybrid_mtx = - Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 1, 3, - std::make_shared(0.4)); + Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 2, 3, 3, + std::make_shared(2)); - this->mtx4->move_to(hybrid_mtx); + this->mtx4->convert_to(hybrid_mtx); + + assert_hybrid_limited_eq_mtx4(hybrid_mtx.get()); +} + + +template +void assert_hybrid_percent_eq_mtx4( + const gko::matrix::Hybrid* hybrid_mtx) +{ auto v = hybrid_mtx->get_const_ell_values(); auto c = hybrid_mtx->get_const_ell_col_idxs(); auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); @@ -1583,13 +1255,13 @@ TYPED_TEST(Dense, MovesToHybridWithStrideByPercent40) EXPECT_EQ(p, 3); EXPECT_EQ(c[0], 0); EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{5.0}); - EXPECT_EQ(v[2], T{0.0}); + EXPECT_EQ(c[2], gko::invalid_index()); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{5.0}); + EXPECT_EQ(v[2], ValueType{0.0}); ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 2); - EXPECT_EQ(coo_v[0], T{3.0}); - EXPECT_EQ(coo_v[1], T{2.0}); + EXPECT_EQ(coo_v[0], ValueType{3.0}); + EXPECT_EQ(coo_v[1], ValueType{2.0}); EXPECT_EQ(coo_c[0], 1); EXPECT_EQ(coo_c[1], 2); EXPECT_EQ(coo_r[0], 0); @@ -1597,87 +1269,41 @@ TYPED_TEST(Dense, MovesToHybridWithStrideByPercent40) } -TYPED_TEST(Dense, ConvertsToHybridWithStrideByPercent40) +TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideByPercent40) { - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 1, 3, std::make_shared(0.4)); - this->mtx4->convert_to(hybrid_mtx); - auto v = hybrid_mtx->get_const_ell_values(); - auto c = hybrid_mtx->get_const_ell_col_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); - auto coo_v = hybrid_mtx->get_const_coo_values(); - auto coo_c = hybrid_mtx->get_const_coo_col_idxs(); - auto coo_r = hybrid_mtx->get_const_coo_row_idxs(); + this->mtx4->move_to(hybrid_mtx); - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 3); - EXPECT_EQ(n, 1); - EXPECT_EQ(p, 3); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{5.0}); - EXPECT_EQ(v[2], T{0.0}); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 2); - EXPECT_EQ(coo_v[0], T{3.0}); - EXPECT_EQ(coo_v[1], T{2.0}); - EXPECT_EQ(coo_c[0], 1); - EXPECT_EQ(coo_c[1], 2); - EXPECT_EQ(coo_r[0], 0); - EXPECT_EQ(coo_r[1], 0); + assert_hybrid_percent_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(Dense, ConvertsToSellp32) +TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideByPercent40) { - using T = typename TestFixture::value_type; - using Sellp = typename gko::matrix::Sellp; - auto sellp_mtx = Sellp::create(this->mtx7->get_executor()); + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = + Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 1, 3, + std::make_shared(0.4)); - this->mtx7->convert_to(sellp_mtx); - auto v = sellp_mtx->get_const_values(); - auto c = sellp_mtx->get_const_col_idxs(); - auto s = sellp_mtx->get_const_slice_sets(); - auto l = sellp_mtx->get_const_slice_lengths(); + this->mtx4->convert_to(hybrid_mtx); - ASSERT_EQ(sellp_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sellp_mtx->get_total_cols(), 3); - ASSERT_EQ(sellp_mtx->get_num_stored_elements(), - 3 * gko::matrix::default_slice_size); - ASSERT_EQ(sellp_mtx->get_slice_size(), gko::matrix::default_slice_size); - ASSERT_EQ(sellp_mtx->get_stride_factor(), - gko::matrix::default_stride_factor); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size + 1], this->invalid_index); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size], 2); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size + 1], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[gko::matrix::default_slice_size], T{2.0}); - EXPECT_EQ(v[gko::matrix::default_slice_size + 1], T{0.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size], T{3.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size + 1], T{0.0}); - EXPECT_EQ(s[0], 0); - EXPECT_EQ(s[1], 3); - EXPECT_EQ(l[0], 3); + assert_hybrid_percent_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(Dense, MovesToSellp32) +template +void assert_sellp_eq_mtx7( + const gko::matrix::Sellp* sellp_mtx) { - using T = typename TestFixture::value_type; - using Sellp = typename gko::matrix::Sellp; - auto sellp_mtx = Sellp::create(this->mtx7->get_executor()); - - this->mtx7->move_to(sellp_mtx); + constexpr auto invalid_index = gko::invalid_index(); auto v = sellp_mtx->get_const_values(); auto c = sellp_mtx->get_const_col_idxs(); auto s = sellp_mtx->get_const_slice_sets(); @@ -1693,103 +1319,52 @@ TYPED_TEST(Dense, MovesToSellp32) EXPECT_EQ(c[0], 0); EXPECT_EQ(c[1], 1); EXPECT_EQ(c[gko::matrix::default_slice_size], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size + 1], this->invalid_index); + EXPECT_EQ(c[gko::matrix::default_slice_size + 1], invalid_index); EXPECT_EQ(c[2 * gko::matrix::default_slice_size], 2); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size + 1], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[gko::matrix::default_slice_size], T{2.0}); - EXPECT_EQ(v[gko::matrix::default_slice_size + 1], T{0.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size], T{3.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size + 1], T{0.0}); + EXPECT_EQ(c[2 * gko::matrix::default_slice_size + 1], invalid_index); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{1.5}); + EXPECT_EQ(v[gko::matrix::default_slice_size], ValueType{2.0}); + EXPECT_EQ(v[gko::matrix::default_slice_size + 1], ValueType{0.0}); + EXPECT_EQ(v[2 * gko::matrix::default_slice_size], ValueType{3.0}); + EXPECT_EQ(v[2 * gko::matrix::default_slice_size + 1], ValueType{0.0}); EXPECT_EQ(s[0], 0); EXPECT_EQ(s[1], 3); EXPECT_EQ(l[0], 3); } -TYPED_TEST(Dense, ConvertsToSellp64) +TYPED_TEST(DenseWithIndexType, ConvertsToSellp) { - using T = typename TestFixture::value_type; - using Sellp = typename gko::matrix::Sellp; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Sellp = typename gko::matrix::Sellp; auto sellp_mtx = Sellp::create(this->mtx7->get_executor()); this->mtx7->convert_to(sellp_mtx); - auto v = sellp_mtx->get_const_values(); - auto c = sellp_mtx->get_const_col_idxs(); - auto s = sellp_mtx->get_const_slice_sets(); - auto l = sellp_mtx->get_const_slice_lengths(); - ASSERT_EQ(sellp_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sellp_mtx->get_total_cols(), 3); - ASSERT_EQ(sellp_mtx->get_num_stored_elements(), - 3 * gko::matrix::default_slice_size); - ASSERT_EQ(sellp_mtx->get_slice_size(), gko::matrix::default_slice_size); - ASSERT_EQ(sellp_mtx->get_stride_factor(), - gko::matrix::default_stride_factor); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size + 1], this->invalid_index); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size], 2); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size + 1], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[gko::matrix::default_slice_size], T{2.0}); - EXPECT_EQ(v[gko::matrix::default_slice_size + 1], T{0.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size], T{3.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size + 1], T{0.0}); - EXPECT_EQ(s[0], 0); - EXPECT_EQ(s[1], 3); - EXPECT_EQ(l[0], 3); + assert_sellp_eq_mtx7(sellp_mtx.get()); } -TYPED_TEST(Dense, MovesToSellp64) +TYPED_TEST(DenseWithIndexType, MovesToSellp) { - using T = typename TestFixture::value_type; - using Sellp = typename gko::matrix::Sellp; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Sellp = typename gko::matrix::Sellp; auto sellp_mtx = Sellp::create(this->mtx7->get_executor()); this->mtx7->move_to(sellp_mtx); - auto v = sellp_mtx->get_const_values(); - auto c = sellp_mtx->get_const_col_idxs(); - auto s = sellp_mtx->get_const_slice_sets(); - auto l = sellp_mtx->get_const_slice_lengths(); - ASSERT_EQ(sellp_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sellp_mtx->get_total_cols(), 3); - ASSERT_EQ(sellp_mtx->get_num_stored_elements(), - 3 * gko::matrix::default_slice_size); - ASSERT_EQ(sellp_mtx->get_slice_size(), gko::matrix::default_slice_size); - ASSERT_EQ(sellp_mtx->get_stride_factor(), - gko::matrix::default_stride_factor); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size + 1], this->invalid_index); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size], 2); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size + 1], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[gko::matrix::default_slice_size], T{2.0}); - EXPECT_EQ(v[gko::matrix::default_slice_size + 1], T{0.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size], T{3.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size + 1], T{0.0}); - EXPECT_EQ(s[0], 0); - EXPECT_EQ(s[1], 3); - EXPECT_EQ(l[0], 3); + assert_sellp_eq_mtx7(sellp_mtx.get()); } -TYPED_TEST(Dense, ConvertsToSellpWithSliceSizeAndStrideFactor) +template +void assert_sellp_strided_eq_mtx7( + const gko::matrix::Sellp* sellp_mtx) { - using T = typename TestFixture::value_type; - using Sellp = typename gko::matrix::Sellp; - auto sellp_mtx = - Sellp::create(this->mtx7->get_executor(), gko::dim<2>{}, 2, 2, 0); - - this->mtx7->convert_to(sellp_mtx); + constexpr auto invalid_index = gko::invalid_index(); auto v = sellp_mtx->get_const_values(); auto c = sellp_mtx->get_const_col_idxs(); auto s = sellp_mtx->get_const_slice_sets(); @@ -1803,70 +1378,59 @@ TYPED_TEST(Dense, ConvertsToSellpWithSliceSizeAndStrideFactor) EXPECT_EQ(c[0], 0); EXPECT_EQ(c[1], 1); EXPECT_EQ(c[2], 1); - EXPECT_EQ(c[3], this->invalid_index); + EXPECT_EQ(c[3], invalid_index); EXPECT_EQ(c[4], 2); - EXPECT_EQ(c[5], this->invalid_index); - EXPECT_EQ(c[6], this->invalid_index); - EXPECT_EQ(c[7], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{0.0}); - EXPECT_EQ(v[4], T{3.0}); - EXPECT_EQ(v[5], T{0.0}); - EXPECT_EQ(v[6], T{0.0}); - EXPECT_EQ(v[7], T{0.0}); + EXPECT_EQ(c[5], invalid_index); + EXPECT_EQ(c[6], invalid_index); + EXPECT_EQ(c[7], invalid_index); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{1.5}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{0.0}); + EXPECT_EQ(v[4], ValueType{3.0}); + EXPECT_EQ(v[5], ValueType{0.0}); + EXPECT_EQ(v[6], ValueType{0.0}); + EXPECT_EQ(v[7], ValueType{0.0}); EXPECT_EQ(s[0], 0); EXPECT_EQ(s[1], 4); EXPECT_EQ(l[0], 4); } -TYPED_TEST(Dense, MovesToSellpWithSliceSizeAndStrideFactor) +TYPED_TEST(DenseWithIndexType, ConvertsToSellpWithSliceSizeAndStrideFactor) { - using T = typename TestFixture::value_type; - using Sellp = typename gko::matrix::Sellp; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Sellp = typename gko::matrix::Sellp; + auto sellp_mtx = + Sellp::create(this->mtx7->get_executor(), gko::dim<2>{}, 2, 2, 0); + + this->mtx7->convert_to(sellp_mtx); + + assert_sellp_strided_eq_mtx7(sellp_mtx.get()); +} + + +TYPED_TEST(DenseWithIndexType, MovesToSellpWithSliceSizeAndStrideFactor) +{ + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Sellp = typename gko::matrix::Sellp; auto sellp_mtx = Sellp::create(this->mtx7->get_executor(), gko::dim<2>{}, 2, 2, 0); this->mtx7->move_to(sellp_mtx); - auto v = sellp_mtx->get_const_values(); - auto c = sellp_mtx->get_const_col_idxs(); - auto s = sellp_mtx->get_const_slice_sets(); - auto l = sellp_mtx->get_const_slice_lengths(); - ASSERT_EQ(sellp_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sellp_mtx->get_total_cols(), 4); - ASSERT_EQ(sellp_mtx->get_num_stored_elements(), 8); - ASSERT_EQ(sellp_mtx->get_slice_size(), 2); - ASSERT_EQ(sellp_mtx->get_stride_factor(), 2); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 1); - EXPECT_EQ(c[3], this->invalid_index); - EXPECT_EQ(c[4], 2); - EXPECT_EQ(c[5], this->invalid_index); - EXPECT_EQ(c[6], this->invalid_index); - EXPECT_EQ(c[7], this->invalid_index); - EXPECT_EQ(v[0], T{1.0}); - EXPECT_EQ(v[1], T{1.5}); - EXPECT_EQ(v[2], T{2.0}); - EXPECT_EQ(v[3], T{0.0}); - EXPECT_EQ(v[4], T{3.0}); - EXPECT_EQ(v[5], T{0.0}); - EXPECT_EQ(v[6], T{0.0}); - EXPECT_EQ(v[7], T{0.0}); - EXPECT_EQ(s[0], 0); - EXPECT_EQ(s[1], 4); - EXPECT_EQ(l[0], 4); + assert_sellp_strided_eq_mtx7(sellp_mtx.get()); } -TYPED_TEST(Dense, ConvertsToAndFromSellpWithMoreThanOneSlice) +TYPED_TEST(DenseWithIndexType, ConvertsToAndFromSellpWithMoreThanOneSlice) { - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; using Mtx = typename TestFixture::Mtx; - using Sellp = typename gko::matrix::Sellp; + using Sellp = typename gko::matrix::Sellp; auto x = this->template gen_mtx(65, 25); auto sellp_mtx = Sellp::create(this->exec); @@ -1908,11 +1472,12 @@ TYPED_TEST(Dense, MovesEmptyToPrecision) } -TYPED_TEST(Dense, ConvertsEmptyToCoo) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToCoo) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Coo = typename gko::matrix::Coo; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Coo = typename gko::matrix::Coo; auto empty = Dense::create(this->exec); auto res = Coo::create(this->exec); @@ -1923,11 +1488,12 @@ TYPED_TEST(Dense, ConvertsEmptyToCoo) } -TYPED_TEST(Dense, MovesEmptyToCoo) +TYPED_TEST(DenseWithIndexType, MovesEmptyToCoo) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Coo = typename gko::matrix::Coo; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Coo = typename gko::matrix::Coo; auto empty = Dense::create(this->exec); auto res = Coo::create(this->exec); @@ -1938,11 +1504,12 @@ TYPED_TEST(Dense, MovesEmptyToCoo) } -TYPED_TEST(Dense, ConvertsEmptyMatrixToCsr) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyMatrixToCsr) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Csr = typename gko::matrix::Csr; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Csr = typename gko::matrix::Csr; auto empty = Dense::create(this->exec); auto res = Csr::create(this->exec); @@ -1954,11 +1521,12 @@ TYPED_TEST(Dense, ConvertsEmptyMatrixToCsr) } -TYPED_TEST(Dense, MovesEmptyMatrixToCsr) +TYPED_TEST(DenseWithIndexType, MovesEmptyMatrixToCsr) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Csr = typename gko::matrix::Csr; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Csr = typename gko::matrix::Csr; auto empty = Dense::create(this->exec); auto res = Csr::create(this->exec); @@ -1970,11 +1538,13 @@ TYPED_TEST(Dense, MovesEmptyMatrixToCsr) } -TYPED_TEST(Dense, ConvertsEmptyToSparsityCsr) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToSparsityCsr) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using SparsityCsr = typename gko::matrix::SparsityCsr; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using SparsityCsr = + typename gko::matrix::SparsityCsr; auto empty = Dense::create(this->exec); auto res = SparsityCsr::create(this->exec); @@ -1986,11 +1556,13 @@ TYPED_TEST(Dense, ConvertsEmptyToSparsityCsr) } -TYPED_TEST(Dense, MovesEmptyToSparsityCsr) +TYPED_TEST(DenseWithIndexType, MovesEmptyToSparsityCsr) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using SparsityCsr = typename gko::matrix::SparsityCsr; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using SparsityCsr = + typename gko::matrix::SparsityCsr; auto empty = Dense::create(this->exec); auto res = SparsityCsr::create(this->exec); @@ -2002,11 +1574,12 @@ TYPED_TEST(Dense, MovesEmptyToSparsityCsr) } -TYPED_TEST(Dense, ConvertsEmptyToEll) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToEll) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Ell = typename gko::matrix::Ell; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Ell = typename gko::matrix::Ell; auto empty = Dense::create(this->exec); auto res = Ell::create(this->exec); @@ -2017,11 +1590,12 @@ TYPED_TEST(Dense, ConvertsEmptyToEll) } -TYPED_TEST(Dense, MovesEmptyToEll) +TYPED_TEST(DenseWithIndexType, MovesEmptyToEll) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Ell = typename gko::matrix::Ell; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Ell = typename gko::matrix::Ell; auto empty = Dense::create(this->exec); auto res = Ell::create(this->exec); @@ -2032,11 +1606,12 @@ TYPED_TEST(Dense, MovesEmptyToEll) } -TYPED_TEST(Dense, ConvertsEmptyToHybrid) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToHybrid) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; auto empty = Dense::create(this->exec); auto res = Hybrid::create(this->exec); @@ -2047,11 +1622,12 @@ TYPED_TEST(Dense, ConvertsEmptyToHybrid) } -TYPED_TEST(Dense, MovesEmptyToHybrid) +TYPED_TEST(DenseWithIndexType, MovesEmptyToHybrid) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Hybrid = typename gko::matrix::Hybrid; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; auto empty = Dense::create(this->exec); auto res = Hybrid::create(this->exec); @@ -2062,11 +1638,12 @@ TYPED_TEST(Dense, MovesEmptyToHybrid) } -TYPED_TEST(Dense, ConvertsEmptyToSellp) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToSellp) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Sellp = typename gko::matrix::Sellp; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Sellp = typename gko::matrix::Sellp; auto empty = Dense::create(this->exec); auto res = Sellp::create(this->exec); @@ -2078,11 +1655,12 @@ TYPED_TEST(Dense, ConvertsEmptyToSellp) } -TYPED_TEST(Dense, MovesEmptyToSellp) +TYPED_TEST(DenseWithIndexType, MovesEmptyToSellp) { using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using Sellp = typename gko::matrix::Sellp; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Sellp = typename gko::matrix::Sellp; auto empty = Dense::create(this->exec); auto res = Sellp::create(this->exec); @@ -2159,961 +1737,400 @@ TYPED_TEST(Dense, NonSquareMatrixIsTransposableIntoDense) auto trans = Mtx::create(this->exec, gko::transpose(this->mtx4->get_size())); - this->mtx4->transpose(trans); - - GKO_ASSERT_MTX_NEAR(trans, l({{1.0, 0.0}, {3.0, 5.0}, {2.0, 0.0}}), 0.0); -} - - -TYPED_TEST(Dense, NonSquareSubmatrixIsTransposableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto trans = Mtx::create(this->exec, gko::dim<2>{2, 1}, 5); - - this->mtx4->create_submatrix({0, 1}, {0, 2})->transpose(trans); - - GKO_ASSERT_MTX_NEAR(trans, l({1.0, 3.0}), 0.0); - ASSERT_EQ(trans->get_stride(), 5); -} - - -TYPED_TEST(Dense, NonSquareMatrixIsTransposableIntoDenseFailsForWrongDimensions) -{ - using Mtx = typename TestFixture::Mtx; - - ASSERT_THROW(this->mtx4->transpose(Mtx::create(this->exec)), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixCanGatherRows) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - - auto row_collection = this->mtx5->row_gather(&permute_idxs); - - GKO_ASSERT_MTX_NEAR(row_collection, - l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixCanGatherRowsIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_collection = Mtx::create(exec, gko::dim<2>{2, 3}); - - this->mtx5->row_gather(&permute_idxs, row_collection); - - GKO_ASSERT_MTX_NEAR(row_collection, - l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), 0.0); -} - - -TYPED_TEST(Dense, SquareSubmatrixCanGatherRowsIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_collection = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - - this->mtx5->create_submatrix({0, 2}, {1, 3}) - ->row_gather(&permute_idxs, row_collection); - - GKO_ASSERT_MTX_NEAR(row_collection, l({{2.0, 4.5}, {-1.0, -0.5}}), 0.0); - ASSERT_EQ(row_collection->get_stride(), 4); -} - - -TYPED_TEST(Dense, NonSquareSubmatrixCanGatherRowsIntoMixedDense) -{ - using Mtx = typename TestFixture::Mtx; - using MixedMtx = typename TestFixture::MixedMtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx4->get_executor(); - gko::array gather_index{exec, {1, 0, 1}}; - auto row_collection = MixedMtx::create(exec, gko::dim<2>{3, 3}, 4); - - this->mtx4->row_gather(&gather_index, row_collection); - - GKO_ASSERT_MTX_NEAR( - row_collection, - l( - {{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}, {0.0, 5.0, 0.0}}), - 0.0); -} - - -TYPED_TEST(Dense, NonSquareSubmatrixCanAdvancedGatherRowsIntoMixedDense) -{ - using Mtx = typename TestFixture::Mtx; - using MixedMtx = typename TestFixture::MixedMtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx4->get_executor(); - gko::array gather_index{exec, {1, 0, 1}}; - auto row_collection = gko::initialize( - {{1.0, 0.5, -1.0}, {-1.5, 0.5, 1.0}, {2.0, -3.0, 1.0}}, exec); - auto alpha = gko::initialize({1.0}, exec); - auto beta = gko::initialize({2.0}, exec); - - this->mtx4->row_gather(alpha, &gather_index, beta, row_collection); - - GKO_ASSERT_MTX_NEAR( - row_collection, - l( - {{2.0, 6.0, -2.0}, {-2.0, 4.0, 4.0}, {4.0, -1.0, 2.0}}), - 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixGatherRowsIntoDenseFailsForWrongDimensions) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - - ASSERT_THROW(this->mtx5->row_gather(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixCanGatherRows64) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - - auto row_collection = this->mtx5->row_gather(&permute_idxs); - - GKO_ASSERT_MTX_NEAR(row_collection, - l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixCanGatherRowsIntoDense64) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_collection = Mtx::create(exec, gko::dim<2>{2, 3}); - - this->mtx5->row_gather(&permute_idxs, row_collection); - - GKO_ASSERT_MTX_NEAR(row_collection, - l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), 0.0); -} - - -TYPED_TEST(Dense, SquareSubmatrixCanGatherRowsIntoDense64) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_collection = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - - this->mtx5->create_submatrix({0, 2}, {1, 3}) - ->row_gather(&permute_idxs, row_collection); - - GKO_ASSERT_MTX_NEAR(row_collection, l({{2.0, 4.5}, {-1.0, -0.5}}), 0.0); - ASSERT_EQ(row_collection->get_stride(), 4); -} - - -TYPED_TEST(Dense, NonSquareSubmatrixCanGatherRowsIntoMixedDense64) -{ - using Mtx = typename TestFixture::Mtx; - using MixedMtx = typename TestFixture::MixedMtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx4->get_executor(); - gko::array gather_index{exec, {1, 0, 1}}; - auto row_collection = MixedMtx::create(exec, gko::dim<2>{3, 3}, 4); - - this->mtx4->row_gather(&gather_index, row_collection); - - GKO_ASSERT_MTX_NEAR( - row_collection, - l( - {{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}, {0.0, 5.0, 0.0}}), - 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixGatherRowsIntoDenseFailsForWrongDimensions64) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - - ASSERT_THROW(this->mtx5->row_gather(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixIsPermutable) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - auto ref_permuted = - gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - auto permuted = gko::as(this->mtx5->permute(&permute_idxs)); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixIsPermutableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto permuted = Mtx::create(exec, this->mtx5->get_size()); - - auto ref_permuted = - gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - this->mtx5->permute(&permute_idxs, permuted); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); -} - - -TYPED_TEST(Dense, SquareSubmatrixIsPermutableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); - - auto ref_permuted = - gko::as(gko::as(mtx->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - mtx->permute(&permute_idxs, permuted); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); - ASSERT_EQ(permuted->get_stride(), 4); -} - - -TYPED_TEST(Dense, NonSquareMatrixPermuteIntoDenseFails) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - ASSERT_THROW(this->mtx4->permute(&permute_idxs, this->mtx4->clone()), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixPermuteIntoDenseFailsForWrongPermutationSize) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - - ASSERT_THROW(this->mtx5->permute(&permute_idxs, this->mtx5->clone()), - gko::ValueMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixPermuteIntoDenseFailsForWrongDimensions) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - ASSERT_THROW(this->mtx5->permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixIsInversePermutable) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - auto ref_permuted = gko::as( - gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - auto permuted = gko::as(this->mtx5->inverse_permute(&permute_idxs)); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixIsInversePermutableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto permuted = Mtx::create(exec, this->mtx5->get_size()); - - auto ref_permuted = gko::as( - gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - this->mtx5->inverse_permute(&permute_idxs, permuted); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); -} - - -TYPED_TEST(Dense, SquareSubmatrixIsInversePermutableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); - - auto ref_permuted = - gko::as(gko::as(mtx->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - mtx->inverse_permute(&permute_idxs, permuted); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); - ASSERT_EQ(permuted->get_stride(), 4); -} - - -TYPED_TEST(Dense, NonSquareMatrixInversePermuteIntoDenseFails) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - ASSERT_THROW( - this->mtx4->inverse_permute(&permute_idxs, this->mtx4->clone()), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, - SquareMatrixInversePermuteIntoDenseFailsForWrongPermutationSize) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {0, 1}}; - - ASSERT_THROW( - this->mtx5->inverse_permute(&permute_idxs, this->mtx5->clone()), - gko::ValueMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixInversePermuteIntoDenseFailsForWrongDimensions) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - ASSERT_THROW(this->mtx5->inverse_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixIsPermutable64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - auto ref_permuted = - gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - auto permuted = gko::as(this->mtx5->permute(&permute_idxs)); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixIsPermutableIntoDense64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto permuted = Mtx::create(exec, this->mtx5->get_size()); - - auto ref_permuted = - gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - this->mtx5->permute(&permute_idxs, permuted); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); -} - - -TYPED_TEST(Dense, SquareSubmatrixIsPermutableIntoDense64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); - - auto ref_permuted = - gko::as(gko::as(mtx->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - mtx->permute(&permute_idxs, permuted); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); - ASSERT_EQ(permuted->get_stride(), 4); -} - - -TYPED_TEST(Dense, NonSquareMatrixPermuteIntoDenseFails64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - ASSERT_THROW(this->mtx4->permute(&permute_idxs, this->mtx4->clone()), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixPermuteIntoDenseFailsForWrongPermutationSize64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - - ASSERT_THROW(this->mtx5->permute(&permute_idxs, this->mtx5->clone()), - gko::ValueMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixPermuteIntoDenseFailsForWrongDimensions64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - ASSERT_THROW(this->mtx5->permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixIsInversePermutable64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - auto ref_permuted = gko::as( - gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - auto permuted = gko::as(this->mtx5->inverse_permute(&permute_idxs)); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixIsInversePermutableIntoDense64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto permuted = Mtx::create(exec, this->mtx5->get_size()); - - auto ref_permuted = gko::as( - gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - this->mtx5->inverse_permute(&permute_idxs, permuted); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); -} - - -TYPED_TEST(Dense, SquareSubmatrixIsInversePermutableIntoDense64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); - - auto ref_permuted = - gko::as(gko::as(mtx->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - mtx->inverse_permute(&permute_idxs, permuted); - - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); - ASSERT_EQ(permuted->get_stride(), 4); -} - - -TYPED_TEST(Dense, NonSquareMatrixInversePermuteIntoDenseFails64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - ASSERT_THROW( - this->mtx4->inverse_permute(&permute_idxs, this->mtx4->clone()), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, - SquareMatrixInversePermuteIntoDenseFailsForWrongPermutationSize64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - - ASSERT_THROW( - this->mtx5->inverse_permute(&permute_idxs, this->mtx5->clone()), - gko::ValueMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixInversePermuteIntoDenseFailsForWrongDimensions64) -{ - using Mtx = typename TestFixture::Mtx; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - ASSERT_THROW(this->mtx5->inverse_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, SquareMatrixIsRowPermutable) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - auto row_permute = gko::as(this->mtx5->row_permute(&permute_idxs)); - - GKO_ASSERT_MTX_NEAR( - row_permute, - l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), 0.0); -} - - -TYPED_TEST(Dense, NonSquareMatrixIsRowPermutable) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - - auto row_permute = gko::as(this->mtx4->row_permute(&permute_idxs)); - - GKO_ASSERT_MTX_NEAR(row_permute, l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), - 0.0); -} - - -TYPED_TEST(Dense, SquareMatrixIsRowPermutableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - - this->mtx5->row_permute(&permute_idxs, row_permute); - - GKO_ASSERT_MTX_NEAR( - row_permute, - l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), 0.0); -} - - -TYPED_TEST(Dense, SquareSubmatrixIsRowPermutableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - - this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->row_permute(&permute_idxs, row_permute); + this->mtx4->transpose(trans); - GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), 0.0); - ASSERT_EQ(row_permute->get_stride(), 4); + GKO_ASSERT_MTX_NEAR(trans, l({{1.0, 0.0}, {3.0, 5.0}, {2.0, 0.0}}), 0.0); } -TYPED_TEST(Dense, SquareMatrixRowPermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(Dense, NonSquareSubmatrixIsTransposableIntoDense) { using Mtx = typename TestFixture::Mtx; using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + auto trans = Mtx::create(this->exec, gko::dim<2>{2, 1}, 5); - ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, row_permute), - gko::ValueMismatch); + this->mtx4->create_submatrix({0, 1}, {0, 2})->transpose(trans); + + GKO_ASSERT_MTX_NEAR(trans, l({1.0, 3.0}), 0.0); + ASSERT_EQ(trans->get_stride(), 5); } -TYPED_TEST(Dense, SquareMatrixRowPermuteIntoDenseFailsForWrongDimensions) +TYPED_TEST(Dense, NonSquareMatrixIsTransposableIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, Mtx::create(exec)), + ASSERT_THROW(this->mtx4->transpose(Mtx::create(this->exec)), gko::DimensionMismatch); } -TYPED_TEST(Dense, SquareMatrixIsColPermutable) +TYPED_TEST(DenseWithIndexType, SquareMatrixCanGatherRows) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 0}}; - auto c_permute = gko::as(this->mtx5->column_permute(&permute_idxs)); + auto row_collection = this->mtx5->row_gather(&permute_idxs); - GKO_ASSERT_MTX_NEAR( - c_permute, l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), - 0.0); + GKO_ASSERT_MTX_NEAR(row_collection, + l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), + 0.0); } -TYPED_TEST(Dense, NonSquareMatrixIsColPermutable) +TYPED_TEST(DenseWithIndexType, SquareMatrixCanGatherRowsIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 0}}; + auto row_collection = Mtx::create(exec, gko::dim<2>{2, 3}); - auto c_permute = gko::as(this->mtx4->column_permute(&permute_idxs)); + this->mtx5->row_gather(&permute_idxs, row_collection); - GKO_ASSERT_MTX_NEAR(c_permute, l({{3.0, 2.0, 1.0}, {5.0, 0.0, 0.0}}), + GKO_ASSERT_MTX_NEAR(row_collection, + l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), 0.0); } -TYPED_TEST(Dense, SquareMatrixIsColPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixCanGatherRowsIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto c_permute = Mtx::create(exec, this->mtx5->get_size()); + gko::array permute_idxs{exec, {1, 0}}; + auto row_collection = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - this->mtx5->column_permute(&permute_idxs, c_permute); + this->mtx5->create_submatrix({0, 2}, {1, 3}) + ->row_gather(&permute_idxs, row_collection); - GKO_ASSERT_MTX_NEAR( - c_permute, l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), - 0.0); + GKO_ASSERT_MTX_NEAR(row_collection, + l({{2.0, 4.5}, {-1.0, -0.5}}), 0.0); + ASSERT_EQ(row_collection->get_stride(), 4); } -TYPED_TEST(Dense, SquareSubmatrixIsColPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, NonSquareSubmatrixCanGatherRowsIntoMixedDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + using MixedMtx = typename TestFixture::MixedMtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array gather_index{exec, {1, 0, 1}}; + auto row_collection = MixedMtx::create(exec, gko::dim<2>{3, 3}, 4); - this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->column_permute(&permute_idxs, c_permute); + this->mtx4->row_gather(&gather_index, row_collection); - GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), 0.0); - ASSERT_EQ(c_permute->get_stride(), 4); + GKO_ASSERT_MTX_NEAR( + row_collection, + l( + {{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}, {0.0, 5.0, 0.0}}), + 0.0); } -TYPED_TEST(Dense, SquareMatrixColPermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(DenseWithIndexType, + NonSquareSubmatrixCanAdvancedGatherRowsIntoMixedDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + using MixedMtx = typename TestFixture::MixedMtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array gather_index{exec, {1, 0, 1}}; + auto row_collection = gko::initialize( + {{1.0, 0.5, -1.0}, {-1.5, 0.5, 1.0}, {2.0, -3.0, 1.0}}, exec); + auto alpha = gko::initialize({1.0}, exec); + auto beta = gko::initialize({2.0}, exec); - ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, row_permute), - gko::ValueMismatch); + this->mtx4->row_gather(alpha, &gather_index, beta, row_collection); + + GKO_ASSERT_MTX_NEAR( + row_collection, + l( + {{2.0, 6.0, -2.0}, {-2.0, 4.0, 4.0}, {4.0, -1.0, 2.0}}), + 0.0); } -TYPED_TEST(Dense, SquareMatrixColPermuteIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, + SquareMatrixGatherRowsIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 0}}; - ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, Mtx::create(exec)), + ASSERT_THROW(this->mtx5->row_gather(&permute_idxs, Mtx::create(exec)), gko::DimensionMismatch); } -TYPED_TEST(Dense, SquareMatrixIsInverseRowPermutable) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; - auto inverse_row_permute = - gko::as(this->mtx5->inverse_row_permute(&inverse_permute_idxs)); + auto ref_permuted = + gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) + ->column_permute(&permute_idxs)); + auto permuted = gko::as(this->mtx5->permute(&permute_idxs)); - GKO_ASSERT_MTX_NEAR( - inverse_row_permute, - l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), 0.0); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); } -TYPED_TEST(Dense, NonSquareMatrixIsInverseRowPermutable) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx4->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 0}}; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - auto inverse_row_permute = - gko::as(this->mtx4->inverse_row_permute(&inverse_permute_idxs)); + auto ref_permuted = + gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) + ->column_permute(&permute_idxs)); + this->mtx5->permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR(inverse_row_permute, - l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); } -TYPED_TEST(Dense, SquareMatrixIsInverseRowPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + gko::array permute_idxs{exec, {1, 0}}; + auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); - this->mtx5->inverse_row_permute(&permute_idxs, row_permute); + auto ref_permuted = + gko::as(gko::as(mtx->row_permute(&permute_idxs)) + ->column_permute(&permute_idxs)); + mtx->permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR( - row_permute, - l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), 0.0); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); + ASSERT_EQ(permuted->get_stride(), 4); } -TYPED_TEST(Dense, SquareSubmatrixIsInverseRowPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixPermuteIntoDenseFails) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - - this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->inverse_row_permute(&permute_idxs, row_permute); + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), 0.0); - ASSERT_EQ(row_permute->get_stride(), 4); + ASSERT_THROW(this->mtx4->permute(&permute_idxs, this->mtx4->clone()), + gko::DimensionMismatch); } -TYPED_TEST(Dense, - SquareMatrixInverseRowPermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(DenseWithIndexType, + SquareMatrixPermuteIntoDenseFailsForWrongPermutationSize) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + gko::array permute_idxs{exec, {1, 2}}; - ASSERT_THROW(this->mtx5->inverse_row_permute(&permute_idxs, row_permute), + ASSERT_THROW(this->mtx5->permute(&permute_idxs, this->mtx5->clone()), gko::ValueMismatch); } -TYPED_TEST(Dense, SquareMatrixInverseRowPermuteIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, + SquareMatrixPermuteIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; - ASSERT_THROW( - this->mtx5->inverse_row_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); + ASSERT_THROW(this->mtx5->permute(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } -TYPED_TEST(Dense, SquareMatrixIsInverseColPermutable) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInversePermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; - auto inverse_c_permute = - gko::as(this->mtx5->inverse_column_permute(&inverse_permute_idxs)); + auto ref_permuted = gko::as( + gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) + ->inverse_column_permute(&permute_idxs)); + auto permuted = gko::as(this->mtx5->inverse_permute(&permute_idxs)); - GKO_ASSERT_MTX_NEAR( - inverse_c_permute, - l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), 0.0); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); } -TYPED_TEST(Dense, NonSquareMatrixIsInverseColPermutable) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInversePermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx4->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - auto inverse_c_permute = - gko::as(this->mtx4->inverse_column_permute(&inverse_permute_idxs)); + auto ref_permuted = gko::as( + gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) + ->inverse_column_permute(&permute_idxs)); + this->mtx5->inverse_permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR(inverse_c_permute, - l({{2.0, 1.0, 3.0}, {0.0, 0.0, 5.0}}), 0.0); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); } -TYPED_TEST(Dense, SquareMatrixIsInverseColPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInversePermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto c_permute = Mtx::create(exec, this->mtx5->get_size()); + gko::array permute_idxs{exec, {1, 0}}; + auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); - this->mtx5->inverse_column_permute(&permute_idxs, c_permute); + auto ref_permuted = + gko::as(gko::as(mtx->inverse_row_permute(&permute_idxs)) + ->inverse_column_permute(&permute_idxs)); + mtx->inverse_permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR( - c_permute, l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), - 0.0); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); + ASSERT_EQ(permuted->get_stride(), 4); } -TYPED_TEST(Dense, SquareSubmatrixIsInverseColPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixInversePermuteIntoDenseFails) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - - this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->column_permute(&permute_idxs, c_permute); + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), 0.0); - ASSERT_EQ(c_permute->get_stride(), 4); + ASSERT_THROW( + this->mtx4->inverse_permute(&permute_idxs, this->mtx4->clone()), + gko::DimensionMismatch); } -TYPED_TEST(Dense, - SquareMatrixInverseColPermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInversePermuteIntoDenseFailsForWrongPermutationSize) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + gko::array permute_idxs{exec, {0, 1}}; - ASSERT_THROW(this->mtx5->inverse_column_permute(&permute_idxs, row_permute), - gko::ValueMismatch); + ASSERT_THROW( + this->mtx5->inverse_permute(&permute_idxs, this->mtx5->clone()), + gko::ValueMismatch); } -TYPED_TEST(Dense, SquareMatrixInverseColPermuteIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInversePermuteIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; - ASSERT_THROW( - this->mtx5->inverse_column_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); + ASSERT_THROW(this->mtx5->inverse_permute(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } -TYPED_TEST(Dense, SquareMatrixIsRowPermutable64) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsRowPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; auto row_permute = gko::as(this->mtx5->row_permute(&permute_idxs)); GKO_ASSERT_MTX_NEAR( row_permute, - l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), 0.0); + l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), + 0.0); } -TYPED_TEST(Dense, NonSquareMatrixIsRowPermutable64) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsRowPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; + gko::array permute_idxs{exec, {1, 0}}; auto row_permute = gko::as(this->mtx4->row_permute(&permute_idxs)); - GKO_ASSERT_MTX_NEAR(row_permute, l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), - 0.0); + GKO_ASSERT_MTX_NEAR(row_permute, + l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); } -TYPED_TEST(Dense, SquareMatrixIsRowPermutableIntoDense64) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsRowPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; auto row_permute = Mtx::create(exec, this->mtx5->get_size()); this->mtx5->row_permute(&permute_idxs, row_permute); GKO_ASSERT_MTX_NEAR( row_permute, - l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), 0.0); + l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), + 0.0); } -TYPED_TEST(Dense, SquareSubmatrixIsRowPermutableIntoDense64) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsRowPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; + gko::array permute_idxs{exec, {1, 0}}; auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); this->mtx5->create_submatrix({0, 2}, {0, 2}) ->row_permute(&permute_idxs, row_permute); - GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), 0.0); + GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), + 0.0); ASSERT_EQ(row_permute->get_stride(), 4); } -TYPED_TEST(Dense, SquareMatrixRowPermuteIntoDenseFailsForWrongPermutationSize64) +TYPED_TEST(DenseWithIndexType, + SquareMatrixRowPermuteIntoDenseFailsForWrongPermutationSize) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; + gko::array permute_idxs{exec, {1, 2}}; auto row_permute = Mtx::create(exec, this->mtx5->get_size()); ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, row_permute), @@ -3121,85 +2138,94 @@ TYPED_TEST(Dense, SquareMatrixRowPermuteIntoDenseFailsForWrongPermutationSize64) } -TYPED_TEST(Dense, SquareMatrixRowPermuteIntoDenseFailsForWrongDimensions64) +TYPED_TEST(DenseWithIndexType, + SquareMatrixRowPermuteIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, Mtx::create(exec)), gko::DimensionMismatch); } -TYPED_TEST(Dense, SquareMatrixIsColPermutable64) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsColPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; auto c_permute = gko::as(this->mtx5->column_permute(&permute_idxs)); GKO_ASSERT_MTX_NEAR( - c_permute, l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), + c_permute, + l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), 0.0); } -TYPED_TEST(Dense, NonSquareMatrixIsColPermutable64) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsColPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; auto c_permute = gko::as(this->mtx4->column_permute(&permute_idxs)); - GKO_ASSERT_MTX_NEAR(c_permute, l({{3.0, 2.0, 1.0}, {5.0, 0.0, 0.0}}), - 0.0); + GKO_ASSERT_MTX_NEAR(c_permute, + l({{3.0, 2.0, 1.0}, {5.0, 0.0, 0.0}}), 0.0); } -TYPED_TEST(Dense, SquareMatrixIsColPermutableIntoDense64) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsColPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; auto c_permute = Mtx::create(exec, this->mtx5->get_size()); this->mtx5->column_permute(&permute_idxs, c_permute); GKO_ASSERT_MTX_NEAR( - c_permute, l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), + c_permute, + l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), 0.0); } -TYPED_TEST(Dense, SquareSubmatrixIsColPermutableIntoDense64) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsColPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; + gko::array permute_idxs{exec, {1, 0}}; auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); this->mtx5->create_submatrix({0, 2}, {0, 2}) ->column_permute(&permute_idxs, c_permute); - GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), 0.0); + GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), + 0.0); ASSERT_EQ(c_permute->get_stride(), 4); } -TYPED_TEST(Dense, SquareMatrixColPermuteIntoDenseFailsForWrongPermutationSize64) +TYPED_TEST(DenseWithIndexType, + SquareMatrixColPermuteIntoDenseFailsForWrongPermutationSize) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; + gko::array permute_idxs{exec, {1, 2}}; auto row_permute = Mtx::create(exec, this->mtx5->get_size()); ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, row_permute), @@ -3207,88 +2233,96 @@ TYPED_TEST(Dense, SquareMatrixColPermuteIntoDenseFailsForWrongPermutationSize64) } -TYPED_TEST(Dense, SquareMatrixColPermuteIntoDenseFailsForWrongDimensions64) +TYPED_TEST(DenseWithIndexType, + SquareMatrixColPermuteIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, Mtx::create(exec)), gko::DimensionMismatch); } -TYPED_TEST(Dense, SquareMatrixIsInverseRowPermutable64) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseRowPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; + gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - auto inverse_row_permute = + auto inv_row_permute = gko::as(this->mtx5->inverse_row_permute(&inverse_permute_idxs)); GKO_ASSERT_MTX_NEAR( - inverse_row_permute, - l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), 0.0); + inv_row_permute, + l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), + 0.0); } -TYPED_TEST(Dense, NonSquareMatrixIsInverseRowPermutable64) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsInverseRowPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx4->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 0}}; + gko::array inverse_permute_idxs{exec, {1, 0}}; auto inverse_row_permute = gko::as(this->mtx4->inverse_row_permute(&inverse_permute_idxs)); GKO_ASSERT_MTX_NEAR(inverse_row_permute, - l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); + l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); } -TYPED_TEST(Dense, SquareMatrixIsInverseRowPermutableIntoDense64) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseRowPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; auto row_permute = Mtx::create(exec, this->mtx5->get_size()); this->mtx5->inverse_row_permute(&permute_idxs, row_permute); GKO_ASSERT_MTX_NEAR( row_permute, - l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), 0.0); + l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), + 0.0); } -TYPED_TEST(Dense, SquareSubmatrixIsInverseRowPermutableIntoDense64) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInverseRowPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; + gko::array permute_idxs{exec, {1, 0}}; auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); this->mtx5->create_submatrix({0, 2}, {0, 2}) ->inverse_row_permute(&permute_idxs, row_permute); - GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), 0.0); + GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), + 0.0); ASSERT_EQ(row_permute->get_stride(), 4); } -TYPED_TEST(Dense, - SquareMatrixInverseRowPermuteIntoDenseFailsForWrongPermutationSize64) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInverseRowPermuteIntoDenseFailsForWrongPermutationSize) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; + gko::array permute_idxs{exec, {1, 2}}; auto row_permute = Mtx::create(exec, this->mtx5->get_size()); ASSERT_THROW(this->mtx5->inverse_row_permute(&permute_idxs, row_permute), @@ -3296,13 +2330,13 @@ TYPED_TEST(Dense, } -TYPED_TEST(Dense, - SquareMatrixInverseRowPermuteIntoDenseFailsForWrongDimensions64) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInverseRowPermuteIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; ASSERT_THROW( this->mtx5->inverse_row_permute(&permute_idxs, Mtx::create(exec)), @@ -3310,76 +2344,83 @@ TYPED_TEST(Dense, } -TYPED_TEST(Dense, SquareMatrixIsInverseColPermutable64) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseColPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; + gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - auto inverse_c_permute = + auto inv_c_permute = gko::as(this->mtx5->inverse_column_permute(&inverse_permute_idxs)); GKO_ASSERT_MTX_NEAR( - inverse_c_permute, - l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), 0.0); + inv_c_permute, + l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), + 0.0); } -TYPED_TEST(Dense, NonSquareMatrixIsInverseColPermutable64) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsInverseColPermutable) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx4->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; + gko::array inverse_permute_idxs{exec, {1, 2, 0}}; auto inverse_c_permute = gko::as(this->mtx4->inverse_column_permute(&inverse_permute_idxs)); GKO_ASSERT_MTX_NEAR(inverse_c_permute, - l({{2.0, 1.0, 3.0}, {0.0, 0.0, 5.0}}), 0.0); + l({{2.0, 1.0, 3.0}, {0.0, 0.0, 5.0}}), 0.0); } -TYPED_TEST(Dense, SquareMatrixIsInverseColPermutableIntoDense64) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseColPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; auto c_permute = Mtx::create(exec, this->mtx5->get_size()); this->mtx5->inverse_column_permute(&permute_idxs, c_permute); GKO_ASSERT_MTX_NEAR( - c_permute, l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), + c_permute, + l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), 0.0); } -TYPED_TEST(Dense, SquareSubmatrixIsInverseColPermutableIntoDense64) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInverseColPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; + gko::array permute_idxs{exec, {1, 0}}; auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); this->mtx5->create_submatrix({0, 2}, {0, 2}) ->column_permute(&permute_idxs, c_permute); - GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), 0.0); + GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), + 0.0); ASSERT_EQ(c_permute->get_stride(), 4); } -TYPED_TEST(Dense, - SquareMatrixInverseColPermuteIntoDenseFailsForWrongPermutationSize64) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInverseColPermuteIntoDenseFailsForWrongPermutationSize) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; + gko::array permute_idxs{exec, {1, 2}}; auto row_permute = Mtx::create(exec, this->mtx5->get_size()); ASSERT_THROW(this->mtx5->inverse_column_permute(&permute_idxs, row_permute), @@ -3387,13 +2428,13 @@ TYPED_TEST(Dense, } -TYPED_TEST(Dense, - SquareMatrixInverseColPermuteIntoDenseFailsForWrongDimensions64) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInverseColPermuteIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 2, 0}}; ASSERT_THROW( this->mtx5->inverse_column_permute(&permute_idxs, Mtx::create(exec)), From 9a3aede9f92c3263452a5b145f913e964645d593 Mon Sep 17 00:00:00 2001 From: Tobias Ribizel Date: Mon, 16 Oct 2023 10:43:50 +0200 Subject: [PATCH 2/3] group tests by fixture --- reference/test/matrix/dense_kernels.cpp | 2582 +++++++++++------------ 1 file changed, 1291 insertions(+), 1291 deletions(-) diff --git a/reference/test/matrix/dense_kernels.cpp b/reference/test/matrix/dense_kernels.cpp index 3a4cfb6826b..56f082243e6 100644 --- a/reference/test/matrix/dense_kernels.cpp +++ b/reference/test/matrix/dense_kernels.cpp @@ -114,23 +114,6 @@ class Dense : public ::testing::Test { TYPED_TEST_SUITE(Dense, gko::test::ValueTypes, TypenameNameGenerator); -template -class DenseWithIndexType - : public Dense< - typename std::tuple_element<0, decltype(ValueIndexType())>::type> { -public: - using value_type = - typename std::tuple_element<0, decltype(ValueIndexType())>::type; - using index_type = - typename std::tuple_element<1, decltype(ValueIndexType())>::type; - - index_type invalid_index = gko::invalid_index(); -}; - -TYPED_TEST_SUITE(DenseWithIndexType, gko::test::ValueIndexTypes, - PairTypenameNameGenerator); - - TYPED_TEST(Dense, CopyRespectsStride) { using value_type = typename TestFixture::value_type; @@ -796,2086 +779,2103 @@ TYPED_TEST(Dense, MovesToPrecision) } -template -void assert_coo_eq_mtx4(const gko::matrix::Coo* coo_mtx) +TYPED_TEST(Dense, SquareMatrixIsTransposable) { - auto v = coo_mtx->get_const_values(); - auto c = coo_mtx->get_const_col_idxs(); - auto r = coo_mtx->get_const_row_idxs(); + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto trans = gko::as(this->mtx5->transpose()); - ASSERT_EQ(coo_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(coo_mtx->get_num_stored_elements(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{3.0}); - EXPECT_EQ(v[2], ValueType{2.0}); - EXPECT_EQ(v[3], ValueType{5.0}); + GKO_ASSERT_MTX_NEAR( + trans, l({{1.0, -2.0, 2.1}, {-1.0, 2.0, 3.4}, {-0.5, 4.5, 1.2}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, ConvertsToCoo) +TYPED_TEST(Dense, SquareMatrixIsTransposableIntoDense) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Coo = typename gko::matrix::Coo; - auto coo_mtx = Coo::create(this->mtx4->get_executor()); + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto trans = Mtx::create(this->exec, this->mtx5->get_size()); - this->mtx4->convert_to(coo_mtx); + this->mtx5->transpose(trans); - assert_coo_eq_mtx4(coo_mtx.get()); + GKO_ASSERT_MTX_NEAR( + trans, l({{1.0, -2.0, 2.1}, {-1.0, 2.0, 3.4}, {-0.5, 4.5, 1.2}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, MovesToCoo) +TYPED_TEST(Dense, SquareSubmatrixIsTransposableIntoDense) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Coo = typename gko::matrix::Coo; - auto coo_mtx = Coo::create(this->mtx4->get_executor()); + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto trans = Mtx::create(this->exec, gko::dim<2>{2, 2}, 4); - this->mtx4->move_to(coo_mtx); + this->mtx5->create_submatrix({0, 2}, {0, 2})->transpose(trans); - assert_coo_eq_mtx4(coo_mtx.get()); + GKO_ASSERT_MTX_NEAR(trans, l({{1.0, -2.0}, {-1.0, 2.0}}), 0.0); + ASSERT_EQ(trans->get_stride(), 4); } -template -void assert_csr_eq_mtx4(const gko::matrix::Csr* csr_mtx) +TYPED_TEST(Dense, SquareMatrixIsTransposableIntoDenseFailsForWrongDimensions) { - auto v = csr_mtx->get_const_values(); - auto c = csr_mtx->get_const_col_idxs(); - auto r = csr_mtx->get_const_row_ptrs(); - ASSERT_EQ(csr_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(csr_mtx->get_num_stored_elements(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 3); - EXPECT_EQ(r[2], 4); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{3.0}); - EXPECT_EQ(v[2], ValueType{2.0}); - EXPECT_EQ(v[3], ValueType{5.0}); + using Mtx = typename TestFixture::Mtx; + + ASSERT_THROW(this->mtx5->transpose(Mtx::create(this->exec)), + gko::DimensionMismatch); } -TYPED_TEST(DenseWithIndexType, ConvertsToCsr) +TYPED_TEST(Dense, NonSquareMatrixIsTransposable) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Csr = typename gko::matrix::Csr; - auto csr_s_classical = std::make_shared(); - auto csr_s_merge = std::make_shared(); - auto csr_mtx_c = Csr::create(this->mtx4->get_executor(), csr_s_classical); - auto csr_mtx_m = Csr::create(this->mtx4->get_executor(), csr_s_merge); - - this->mtx4->convert_to(csr_mtx_c); - this->mtx4->convert_to(csr_mtx_m); + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto trans = gko::as(this->mtx4->transpose()); - assert_csr_eq_mtx4(csr_mtx_c.get()); - ASSERT_EQ(csr_mtx_c->get_strategy()->get_name(), "classical"); - GKO_ASSERT_MTX_NEAR(csr_mtx_c, csr_mtx_m, 0.0); - ASSERT_EQ(csr_mtx_m->get_strategy()->get_name(), "merge_path"); + GKO_ASSERT_MTX_NEAR(trans, l({{1.0, 0.0}, {3.0, 5.0}, {2.0, 0.0}}), 0.0); } -TYPED_TEST(DenseWithIndexType, MovesToCsr) +TYPED_TEST(Dense, NonSquareMatrixIsTransposableIntoDense) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Csr = typename gko::matrix::Csr; - auto csr_s_classical = std::make_shared(); - auto csr_s_merge = std::make_shared(); - auto csr_mtx_c = Csr::create(this->mtx4->get_executor(), csr_s_classical); - auto csr_mtx_m = Csr::create(this->mtx4->get_executor(), csr_s_merge); - auto mtx_clone = this->mtx4->clone(); + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto trans = + Mtx::create(this->exec, gko::transpose(this->mtx4->get_size())); - this->mtx4->move_to(csr_mtx_c); - mtx_clone->move_to(csr_mtx_m); + this->mtx4->transpose(trans); - assert_csr_eq_mtx4(csr_mtx_c.get()); - ASSERT_EQ(csr_mtx_c->get_strategy()->get_name(), "classical"); - GKO_ASSERT_MTX_NEAR(csr_mtx_c, csr_mtx_m, 0.0); - ASSERT_EQ(csr_mtx_m->get_strategy()->get_name(), "merge_path"); + GKO_ASSERT_MTX_NEAR(trans, l({{1.0, 0.0}, {3.0, 5.0}, {2.0, 0.0}}), 0.0); } -template -void assert_sparsity_csr_eq_mtx4( - const gko::matrix::SparsityCsr* sparsity_csr_mtx) +TYPED_TEST(Dense, NonSquareSubmatrixIsTransposableIntoDense) { - auto v = sparsity_csr_mtx->get_const_value(); - auto c = sparsity_csr_mtx->get_const_col_idxs(); - auto r = sparsity_csr_mtx->get_const_row_ptrs(); + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto trans = Mtx::create(this->exec, gko::dim<2>{2, 1}, 5); - ASSERT_EQ(sparsity_csr_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sparsity_csr_mtx->get_num_nonzeros(), 4); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 3); - EXPECT_EQ(r[2], 4); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], ValueType{1.0}); + this->mtx4->create_submatrix({0, 1}, {0, 2})->transpose(trans); + + GKO_ASSERT_MTX_NEAR(trans, l({1.0, 3.0}), 0.0); + ASSERT_EQ(trans->get_stride(), 5); } -TYPED_TEST(DenseWithIndexType, ConvertsToSparsityCsr) +TYPED_TEST(Dense, NonSquareMatrixIsTransposableIntoDenseFailsForWrongDimensions) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using SparsityCsr = - typename gko::matrix::SparsityCsr; - auto sparsity_csr_mtx = SparsityCsr::create(this->mtx4->get_executor()); - - this->mtx4->convert_to(sparsity_csr_mtx); + using Mtx = typename TestFixture::Mtx; - assert_sparsity_csr_eq_mtx4(sparsity_csr_mtx.get()); + ASSERT_THROW(this->mtx4->transpose(Mtx::create(this->exec)), + gko::DimensionMismatch); } -TYPED_TEST(DenseWithIndexType, MovesToSparsityCsr) +TYPED_TEST(Dense, ExtractsDiagonalFromSquareMatrix) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using SparsityCsr = - typename gko::matrix::SparsityCsr; - auto sparsity_csr_mtx = SparsityCsr::create(this->mtx4->get_executor()); + using T = typename TestFixture::value_type; - this->mtx4->move_to(sparsity_csr_mtx); + auto diag = this->mtx5->extract_diagonal(); - assert_sparsity_csr_eq_mtx4(sparsity_csr_mtx.get()); + ASSERT_EQ(diag->get_size()[0], 3); + ASSERT_EQ(diag->get_size()[1], 3); + ASSERT_EQ(diag->get_values()[0], T{1.}); + ASSERT_EQ(diag->get_values()[1], T{2.}); + ASSERT_EQ(diag->get_values()[2], T{1.2}); } -template -void assert_ell_eq_mtx6(const gko::matrix::Ell* ell_mtx) +TYPED_TEST(Dense, ExtractsDiagonalFromTallSkinnyMatrix) { - auto v = ell_mtx->get_const_values(); - auto c = ell_mtx->get_const_col_idxs(); + using T = typename TestFixture::value_type; - ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); - ASSERT_EQ(ell_mtx->get_num_stored_elements(), 4); - ASSERT_EQ(ell_mtx->get_stride(), 2); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 1); - EXPECT_EQ(c[3], gko::invalid_index()); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{1.5}); - EXPECT_EQ(v[2], ValueType{2.0}); - EXPECT_EQ(v[3], ValueType{0.0}); + auto diag = this->mtx4->extract_diagonal(); + + ASSERT_EQ(diag->get_size()[0], 2); + ASSERT_EQ(diag->get_size()[1], 2); + ASSERT_EQ(diag->get_values()[0], T{1.}); + ASSERT_EQ(diag->get_values()[1], T{5.}); } -TYPED_TEST(DenseWithIndexType, ConvertsToEll) +TYPED_TEST(Dense, ExtractsDiagonalFromShortFatMatrix) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Ell = typename gko::matrix::Ell; - auto ell_mtx = Ell::create(this->mtx6->get_executor()); + using T = typename TestFixture::value_type; - this->mtx6->convert_to(ell_mtx); + auto diag = this->mtx8->extract_diagonal(); - assert_ell_eq_mtx6(ell_mtx.get()); + ASSERT_EQ(diag->get_size()[0], 2); + ASSERT_EQ(diag->get_size()[1], 2); + ASSERT_EQ(diag->get_values()[0], T{1.}); + ASSERT_EQ(diag->get_values()[1], T{2.}); } -TYPED_TEST(DenseWithIndexType, MovesToEll) +TYPED_TEST(Dense, ExtractsDiagonalFromSquareMatrixIntoDiagonal) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Ell = typename gko::matrix::Ell; - auto ell_mtx = Ell::create(this->mtx6->get_executor()); + using T = typename TestFixture::value_type; + auto diag = gko::matrix::Diagonal::create(this->exec, 3); - this->mtx6->move_to(ell_mtx); + this->mtx5->extract_diagonal(diag); - assert_ell_eq_mtx6(ell_mtx.get()); + ASSERT_EQ(diag->get_size()[0], 3); + ASSERT_EQ(diag->get_size()[1], 3); + ASSERT_EQ(diag->get_values()[0], T{1.}); + ASSERT_EQ(diag->get_values()[1], T{2.}); + ASSERT_EQ(diag->get_values()[2], T{1.2}); } -template -void assert_strided_ell_eq_mtx6( - const gko::matrix::Ell* ell_mtx) +TYPED_TEST(Dense, ExtractsDiagonalFromTallSkinnyMatrixIntoDiagonal) { - constexpr auto invalid_index = gko::invalid_index(); - auto v = ell_mtx->get_const_values(); - auto c = ell_mtx->get_const_col_idxs(); + using T = typename TestFixture::value_type; + auto diag = gko::matrix::Diagonal::create(this->exec, 2); - ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); - ASSERT_EQ(ell_mtx->get_num_stored_elements(), 6); - ASSERT_EQ(ell_mtx->get_stride(), 3); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], invalid_index); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(c[4], invalid_index); - EXPECT_EQ(c[5], invalid_index); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{1.5}); - EXPECT_EQ(v[2], ValueType{0.0}); - EXPECT_EQ(v[3], ValueType{2.0}); - EXPECT_EQ(v[4], ValueType{0.0}); - EXPECT_EQ(v[5], ValueType{0.0}); + this->mtx4->extract_diagonal(diag); + + ASSERT_EQ(diag->get_size()[0], 2); + ASSERT_EQ(diag->get_size()[1], 2); + ASSERT_EQ(diag->get_values()[0], T{1.}); + ASSERT_EQ(diag->get_values()[1], T{5.}); } -TYPED_TEST(DenseWithIndexType, ConvertsToEllWithStride) +TYPED_TEST(Dense, ExtractsDiagonalFromShortFatMatrixIntoDiagonal) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Ell = typename gko::matrix::Ell; - auto ell_mtx = - Ell::create(this->mtx6->get_executor(), gko::dim<2>{2, 3}, 2, 3); + using T = typename TestFixture::value_type; + auto diag = gko::matrix::Diagonal::create(this->exec, 2); - this->mtx6->convert_to(ell_mtx); + this->mtx8->extract_diagonal(diag); - assert_strided_ell_eq_mtx6(ell_mtx.get()); + ASSERT_EQ(diag->get_size()[0], 2); + ASSERT_EQ(diag->get_size()[1], 2); + ASSERT_EQ(diag->get_values()[0], T{1.}); + ASSERT_EQ(diag->get_values()[1], T{2.}); } -TYPED_TEST(DenseWithIndexType, MovesToEllWithStride) +TYPED_TEST(Dense, InplaceAbsolute) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Ell = typename gko::matrix::Ell; - auto ell_mtx = - Ell::create(this->mtx6->get_executor(), gko::dim<2>{2, 3}, 2, 3); + using T = typename TestFixture::value_type; - this->mtx6->move_to(ell_mtx); + this->mtx5->compute_absolute_inplace(); - assert_strided_ell_eq_mtx6(ell_mtx.get()); + GKO_ASSERT_MTX_NEAR( + this->mtx5, l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}), + 0.0); } -template -void assert_hybrid_auto_eq_mtx4( - const gko::matrix::Hybrid* hybrid_mtx) +TYPED_TEST(Dense, InplaceAbsoluteSubMatrix) { - auto v = hybrid_mtx->get_const_coo_values(); - auto c = hybrid_mtx->get_const_coo_col_idxs(); - auto r = hybrid_mtx->get_const_coo_row_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); + using T = typename TestFixture::value_type; + auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2}); - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); - EXPECT_EQ(n, 0); - EXPECT_EQ(p, 2); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{3.0}); - EXPECT_EQ(v[2], ValueType{2.0}); - EXPECT_EQ(v[3], ValueType{5.0}); + mtx->compute_absolute_inplace(); + + GKO_ASSERT_MTX_NEAR( + this->mtx5, l({{1.0, 1.0, -0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, MovesToHybridAutomatically) +TYPED_TEST(Dense, OutplaceAbsolute) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); + using T = typename TestFixture::value_type; - this->mtx4->move_to(hybrid_mtx); + auto abs_mtx = this->mtx5->compute_absolute(); - assert_hybrid_auto_eq_mtx4(hybrid_mtx.get()); + GKO_ASSERT_MTX_NEAR( + abs_mtx, l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, ConvertsToHybridAutomatically) +TYPED_TEST(Dense, OutplaceAbsoluteIntoDense) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto abs_mtx = + gko::remove_complex::create(this->exec, this->mtx5->get_size()); - this->mtx4->convert_to(hybrid_mtx); + this->mtx5->compute_absolute(abs_mtx); - assert_hybrid_auto_eq_mtx4(hybrid_mtx.get()); + GKO_ASSERT_MTX_NEAR( + abs_mtx, l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}), + 0.0); } -template -void assert_hybrid_strided_eq_mtx4( - const gko::matrix::Hybrid* hybrid_mtx) +TYPED_TEST(Dense, OutplaceAbsoluteSubMatrix) { - auto v = hybrid_mtx->get_const_coo_values(); - auto c = hybrid_mtx->get_const_coo_col_idxs(); - auto r = hybrid_mtx->get_const_coo_row_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); + using T = typename TestFixture::value_type; + auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2}); - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); - EXPECT_EQ(n, 0); - EXPECT_EQ(p, 3); - EXPECT_EQ(r[0], 0); - EXPECT_EQ(r[1], 0); - EXPECT_EQ(r[2], 0); - EXPECT_EQ(r[3], 1); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 2); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{3.0}); - EXPECT_EQ(v[2], ValueType{2.0}); - EXPECT_EQ(v[3], ValueType{5.0}); + auto abs_mtx = mtx->compute_absolute(); + + GKO_ASSERT_MTX_NEAR(abs_mtx, l({{1.0, 1.0}, {2.0, 2.0}}), 0); + GKO_ASSERT_EQ(abs_mtx->get_stride(), 2); } -TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideAutomatically) +TYPED_TEST(Dense, OutplaceSubmatrixAbsoluteIntoDense) +{ + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2}); + auto abs_mtx = + gko::remove_complex::create(this->exec, gko::dim<2>{2, 2}, 4); + + mtx->compute_absolute(abs_mtx); + + GKO_ASSERT_MTX_NEAR(abs_mtx, l({{1.0, 1.0}, {2.0, 2.0}}), 0); + GKO_ASSERT_EQ(abs_mtx->get_stride(), 4); +} + + +TYPED_TEST(Dense, AppliesToComplex) { using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = - Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 0, 3); + using complex_type = gko::to_complex; + using Vec = gko::matrix::Dense; + auto exec = gko::ReferenceExecutor::create(); + auto b = + gko::initialize({{complex_type{1.0, 0.0}, complex_type{2.0, 1.0}}, + {complex_type{2.0, 2.0}, complex_type{3.0, 3.0}}, + {complex_type{3.0, 4.0}, complex_type{4.0, 5.0}}}, + exec); + auto x = Vec::create(exec, gko::dim<2>{2, 2}); - this->mtx4->move_to(hybrid_mtx); + this->mtx1->apply(b, x); - assert_hybrid_strided_eq_mtx4(hybrid_mtx.get()); + GKO_ASSERT_MTX_NEAR( + x, + l({{complex_type{14.0, 16.0}, complex_type{20.0, 22.0}}, + {complex_type{17.0, 19.0}, complex_type{24.5, 26.5}}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideAutomatically) +TYPED_TEST(Dense, AppliesToMixedComplex) +{ + using mixed_value_type = + gko::next_precision; + using mixed_complex_type = gko::to_complex; + using Vec = gko::matrix::Dense; + auto exec = gko::ReferenceExecutor::create(); + auto b = gko::initialize( + {{mixed_complex_type{1.0, 0.0}, mixed_complex_type{2.0, 1.0}}, + {mixed_complex_type{2.0, 2.0}, mixed_complex_type{3.0, 3.0}}, + {mixed_complex_type{3.0, 4.0}, mixed_complex_type{4.0, 5.0}}}, + exec); + auto x = Vec::create(exec, gko::dim<2>{2, 2}); + + this->mtx1->apply(b, x); + + GKO_ASSERT_MTX_NEAR( + x, + l({{mixed_complex_type{14.0, 16.0}, mixed_complex_type{20.0, 22.0}}, + {mixed_complex_type{17.0, 19.0}, mixed_complex_type{24.5, 26.5}}}), + 0.0); +} + + +TYPED_TEST(Dense, AdvancedAppliesToComplex) { using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = - Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 0, 3); + using complex_type = gko::to_complex; + using Dense = gko::matrix::Dense; + using DenseComplex = gko::matrix::Dense; + auto exec = gko::ReferenceExecutor::create(); - this->mtx4->convert_to(hybrid_mtx); + auto b = gko::initialize( + {{complex_type{1.0, 0.0}, complex_type{2.0, 1.0}}, + {complex_type{2.0, 2.0}, complex_type{3.0, 3.0}}, + {complex_type{3.0, 4.0}, complex_type{4.0, 5.0}}}, + exec); + auto x = gko::initialize( + {{complex_type{1.0, 0.0}, complex_type{2.0, 1.0}}, + {complex_type{2.0, 2.0}, complex_type{3.0, 3.0}}}, + exec); + auto alpha = gko::initialize({-1.0}, this->exec); + auto beta = gko::initialize({2.0}, this->exec); - assert_hybrid_strided_eq_mtx4(hybrid_mtx.get()); + this->mtx1->apply(alpha, b, beta, x); + + GKO_ASSERT_MTX_NEAR( + x, + l({{complex_type{-12.0, -16.0}, complex_type{-16.0, -20.0}}, + {complex_type{-13.0, -15.0}, complex_type{-18.5, -20.5}}}), + 0.0); } -template -void assert_hybrid_limited_eq_mtx4( - const gko::matrix::Hybrid* hybrid_mtx) +TYPED_TEST(Dense, AdvancedAppliesToMixedComplex) { - constexpr auto invalid_index = gko::invalid_index(); - auto v = hybrid_mtx->get_const_ell_values(); - auto c = hybrid_mtx->get_const_ell_col_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); + using mixed_value_type = + gko::next_precision; + using mixed_complex_type = gko::to_complex; + using MixedDense = gko::matrix::Dense; + using MixedDenseComplex = gko::matrix::Dense; + auto exec = gko::ReferenceExecutor::create(); - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 6); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 1); - EXPECT_EQ(n, 2); - EXPECT_EQ(p, 3); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], invalid_index); - EXPECT_EQ(c[3], 1); - EXPECT_EQ(c[4], invalid_index); - EXPECT_EQ(c[5], invalid_index); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{5.0}); - EXPECT_EQ(v[2], ValueType{0.0}); - EXPECT_EQ(v[3], ValueType{3.0}); - EXPECT_EQ(v[4], ValueType{0.0}); - EXPECT_EQ(v[5], ValueType{0.0}); - EXPECT_EQ(hybrid_mtx->get_const_coo_values()[0], ValueType{2.0}); - EXPECT_EQ(hybrid_mtx->get_const_coo_row_idxs()[0], 0); - EXPECT_EQ(hybrid_mtx->get_const_coo_col_idxs()[0], 2); + auto b = gko::initialize( + {{mixed_complex_type{1.0, 0.0}, mixed_complex_type{2.0, 1.0}}, + {mixed_complex_type{2.0, 2.0}, mixed_complex_type{3.0, 3.0}}, + {mixed_complex_type{3.0, 4.0}, mixed_complex_type{4.0, 5.0}}}, + exec); + auto x = gko::initialize( + {{mixed_complex_type{1.0, 0.0}, mixed_complex_type{2.0, 1.0}}, + {mixed_complex_type{2.0, 2.0}, mixed_complex_type{3.0, 3.0}}}, + exec); + auto alpha = gko::initialize({-1.0}, this->exec); + auto beta = gko::initialize({2.0}, this->exec); + + this->mtx1->apply(alpha, b, beta, x); + + GKO_ASSERT_MTX_NEAR( + x, + l({{mixed_complex_type{-12.0, -16.0}, mixed_complex_type{-16.0, -20.0}}, + {mixed_complex_type{-13.0, -15.0}, + mixed_complex_type{-18.5, -20.5}}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideAndCooLengthByColumns2) +TYPED_TEST(Dense, MakeComplex) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = - Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 2, 3, 3, - std::make_shared(2)); + using T = typename TestFixture::value_type; - this->mtx4->move_to(hybrid_mtx); + auto complex_mtx = this->mtx5->make_complex(); - assert_hybrid_limited_eq_mtx4(hybrid_mtx.get()); + GKO_ASSERT_MTX_NEAR(complex_mtx, this->mtx5, 0.0); } -TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideAndCooLengthByColumns2) +TYPED_TEST(Dense, MakeComplexIntoDense) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = - Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 2, 3, 3, - std::make_shared(2)); + using T = typename TestFixture::value_type; + using ComplexMtx = typename TestFixture::ComplexMtx; + auto exec = this->mtx5->get_executor(); - this->mtx4->convert_to(hybrid_mtx); + auto complex_mtx = ComplexMtx::create(exec, this->mtx5->get_size()); + this->mtx5->make_complex(complex_mtx); - assert_hybrid_limited_eq_mtx4(hybrid_mtx.get()); + GKO_ASSERT_MTX_NEAR(complex_mtx, this->mtx5, 0.0); } -template -void assert_hybrid_percent_eq_mtx4( - const gko::matrix::Hybrid* hybrid_mtx) +TYPED_TEST(Dense, MakeComplexIntoDenseFailsForWrongDimensions) { - auto v = hybrid_mtx->get_const_ell_values(); - auto c = hybrid_mtx->get_const_ell_col_idxs(); - auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); - auto p = hybrid_mtx->get_ell_stride(); - auto coo_v = hybrid_mtx->get_const_coo_values(); - auto coo_c = hybrid_mtx->get_const_coo_col_idxs(); - auto coo_r = hybrid_mtx->get_const_coo_row_idxs(); + using T = typename TestFixture::value_type; + using ComplexMtx = typename TestFixture::ComplexMtx; + auto exec = this->mtx5->get_executor(); - ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 3); - EXPECT_EQ(n, 1); - EXPECT_EQ(p, 3); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], gko::invalid_index()); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{5.0}); - EXPECT_EQ(v[2], ValueType{0.0}); - ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 2); - EXPECT_EQ(coo_v[0], ValueType{3.0}); - EXPECT_EQ(coo_v[1], ValueType{2.0}); - EXPECT_EQ(coo_c[0], 1); - EXPECT_EQ(coo_c[1], 2); - EXPECT_EQ(coo_r[0], 0); - EXPECT_EQ(coo_r[1], 0); + auto complex_mtx = ComplexMtx::create(exec); + + ASSERT_THROW(this->mtx5->make_complex(complex_mtx), gko::DimensionMismatch); } -TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideByPercent40) +TYPED_TEST(Dense, GetReal) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = - Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 1, 3, - std::make_shared(0.4)); + using T = typename TestFixture::value_type; - this->mtx4->move_to(hybrid_mtx); + auto real_mtx = this->mtx5->get_real(); - assert_hybrid_percent_eq_mtx4(hybrid_mtx.get()); + GKO_ASSERT_MTX_NEAR(real_mtx, this->mtx5, 0.0); } -TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideByPercent40) +TYPED_TEST(Dense, GetRealIntoDense) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto hybrid_mtx = - Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 1, 3, - std::make_shared(0.4)); + using T = typename TestFixture::value_type; + using RealMtx = typename TestFixture::RealMtx; + auto exec = this->mtx5->get_executor(); - this->mtx4->convert_to(hybrid_mtx); + auto real_mtx = RealMtx::create(exec, this->mtx5->get_size()); + this->mtx5->get_real(real_mtx); - assert_hybrid_percent_eq_mtx4(hybrid_mtx.get()); + GKO_ASSERT_MTX_NEAR(real_mtx, this->mtx5, 0.0); } -template -void assert_sellp_eq_mtx7( - const gko::matrix::Sellp* sellp_mtx) +TYPED_TEST(Dense, GetRealIntoDenseFailsForWrongDimensions) { - constexpr auto invalid_index = gko::invalid_index(); - auto v = sellp_mtx->get_const_values(); - auto c = sellp_mtx->get_const_col_idxs(); - auto s = sellp_mtx->get_const_slice_sets(); - auto l = sellp_mtx->get_const_slice_lengths(); + using T = typename TestFixture::value_type; + using RealMtx = typename TestFixture::RealMtx; + auto exec = this->mtx5->get_executor(); - ASSERT_EQ(sellp_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sellp_mtx->get_total_cols(), 3); - ASSERT_EQ(sellp_mtx->get_num_stored_elements(), - 3 * gko::matrix::default_slice_size); - ASSERT_EQ(sellp_mtx->get_slice_size(), gko::matrix::default_slice_size); - ASSERT_EQ(sellp_mtx->get_stride_factor(), - gko::matrix::default_stride_factor); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size], 1); - EXPECT_EQ(c[gko::matrix::default_slice_size + 1], invalid_index); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size], 2); - EXPECT_EQ(c[2 * gko::matrix::default_slice_size + 1], invalid_index); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{1.5}); - EXPECT_EQ(v[gko::matrix::default_slice_size], ValueType{2.0}); - EXPECT_EQ(v[gko::matrix::default_slice_size + 1], ValueType{0.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size], ValueType{3.0}); - EXPECT_EQ(v[2 * gko::matrix::default_slice_size + 1], ValueType{0.0}); - EXPECT_EQ(s[0], 0); - EXPECT_EQ(s[1], 3); - EXPECT_EQ(l[0], 3); + auto real_mtx = RealMtx::create(exec); + ASSERT_THROW(this->mtx5->get_real(real_mtx), gko::DimensionMismatch); } -TYPED_TEST(DenseWithIndexType, ConvertsToSellp) +TYPED_TEST(Dense, GetImag) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Sellp = typename gko::matrix::Sellp; - auto sellp_mtx = Sellp::create(this->mtx7->get_executor()); + using T = typename TestFixture::value_type; - this->mtx7->convert_to(sellp_mtx); + auto imag_mtx = this->mtx5->get_imag(); - assert_sellp_eq_mtx7(sellp_mtx.get()); + GKO_ASSERT_MTX_NEAR( + imag_mtx, l({{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, MovesToSellp) +TYPED_TEST(Dense, GetImagIntoDense) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Sellp = typename gko::matrix::Sellp; - auto sellp_mtx = Sellp::create(this->mtx7->get_executor()); + using T = typename TestFixture::value_type; + using RealMtx = typename TestFixture::RealMtx; + auto exec = this->mtx5->get_executor(); - this->mtx7->move_to(sellp_mtx); + auto imag_mtx = RealMtx::create(exec, this->mtx5->get_size()); + this->mtx5->get_imag(imag_mtx); - assert_sellp_eq_mtx7(sellp_mtx.get()); + GKO_ASSERT_MTX_NEAR( + imag_mtx, l({{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}}), + 0.0); } -template -void assert_sellp_strided_eq_mtx7( - const gko::matrix::Sellp* sellp_mtx) +TYPED_TEST(Dense, GetImagIntoDenseFailsForWrongDimensions) { - constexpr auto invalid_index = gko::invalid_index(); - auto v = sellp_mtx->get_const_values(); - auto c = sellp_mtx->get_const_col_idxs(); - auto s = sellp_mtx->get_const_slice_sets(); - auto l = sellp_mtx->get_const_slice_lengths(); + using T = typename TestFixture::value_type; + using RealMtx = typename TestFixture::RealMtx; + auto exec = this->mtx5->get_executor(); - ASSERT_EQ(sellp_mtx->get_size(), gko::dim<2>(2, 3)); - ASSERT_EQ(sellp_mtx->get_total_cols(), 4); - ASSERT_EQ(sellp_mtx->get_num_stored_elements(), 8); - ASSERT_EQ(sellp_mtx->get_slice_size(), 2); - ASSERT_EQ(sellp_mtx->get_stride_factor(), 2); - EXPECT_EQ(c[0], 0); - EXPECT_EQ(c[1], 1); - EXPECT_EQ(c[2], 1); - EXPECT_EQ(c[3], invalid_index); - EXPECT_EQ(c[4], 2); - EXPECT_EQ(c[5], invalid_index); - EXPECT_EQ(c[6], invalid_index); - EXPECT_EQ(c[7], invalid_index); - EXPECT_EQ(v[0], ValueType{1.0}); - EXPECT_EQ(v[1], ValueType{1.5}); - EXPECT_EQ(v[2], ValueType{2.0}); - EXPECT_EQ(v[3], ValueType{0.0}); - EXPECT_EQ(v[4], ValueType{3.0}); - EXPECT_EQ(v[5], ValueType{0.0}); - EXPECT_EQ(v[6], ValueType{0.0}); - EXPECT_EQ(v[7], ValueType{0.0}); - EXPECT_EQ(s[0], 0); - EXPECT_EQ(s[1], 4); - EXPECT_EQ(l[0], 4); + auto imag_mtx = RealMtx::create(exec); + ASSERT_THROW(this->mtx5->get_imag(imag_mtx), gko::DimensionMismatch); } -TYPED_TEST(DenseWithIndexType, ConvertsToSellpWithSliceSizeAndStrideFactor) +TYPED_TEST(Dense, MakeTemporaryConversionDoesntConvertOnMatch) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Sellp = typename gko::matrix::Sellp; - auto sellp_mtx = - Sellp::create(this->mtx7->get_executor(), gko::dim<2>{}, 2, 2, 0); - - this->mtx7->convert_to(sellp_mtx); + using Mtx = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + auto alpha = gko::initialize({8.0}, this->exec); - assert_sellp_strided_eq_mtx7(sellp_mtx.get()); + ASSERT_EQ(gko::make_temporary_conversion(alpha).get(), alpha.get()); } -TYPED_TEST(DenseWithIndexType, MovesToSellpWithSliceSizeAndStrideFactor) +TYPED_TEST(Dense, MakeTemporaryConversionConvertsBack) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Sellp = typename gko::matrix::Sellp; - auto sellp_mtx = - Sellp::create(this->mtx7->get_executor(), gko::dim<2>{}, 2, 2, 0); + using MixedMtx = typename TestFixture::MixedMtx; + using T = typename TestFixture::value_type; + using MixedT = typename MixedMtx::value_type; + auto alpha = gko::initialize({8.0}, this->exec); - this->mtx7->move_to(sellp_mtx); + { + auto conversion = gko::make_temporary_conversion(alpha); + conversion->at(0, 0) = T{7.0}; + } - assert_sellp_strided_eq_mtx7(sellp_mtx.get()); + ASSERT_EQ(alpha->at(0, 0), MixedT{7.0}); } -TYPED_TEST(DenseWithIndexType, ConvertsToAndFromSellpWithMoreThanOneSlice) +TYPED_TEST(Dense, MakeTemporaryConversionConstDoesntConvertBack) { - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Mtx = typename TestFixture::Mtx; - using Sellp = typename gko::matrix::Sellp; - auto x = this->template gen_mtx(65, 25); + using MixedMtx = typename TestFixture::MixedMtx; + using T = typename TestFixture::value_type; + using MixedT = typename MixedMtx::value_type; + auto alpha = gko::initialize({8.0}, this->exec); - auto sellp_mtx = Sellp::create(this->exec); - auto dense_mtx = Mtx::create(this->exec); - x->convert_to(sellp_mtx); - sellp_mtx->convert_to(dense_mtx); + { + auto conversion = gko::make_temporary_conversion( + static_cast(alpha.get())); + alpha->at(0, 0) = MixedT{7.0}; + } - GKO_ASSERT_MTX_NEAR(dense_mtx, x, 0.0); + ASSERT_EQ(alpha->at(0, 0), MixedT{7.0}); } -TYPED_TEST(Dense, ConvertsEmptyToPrecision) +TYPED_TEST(Dense, ScaleAddIdentityRectangular) { - using Dense = typename TestFixture::Mtx; using T = typename TestFixture::value_type; - using OtherT = typename gko::next_precision; - using OtherDense = typename gko::matrix::Dense; - auto empty = OtherDense::create(this->exec); - auto res = Dense::create(this->exec); + using Vec = typename TestFixture::Mtx; + using MixedVec = typename TestFixture::MixedMtx; + auto alpha = gko::initialize({2.0}, this->exec); + auto beta = gko::initialize({-1.0}, this->exec); + auto b = gko::initialize( + {I{2.0, 0.0}, I{1.0, 2.5}, I{0.0, -4.0}}, this->exec); - empty->convert_to(res); + b->add_scaled_identity(alpha, beta); - ASSERT_FALSE(res->get_size()); + GKO_ASSERT_MTX_NEAR(b, l({{0.0, 0.0}, {-1.0, -0.5}, {0.0, 4.0}}), 0.0); } -TYPED_TEST(Dense, MovesEmptyToPrecision) -{ - using Dense = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - using OtherT = typename gko::next_precision; - using OtherDense = typename gko::matrix::Dense; - auto empty = OtherDense::create(this->exec); - auto res = Dense::create(this->exec); +template +class DenseWithIndexType + : public Dense< + typename std::tuple_element<0, decltype(ValueIndexType())>::type> { +public: + using value_type = + typename std::tuple_element<0, decltype(ValueIndexType())>::type; + using index_type = + typename std::tuple_element<1, decltype(ValueIndexType())>::type; - empty->move_to(res); + index_type invalid_index = gko::invalid_index(); +}; - ASSERT_FALSE(res->get_size()); -} +TYPED_TEST_SUITE(DenseWithIndexType, gko::test::ValueIndexTypes, + PairTypenameNameGenerator); -TYPED_TEST(DenseWithIndexType, ConvertsEmptyToCoo) +template +void assert_coo_eq_mtx4(const gko::matrix::Coo* coo_mtx) { - using Dense = typename TestFixture::Mtx; - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Coo = typename gko::matrix::Coo; - auto empty = Dense::create(this->exec); - auto res = Coo::create(this->exec); - - empty->convert_to(res); + auto v = coo_mtx->get_const_values(); + auto c = coo_mtx->get_const_col_idxs(); + auto r = coo_mtx->get_const_row_idxs(); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_FALSE(res->get_size()); + ASSERT_EQ(coo_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(coo_mtx->get_num_stored_elements(), 4); + EXPECT_EQ(r[0], 0); + EXPECT_EQ(r[1], 0); + EXPECT_EQ(r[2], 0); + EXPECT_EQ(r[3], 1); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], 2); + EXPECT_EQ(c[3], 1); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{3.0}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{5.0}); } -TYPED_TEST(DenseWithIndexType, MovesEmptyToCoo) +TYPED_TEST(DenseWithIndexType, ConvertsToCoo) { - using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; using Coo = typename gko::matrix::Coo; - auto empty = Dense::create(this->exec); - auto res = Coo::create(this->exec); + auto coo_mtx = Coo::create(this->mtx4->get_executor()); - empty->move_to(res); + this->mtx4->convert_to(coo_mtx); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_FALSE(res->get_size()); + assert_coo_eq_mtx4(coo_mtx.get()); } -TYPED_TEST(DenseWithIndexType, ConvertsEmptyMatrixToCsr) +TYPED_TEST(DenseWithIndexType, MovesToCoo) { - using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - using Csr = typename gko::matrix::Csr; - auto empty = Dense::create(this->exec); - auto res = Csr::create(this->exec); + using Coo = typename gko::matrix::Coo; + auto coo_mtx = Coo::create(this->mtx4->get_executor()); - empty->convert_to(res); + this->mtx4->move_to(coo_mtx); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_EQ(*res->get_const_row_ptrs(), 0); - ASSERT_FALSE(res->get_size()); + assert_coo_eq_mtx4(coo_mtx.get()); } -TYPED_TEST(DenseWithIndexType, MovesEmptyMatrixToCsr) +template +void assert_csr_eq_mtx4(const gko::matrix::Csr* csr_mtx) { - using Dense = typename TestFixture::Mtx; - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Csr = typename gko::matrix::Csr; - auto empty = Dense::create(this->exec); - auto res = Csr::create(this->exec); - - empty->move_to(res); - - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_EQ(*res->get_const_row_ptrs(), 0); - ASSERT_FALSE(res->get_size()); + auto v = csr_mtx->get_const_values(); + auto c = csr_mtx->get_const_col_idxs(); + auto r = csr_mtx->get_const_row_ptrs(); + ASSERT_EQ(csr_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(csr_mtx->get_num_stored_elements(), 4); + EXPECT_EQ(r[0], 0); + EXPECT_EQ(r[1], 3); + EXPECT_EQ(r[2], 4); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], 2); + EXPECT_EQ(c[3], 1); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{3.0}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{5.0}); } -TYPED_TEST(DenseWithIndexType, ConvertsEmptyToSparsityCsr) +TYPED_TEST(DenseWithIndexType, ConvertsToCsr) { - using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - using SparsityCsr = - typename gko::matrix::SparsityCsr; - auto empty = Dense::create(this->exec); - auto res = SparsityCsr::create(this->exec); + using Csr = typename gko::matrix::Csr; + auto csr_s_classical = std::make_shared(); + auto csr_s_merge = std::make_shared(); + auto csr_mtx_c = Csr::create(this->mtx4->get_executor(), csr_s_classical); + auto csr_mtx_m = Csr::create(this->mtx4->get_executor(), csr_s_merge); - empty->convert_to(res); + this->mtx4->convert_to(csr_mtx_c); + this->mtx4->convert_to(csr_mtx_m); - ASSERT_EQ(res->get_num_nonzeros(), 0); - ASSERT_EQ(*res->get_const_row_ptrs(), 0); - ASSERT_FALSE(res->get_size()); + assert_csr_eq_mtx4(csr_mtx_c.get()); + ASSERT_EQ(csr_mtx_c->get_strategy()->get_name(), "classical"); + GKO_ASSERT_MTX_NEAR(csr_mtx_c, csr_mtx_m, 0.0); + ASSERT_EQ(csr_mtx_m->get_strategy()->get_name(), "merge_path"); } -TYPED_TEST(DenseWithIndexType, MovesEmptyToSparsityCsr) +TYPED_TEST(DenseWithIndexType, MovesToCsr) { - using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - using SparsityCsr = - typename gko::matrix::SparsityCsr; - auto empty = Dense::create(this->exec); - auto res = SparsityCsr::create(this->exec); + using Csr = typename gko::matrix::Csr; + auto csr_s_classical = std::make_shared(); + auto csr_s_merge = std::make_shared(); + auto csr_mtx_c = Csr::create(this->mtx4->get_executor(), csr_s_classical); + auto csr_mtx_m = Csr::create(this->mtx4->get_executor(), csr_s_merge); + auto mtx_clone = this->mtx4->clone(); - empty->move_to(res); + this->mtx4->move_to(csr_mtx_c); + mtx_clone->move_to(csr_mtx_m); - ASSERT_EQ(res->get_num_nonzeros(), 0); - ASSERT_EQ(*res->get_const_row_ptrs(), 0); - ASSERT_FALSE(res->get_size()); + assert_csr_eq_mtx4(csr_mtx_c.get()); + ASSERT_EQ(csr_mtx_c->get_strategy()->get_name(), "classical"); + GKO_ASSERT_MTX_NEAR(csr_mtx_c, csr_mtx_m, 0.0); + ASSERT_EQ(csr_mtx_m->get_strategy()->get_name(), "merge_path"); } -TYPED_TEST(DenseWithIndexType, ConvertsEmptyToEll) +template +void assert_sparsity_csr_eq_mtx4( + const gko::matrix::SparsityCsr* sparsity_csr_mtx) { - using Dense = typename TestFixture::Mtx; - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Ell = typename gko::matrix::Ell; - auto empty = Dense::create(this->exec); - auto res = Ell::create(this->exec); - - empty->convert_to(res); + auto v = sparsity_csr_mtx->get_const_value(); + auto c = sparsity_csr_mtx->get_const_col_idxs(); + auto r = sparsity_csr_mtx->get_const_row_ptrs(); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_FALSE(res->get_size()); + ASSERT_EQ(sparsity_csr_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(sparsity_csr_mtx->get_num_nonzeros(), 4); + EXPECT_EQ(r[0], 0); + EXPECT_EQ(r[1], 3); + EXPECT_EQ(r[2], 4); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], 2); + EXPECT_EQ(c[3], 1); + EXPECT_EQ(v[0], ValueType{1.0}); } -TYPED_TEST(DenseWithIndexType, MovesEmptyToEll) +TYPED_TEST(DenseWithIndexType, ConvertsToSparsityCsr) { - using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - using Ell = typename gko::matrix::Ell; - auto empty = Dense::create(this->exec); - auto res = Ell::create(this->exec); + using SparsityCsr = + typename gko::matrix::SparsityCsr; + auto sparsity_csr_mtx = SparsityCsr::create(this->mtx4->get_executor()); - empty->move_to(res); + this->mtx4->convert_to(sparsity_csr_mtx); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_FALSE(res->get_size()); + assert_sparsity_csr_eq_mtx4(sparsity_csr_mtx.get()); } -TYPED_TEST(DenseWithIndexType, ConvertsEmptyToHybrid) +TYPED_TEST(DenseWithIndexType, MovesToSparsityCsr) { - using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto empty = Dense::create(this->exec); - auto res = Hybrid::create(this->exec); + using SparsityCsr = + typename gko::matrix::SparsityCsr; + auto sparsity_csr_mtx = SparsityCsr::create(this->mtx4->get_executor()); - empty->convert_to(res); + this->mtx4->move_to(sparsity_csr_mtx); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_FALSE(res->get_size()); + assert_sparsity_csr_eq_mtx4(sparsity_csr_mtx.get()); } -TYPED_TEST(DenseWithIndexType, MovesEmptyToHybrid) +template +void assert_ell_eq_mtx6(const gko::matrix::Ell* ell_mtx) { - using Dense = typename TestFixture::Mtx; - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - using Hybrid = typename gko::matrix::Hybrid; - auto empty = Dense::create(this->exec); - auto res = Hybrid::create(this->exec); - - empty->move_to(res); + auto v = ell_mtx->get_const_values(); + auto c = ell_mtx->get_const_col_idxs(); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_FALSE(res->get_size()); + ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); + ASSERT_EQ(ell_mtx->get_num_stored_elements(), 4); + ASSERT_EQ(ell_mtx->get_stride(), 2); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], 1); + EXPECT_EQ(c[3], gko::invalid_index()); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{1.5}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{0.0}); } -TYPED_TEST(DenseWithIndexType, ConvertsEmptyToSellp) +TYPED_TEST(DenseWithIndexType, ConvertsToEll) { - using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - using Sellp = typename gko::matrix::Sellp; - auto empty = Dense::create(this->exec); - auto res = Sellp::create(this->exec); + using Ell = typename gko::matrix::Ell; + auto ell_mtx = Ell::create(this->mtx6->get_executor()); - empty->convert_to(res); + this->mtx6->convert_to(ell_mtx); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_EQ(*res->get_const_slice_sets(), 0); - ASSERT_FALSE(res->get_size()); + assert_ell_eq_mtx6(ell_mtx.get()); } -TYPED_TEST(DenseWithIndexType, MovesEmptyToSellp) +TYPED_TEST(DenseWithIndexType, MovesToEll) { - using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - using Sellp = typename gko::matrix::Sellp; - auto empty = Dense::create(this->exec); - auto res = Sellp::create(this->exec); + using Ell = typename gko::matrix::Ell; + auto ell_mtx = Ell::create(this->mtx6->get_executor()); - empty->move_to(res); + this->mtx6->move_to(ell_mtx); - ASSERT_EQ(res->get_num_stored_elements(), 0); - ASSERT_EQ(*res->get_const_slice_sets(), 0); - ASSERT_FALSE(res->get_size()); + assert_ell_eq_mtx6(ell_mtx.get()); } -TYPED_TEST(Dense, SquareMatrixIsTransposable) +template +void assert_strided_ell_eq_mtx6( + const gko::matrix::Ell* ell_mtx) { - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto trans = gko::as(this->mtx5->transpose()); + constexpr auto invalid_index = gko::invalid_index(); + auto v = ell_mtx->get_const_values(); + auto c = ell_mtx->get_const_col_idxs(); - GKO_ASSERT_MTX_NEAR( - trans, l({{1.0, -2.0, 2.1}, {-1.0, 2.0, 3.4}, {-0.5, 4.5, 1.2}}), - 0.0); + ASSERT_EQ(ell_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(ell_mtx->get_num_stored_elements_per_row(), 2); + ASSERT_EQ(ell_mtx->get_num_stored_elements(), 6); + ASSERT_EQ(ell_mtx->get_stride(), 3); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], invalid_index); + EXPECT_EQ(c[3], 1); + EXPECT_EQ(c[4], invalid_index); + EXPECT_EQ(c[5], invalid_index); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{1.5}); + EXPECT_EQ(v[2], ValueType{0.0}); + EXPECT_EQ(v[3], ValueType{2.0}); + EXPECT_EQ(v[4], ValueType{0.0}); + EXPECT_EQ(v[5], ValueType{0.0}); } -TYPED_TEST(Dense, SquareMatrixIsTransposableIntoDense) +TYPED_TEST(DenseWithIndexType, ConvertsToEllWithStride) { - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto trans = Mtx::create(this->exec, this->mtx5->get_size()); + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Ell = typename gko::matrix::Ell; + auto ell_mtx = + Ell::create(this->mtx6->get_executor(), gko::dim<2>{2, 3}, 2, 3); - this->mtx5->transpose(trans); + this->mtx6->convert_to(ell_mtx); - GKO_ASSERT_MTX_NEAR( - trans, l({{1.0, -2.0, 2.1}, {-1.0, 2.0, 3.4}, {-0.5, 4.5, 1.2}}), - 0.0); + assert_strided_ell_eq_mtx6(ell_mtx.get()); } -TYPED_TEST(Dense, SquareSubmatrixIsTransposableIntoDense) +TYPED_TEST(DenseWithIndexType, MovesToEllWithStride) { - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto trans = Mtx::create(this->exec, gko::dim<2>{2, 2}, 4); + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Ell = typename gko::matrix::Ell; + auto ell_mtx = + Ell::create(this->mtx6->get_executor(), gko::dim<2>{2, 3}, 2, 3); - this->mtx5->create_submatrix({0, 2}, {0, 2})->transpose(trans); + this->mtx6->move_to(ell_mtx); - GKO_ASSERT_MTX_NEAR(trans, l({{1.0, -2.0}, {-1.0, 2.0}}), 0.0); - ASSERT_EQ(trans->get_stride(), 4); + assert_strided_ell_eq_mtx6(ell_mtx.get()); } -TYPED_TEST(Dense, SquareMatrixIsTransposableIntoDenseFailsForWrongDimensions) +template +void assert_hybrid_auto_eq_mtx4( + const gko::matrix::Hybrid* hybrid_mtx) { - using Mtx = typename TestFixture::Mtx; + auto v = hybrid_mtx->get_const_coo_values(); + auto c = hybrid_mtx->get_const_coo_col_idxs(); + auto r = hybrid_mtx->get_const_coo_row_idxs(); + auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); + auto p = hybrid_mtx->get_ell_stride(); - ASSERT_THROW(this->mtx5->transpose(Mtx::create(this->exec)), - gko::DimensionMismatch); + ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); + ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); + EXPECT_EQ(n, 0); + EXPECT_EQ(p, 2); + EXPECT_EQ(r[0], 0); + EXPECT_EQ(r[1], 0); + EXPECT_EQ(r[2], 0); + EXPECT_EQ(r[3], 1); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], 2); + EXPECT_EQ(c[3], 1); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{3.0}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{5.0}); } -TYPED_TEST(Dense, NonSquareMatrixIsTransposable) +TYPED_TEST(DenseWithIndexType, MovesToHybridAutomatically) { - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto trans = gko::as(this->mtx4->transpose()); + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); - GKO_ASSERT_MTX_NEAR(trans, l({{1.0, 0.0}, {3.0, 5.0}, {2.0, 0.0}}), 0.0); + this->mtx4->move_to(hybrid_mtx); + + assert_hybrid_auto_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(Dense, NonSquareMatrixIsTransposableIntoDense) +TYPED_TEST(DenseWithIndexType, ConvertsToHybridAutomatically) { - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto trans = - Mtx::create(this->exec, gko::transpose(this->mtx4->get_size())); + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = Hybrid::create(this->mtx4->get_executor()); - this->mtx4->transpose(trans); + this->mtx4->convert_to(hybrid_mtx); - GKO_ASSERT_MTX_NEAR(trans, l({{1.0, 0.0}, {3.0, 5.0}, {2.0, 0.0}}), 0.0); + assert_hybrid_auto_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(Dense, NonSquareSubmatrixIsTransposableIntoDense) +template +void assert_hybrid_strided_eq_mtx4( + const gko::matrix::Hybrid* hybrid_mtx) { - using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto trans = Mtx::create(this->exec, gko::dim<2>{2, 1}, 5); - - this->mtx4->create_submatrix({0, 1}, {0, 2})->transpose(trans); + auto v = hybrid_mtx->get_const_coo_values(); + auto c = hybrid_mtx->get_const_coo_col_idxs(); + auto r = hybrid_mtx->get_const_coo_row_idxs(); + auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); + auto p = hybrid_mtx->get_ell_stride(); - GKO_ASSERT_MTX_NEAR(trans, l({1.0, 3.0}), 0.0); - ASSERT_EQ(trans->get_stride(), 5); + ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 0); + ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 4); + EXPECT_EQ(n, 0); + EXPECT_EQ(p, 3); + EXPECT_EQ(r[0], 0); + EXPECT_EQ(r[1], 0); + EXPECT_EQ(r[2], 0); + EXPECT_EQ(r[3], 1); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], 2); + EXPECT_EQ(c[3], 1); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{3.0}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{5.0}); } -TYPED_TEST(Dense, NonSquareMatrixIsTransposableIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideAutomatically) { - using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = + Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 0, 3); - ASSERT_THROW(this->mtx4->transpose(Mtx::create(this->exec)), - gko::DimensionMismatch); + this->mtx4->move_to(hybrid_mtx); + + assert_hybrid_strided_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(DenseWithIndexType, SquareMatrixCanGatherRows) +TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideAutomatically) { - using Mtx = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = + Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 0, 3); - auto row_collection = this->mtx5->row_gather(&permute_idxs); + this->mtx4->convert_to(hybrid_mtx); - GKO_ASSERT_MTX_NEAR(row_collection, - l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), - 0.0); + assert_hybrid_strided_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(DenseWithIndexType, SquareMatrixCanGatherRowsIntoDense) +template +void assert_hybrid_limited_eq_mtx4( + const gko::matrix::Hybrid* hybrid_mtx) +{ + constexpr auto invalid_index = gko::invalid_index(); + auto v = hybrid_mtx->get_const_ell_values(); + auto c = hybrid_mtx->get_const_ell_col_idxs(); + auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); + auto p = hybrid_mtx->get_ell_stride(); + + ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 6); + ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 1); + EXPECT_EQ(n, 2); + EXPECT_EQ(p, 3); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], invalid_index); + EXPECT_EQ(c[3], 1); + EXPECT_EQ(c[4], invalid_index); + EXPECT_EQ(c[5], invalid_index); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{5.0}); + EXPECT_EQ(v[2], ValueType{0.0}); + EXPECT_EQ(v[3], ValueType{3.0}); + EXPECT_EQ(v[4], ValueType{0.0}); + EXPECT_EQ(v[5], ValueType{0.0}); + EXPECT_EQ(hybrid_mtx->get_const_coo_values()[0], ValueType{2.0}); + EXPECT_EQ(hybrid_mtx->get_const_coo_row_idxs()[0], 0); + EXPECT_EQ(hybrid_mtx->get_const_coo_col_idxs()[0], 2); +} + + +TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideAndCooLengthByColumns2) { - using Mtx = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_collection = Mtx::create(exec, gko::dim<2>{2, 3}); + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = + Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 2, 3, 3, + std::make_shared(2)); - this->mtx5->row_gather(&permute_idxs, row_collection); + this->mtx4->move_to(hybrid_mtx); - GKO_ASSERT_MTX_NEAR(row_collection, - l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), - 0.0); + assert_hybrid_limited_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(DenseWithIndexType, SquareSubmatrixCanGatherRowsIntoDense) +TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideAndCooLengthByColumns2) { - using Mtx = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_collection = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = + Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 2, 3, 3, + std::make_shared(2)); - this->mtx5->create_submatrix({0, 2}, {1, 3}) - ->row_gather(&permute_idxs, row_collection); + this->mtx4->convert_to(hybrid_mtx); - GKO_ASSERT_MTX_NEAR(row_collection, - l({{2.0, 4.5}, {-1.0, -0.5}}), 0.0); - ASSERT_EQ(row_collection->get_stride(), 4); + assert_hybrid_limited_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(DenseWithIndexType, NonSquareSubmatrixCanGatherRowsIntoMixedDense) +template +void assert_hybrid_percent_eq_mtx4( + const gko::matrix::Hybrid* hybrid_mtx) { - using Mtx = typename TestFixture::Mtx; - using MixedMtx = typename TestFixture::MixedMtx; - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - auto exec = this->mtx4->get_executor(); - gko::array gather_index{exec, {1, 0, 1}}; - auto row_collection = MixedMtx::create(exec, gko::dim<2>{3, 3}, 4); - - this->mtx4->row_gather(&gather_index, row_collection); + auto v = hybrid_mtx->get_const_ell_values(); + auto c = hybrid_mtx->get_const_ell_col_idxs(); + auto n = hybrid_mtx->get_ell_num_stored_elements_per_row(); + auto p = hybrid_mtx->get_ell_stride(); + auto coo_v = hybrid_mtx->get_const_coo_values(); + auto coo_c = hybrid_mtx->get_const_coo_col_idxs(); + auto coo_r = hybrid_mtx->get_const_coo_row_idxs(); - GKO_ASSERT_MTX_NEAR( - row_collection, - l( - {{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}, {0.0, 5.0, 0.0}}), - 0.0); + ASSERT_EQ(hybrid_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(hybrid_mtx->get_ell_num_stored_elements(), 3); + EXPECT_EQ(n, 1); + EXPECT_EQ(p, 3); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], gko::invalid_index()); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{5.0}); + EXPECT_EQ(v[2], ValueType{0.0}); + ASSERT_EQ(hybrid_mtx->get_coo_num_stored_elements(), 2); + EXPECT_EQ(coo_v[0], ValueType{3.0}); + EXPECT_EQ(coo_v[1], ValueType{2.0}); + EXPECT_EQ(coo_c[0], 1); + EXPECT_EQ(coo_c[1], 2); + EXPECT_EQ(coo_r[0], 0); + EXPECT_EQ(coo_r[1], 0); } -TYPED_TEST(DenseWithIndexType, - NonSquareSubmatrixCanAdvancedGatherRowsIntoMixedDense) +TYPED_TEST(DenseWithIndexType, MovesToHybridWithStrideByPercent40) { - using Mtx = typename TestFixture::Mtx; - using MixedMtx = typename TestFixture::MixedMtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx4->get_executor(); - gko::array gather_index{exec, {1, 0, 1}}; - auto row_collection = gko::initialize( - {{1.0, 0.5, -1.0}, {-1.5, 0.5, 1.0}, {2.0, -3.0, 1.0}}, exec); - auto alpha = gko::initialize({1.0}, exec); - auto beta = gko::initialize({2.0}, exec); + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = + Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 1, 3, + std::make_shared(0.4)); - this->mtx4->row_gather(alpha, &gather_index, beta, row_collection); + this->mtx4->move_to(hybrid_mtx); - GKO_ASSERT_MTX_NEAR( - row_collection, - l( - {{2.0, 6.0, -2.0}, {-2.0, 4.0, 4.0}, {4.0, -1.0, 2.0}}), - 0.0); + assert_hybrid_percent_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixGatherRowsIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, ConvertsToHybridWithStrideByPercent40) { - using Mtx = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; + using Hybrid = typename gko::matrix::Hybrid; + auto hybrid_mtx = + Hybrid::create(this->mtx4->get_executor(), gko::dim<2>{2, 3}, 1, 3, + std::make_shared(0.4)); - ASSERT_THROW(this->mtx5->row_gather(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); + this->mtx4->convert_to(hybrid_mtx); + + assert_hybrid_percent_eq_mtx4(hybrid_mtx.get()); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsPermutable) +template +void assert_sellp_eq_mtx7( + const gko::matrix::Sellp* sellp_mtx) { - using Mtx = typename TestFixture::Mtx; - using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - - auto ref_permuted = - gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - auto permuted = gko::as(this->mtx5->permute(&permute_idxs)); + constexpr auto invalid_index = gko::invalid_index(); + auto v = sellp_mtx->get_const_values(); + auto c = sellp_mtx->get_const_col_idxs(); + auto s = sellp_mtx->get_const_slice_sets(); + auto l = sellp_mtx->get_const_slice_lengths(); - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); + ASSERT_EQ(sellp_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(sellp_mtx->get_total_cols(), 3); + ASSERT_EQ(sellp_mtx->get_num_stored_elements(), + 3 * gko::matrix::default_slice_size); + ASSERT_EQ(sellp_mtx->get_slice_size(), gko::matrix::default_slice_size); + ASSERT_EQ(sellp_mtx->get_stride_factor(), + gko::matrix::default_stride_factor); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[gko::matrix::default_slice_size], 1); + EXPECT_EQ(c[gko::matrix::default_slice_size + 1], invalid_index); + EXPECT_EQ(c[2 * gko::matrix::default_slice_size], 2); + EXPECT_EQ(c[2 * gko::matrix::default_slice_size + 1], invalid_index); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{1.5}); + EXPECT_EQ(v[gko::matrix::default_slice_size], ValueType{2.0}); + EXPECT_EQ(v[gko::matrix::default_slice_size + 1], ValueType{0.0}); + EXPECT_EQ(v[2 * gko::matrix::default_slice_size], ValueType{3.0}); + EXPECT_EQ(v[2 * gko::matrix::default_slice_size + 1], ValueType{0.0}); + EXPECT_EQ(s[0], 0); + EXPECT_EQ(s[1], 3); + EXPECT_EQ(l[0], 3); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, ConvertsToSellp) { - using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto permuted = Mtx::create(exec, this->mtx5->get_size()); + using Sellp = typename gko::matrix::Sellp; + auto sellp_mtx = Sellp::create(this->mtx7->get_executor()); - auto ref_permuted = - gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - this->mtx5->permute(&permute_idxs, permuted); + this->mtx7->convert_to(sellp_mtx); - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); + assert_sellp_eq_mtx7(sellp_mtx.get()); } -TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, MovesToSellp) { - using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); + using Sellp = typename gko::matrix::Sellp; + auto sellp_mtx = Sellp::create(this->mtx7->get_executor()); - auto ref_permuted = - gko::as(gko::as(mtx->row_permute(&permute_idxs)) - ->column_permute(&permute_idxs)); - mtx->permute(&permute_idxs, permuted); + this->mtx7->move_to(sellp_mtx); - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); - ASSERT_EQ(permuted->get_stride(), 4); + assert_sellp_eq_mtx7(sellp_mtx.get()); } -TYPED_TEST(DenseWithIndexType, NonSquareMatrixPermuteIntoDenseFails) +template +void assert_sellp_strided_eq_mtx7( + const gko::matrix::Sellp* sellp_mtx) { - using Mtx = typename TestFixture::Mtx; - using index_type = typename TestFixture::index_type; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + constexpr auto invalid_index = gko::invalid_index(); + auto v = sellp_mtx->get_const_values(); + auto c = sellp_mtx->get_const_col_idxs(); + auto s = sellp_mtx->get_const_slice_sets(); + auto l = sellp_mtx->get_const_slice_lengths(); - ASSERT_THROW(this->mtx4->permute(&permute_idxs, this->mtx4->clone()), - gko::DimensionMismatch); + ASSERT_EQ(sellp_mtx->get_size(), gko::dim<2>(2, 3)); + ASSERT_EQ(sellp_mtx->get_total_cols(), 4); + ASSERT_EQ(sellp_mtx->get_num_stored_elements(), 8); + ASSERT_EQ(sellp_mtx->get_slice_size(), 2); + ASSERT_EQ(sellp_mtx->get_stride_factor(), 2); + EXPECT_EQ(c[0], 0); + EXPECT_EQ(c[1], 1); + EXPECT_EQ(c[2], 1); + EXPECT_EQ(c[3], invalid_index); + EXPECT_EQ(c[4], 2); + EXPECT_EQ(c[5], invalid_index); + EXPECT_EQ(c[6], invalid_index); + EXPECT_EQ(c[7], invalid_index); + EXPECT_EQ(v[0], ValueType{1.0}); + EXPECT_EQ(v[1], ValueType{1.5}); + EXPECT_EQ(v[2], ValueType{2.0}); + EXPECT_EQ(v[3], ValueType{0.0}); + EXPECT_EQ(v[4], ValueType{3.0}); + EXPECT_EQ(v[5], ValueType{0.0}); + EXPECT_EQ(v[6], ValueType{0.0}); + EXPECT_EQ(v[7], ValueType{0.0}); + EXPECT_EQ(s[0], 0); + EXPECT_EQ(s[1], 4); + EXPECT_EQ(l[0], 4); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixPermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(DenseWithIndexType, ConvertsToSellpWithSliceSizeAndStrideFactor) { - using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; + using Sellp = typename gko::matrix::Sellp; + auto sellp_mtx = + Sellp::create(this->mtx7->get_executor(), gko::dim<2>{}, 2, 2, 0); - ASSERT_THROW(this->mtx5->permute(&permute_idxs, this->mtx5->clone()), - gko::ValueMismatch); + this->mtx7->convert_to(sellp_mtx); + + assert_sellp_strided_eq_mtx7(sellp_mtx.get()); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixPermuteIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, MovesToSellpWithSliceSizeAndStrideFactor) { - using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using Sellp = typename gko::matrix::Sellp; + auto sellp_mtx = + Sellp::create(this->mtx7->get_executor(), gko::dim<2>{}, 2, 2, 0); - ASSERT_THROW(this->mtx5->permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); + this->mtx7->move_to(sellp_mtx); + + assert_sellp_strided_eq_mtx7(sellp_mtx.get()); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsInversePermutable) +TYPED_TEST(DenseWithIndexType, ConvertsToAndFromSellpWithMoreThanOneSlice) { - using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using Mtx = typename TestFixture::Mtx; + using Sellp = typename gko::matrix::Sellp; + auto x = this->template gen_mtx(65, 25); - auto ref_permuted = gko::as( - gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - auto permuted = gko::as(this->mtx5->inverse_permute(&permute_idxs)); + auto sellp_mtx = Sellp::create(this->exec); + auto dense_mtx = Mtx::create(this->exec); + x->convert_to(sellp_mtx); + sellp_mtx->convert_to(dense_mtx); - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); + GKO_ASSERT_MTX_NEAR(dense_mtx, x, 0.0); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsInversePermutableIntoDense) +TYPED_TEST(Dense, ConvertsEmptyToPrecision) { - using Mtx = typename TestFixture::Mtx; - using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto permuted = Mtx::create(exec, this->mtx5->get_size()); + using Dense = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + using OtherT = typename gko::next_precision; + using OtherDense = typename gko::matrix::Dense; + auto empty = OtherDense::create(this->exec); + auto res = Dense::create(this->exec); - auto ref_permuted = gko::as( - gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - this->mtx5->inverse_permute(&permute_idxs, permuted); + empty->convert_to(res); - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInversePermutableIntoDense) +TYPED_TEST(Dense, MovesEmptyToPrecision) { - using Mtx = typename TestFixture::Mtx; - using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); + using Dense = typename TestFixture::Mtx; + using T = typename TestFixture::value_type; + using OtherT = typename gko::next_precision; + using OtherDense = typename gko::matrix::Dense; + auto empty = OtherDense::create(this->exec); + auto res = Dense::create(this->exec); - auto ref_permuted = - gko::as(gko::as(mtx->inverse_row_permute(&permute_idxs)) - ->inverse_column_permute(&permute_idxs)); - mtx->inverse_permute(&permute_idxs, permuted); + empty->move_to(res); - GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); - ASSERT_EQ(permuted->get_stride(), 4); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, NonSquareMatrixInversePermuteIntoDenseFails) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToCoo) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using Coo = typename gko::matrix::Coo; + auto empty = Dense::create(this->exec); + auto res = Coo::create(this->exec); - ASSERT_THROW( - this->mtx4->inverse_permute(&permute_idxs, this->mtx4->clone()), - gko::DimensionMismatch); + empty->convert_to(res); + + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixInversePermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(DenseWithIndexType, MovesEmptyToCoo) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {0, 1}}; + using Coo = typename gko::matrix::Coo; + auto empty = Dense::create(this->exec); + auto res = Coo::create(this->exec); - ASSERT_THROW( - this->mtx5->inverse_permute(&permute_idxs, this->mtx5->clone()), - gko::ValueMismatch); + empty->move_to(res); + + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixInversePermuteIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyMatrixToCsr) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using Csr = typename gko::matrix::Csr; + auto empty = Dense::create(this->exec); + auto res = Csr::create(this->exec); - ASSERT_THROW(this->mtx5->inverse_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); + empty->convert_to(res); + + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_EQ(*res->get_const_row_ptrs(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsRowPermutable) +TYPED_TEST(DenseWithIndexType, MovesEmptyMatrixToCsr) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using Csr = typename gko::matrix::Csr; + auto empty = Dense::create(this->exec); + auto res = Csr::create(this->exec); - auto row_permute = gko::as(this->mtx5->row_permute(&permute_idxs)); + empty->move_to(res); - GKO_ASSERT_MTX_NEAR( - row_permute, - l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), - 0.0); + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_EQ(*res->get_const_row_ptrs(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsRowPermutable) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToSparsityCsr) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; + using SparsityCsr = + typename gko::matrix::SparsityCsr; + auto empty = Dense::create(this->exec); + auto res = SparsityCsr::create(this->exec); - auto row_permute = gko::as(this->mtx4->row_permute(&permute_idxs)); + empty->convert_to(res); - GKO_ASSERT_MTX_NEAR(row_permute, - l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); + ASSERT_EQ(res->get_num_nonzeros(), 0); + ASSERT_EQ(*res->get_const_row_ptrs(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsRowPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, MovesEmptyToSparsityCsr) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + using SparsityCsr = + typename gko::matrix::SparsityCsr; + auto empty = Dense::create(this->exec); + auto res = SparsityCsr::create(this->exec); - this->mtx5->row_permute(&permute_idxs, row_permute); + empty->move_to(res); - GKO_ASSERT_MTX_NEAR( - row_permute, - l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), - 0.0); + ASSERT_EQ(res->get_num_nonzeros(), 0); + ASSERT_EQ(*res->get_const_row_ptrs(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsRowPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToEll) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + using Ell = typename gko::matrix::Ell; + auto empty = Dense::create(this->exec); + auto res = Ell::create(this->exec); - this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->row_permute(&permute_idxs, row_permute); + empty->convert_to(res); - GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), - 0.0); - ASSERT_EQ(row_permute->get_stride(), 4); + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixRowPermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(DenseWithIndexType, MovesEmptyToEll) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + using Ell = typename gko::matrix::Ell; + auto empty = Dense::create(this->exec); + auto res = Ell::create(this->exec); - ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, row_permute), - gko::ValueMismatch); + empty->move_to(res); + + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixRowPermuteIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToHybrid) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using Hybrid = typename gko::matrix::Hybrid; + auto empty = Dense::create(this->exec); + auto res = Hybrid::create(this->exec); - ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); + empty->convert_to(res); + + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsColPermutable) +TYPED_TEST(DenseWithIndexType, MovesEmptyToHybrid) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using Hybrid = typename gko::matrix::Hybrid; + auto empty = Dense::create(this->exec); + auto res = Hybrid::create(this->exec); - auto c_permute = gko::as(this->mtx5->column_permute(&permute_idxs)); + empty->move_to(res); - GKO_ASSERT_MTX_NEAR( - c_permute, - l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), - 0.0); + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsColPermutable) +TYPED_TEST(DenseWithIndexType, ConvertsEmptyToSellp) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx4->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + using Sellp = typename gko::matrix::Sellp; + auto empty = Dense::create(this->exec); + auto res = Sellp::create(this->exec); - auto c_permute = gko::as(this->mtx4->column_permute(&permute_idxs)); + empty->convert_to(res); - GKO_ASSERT_MTX_NEAR(c_permute, - l({{3.0, 2.0, 1.0}, {5.0, 0.0, 0.0}}), 0.0); + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_EQ(*res->get_const_slice_sets(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsColPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, MovesEmptyToSellp) { - using Mtx = typename TestFixture::Mtx; + using Dense = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto c_permute = Mtx::create(exec, this->mtx5->get_size()); + using Sellp = typename gko::matrix::Sellp; + auto empty = Dense::create(this->exec); + auto res = Sellp::create(this->exec); - this->mtx5->column_permute(&permute_idxs, c_permute); + empty->move_to(res); - GKO_ASSERT_MTX_NEAR( - c_permute, - l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), - 0.0); + ASSERT_EQ(res->get_num_stored_elements(), 0); + ASSERT_EQ(*res->get_const_slice_sets(), 0); + ASSERT_FALSE(res->get_size()); } -TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsColPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, SquareMatrixCanGatherRows) { using Mtx = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 0}}; - auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->column_permute(&permute_idxs, c_permute); + auto row_collection = this->mtx5->row_gather(&permute_idxs); - GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), + GKO_ASSERT_MTX_NEAR(row_collection, + l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), 0.0); - ASSERT_EQ(c_permute->get_stride(), 4); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixColPermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(DenseWithIndexType, SquareMatrixCanGatherRowsIntoDense) { using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - - ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, row_permute), - gko::ValueMismatch); -} - + gko::array permute_idxs{exec, {1, 0}}; + auto row_collection = Mtx::create(exec, gko::dim<2>{2, 3}); -TYPED_TEST(DenseWithIndexType, - SquareMatrixColPermuteIntoDenseFailsForWrongDimensions) -{ - using Mtx = typename TestFixture::Mtx; - using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; + this->mtx5->row_gather(&permute_idxs, row_collection); - ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); + GKO_ASSERT_MTX_NEAR(row_collection, + l({{-2.0, 2.0, 4.5}, {1.0, -1.0, -0.5}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseRowPermutable) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixCanGatherRowsIntoDense) { using Mtx = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 0}}; + auto row_collection = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto inv_row_permute = - gko::as(this->mtx5->inverse_row_permute(&inverse_permute_idxs)); + this->mtx5->create_submatrix({0, 2}, {1, 3}) + ->row_gather(&permute_idxs, row_collection); - GKO_ASSERT_MTX_NEAR( - inv_row_permute, - l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), - 0.0); + GKO_ASSERT_MTX_NEAR(row_collection, + l({{2.0, 4.5}, {-1.0, -0.5}}), 0.0); + ASSERT_EQ(row_collection->get_stride(), 4); } -TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsInverseRowPermutable) +TYPED_TEST(DenseWithIndexType, NonSquareSubmatrixCanGatherRowsIntoMixedDense) { using Mtx = typename TestFixture::Mtx; + using MixedMtx = typename TestFixture::MixedMtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; auto exec = this->mtx4->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 0}}; + gko::array gather_index{exec, {1, 0, 1}}; + auto row_collection = MixedMtx::create(exec, gko::dim<2>{3, 3}, 4); - auto inverse_row_permute = - gko::as(this->mtx4->inverse_row_permute(&inverse_permute_idxs)); + this->mtx4->row_gather(&gather_index, row_collection); - GKO_ASSERT_MTX_NEAR(inverse_row_permute, - l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); + GKO_ASSERT_MTX_NEAR( + row_collection, + l( + {{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}, {0.0, 5.0, 0.0}}), + 0.0); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseRowPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, + NonSquareSubmatrixCanAdvancedGatherRowsIntoMixedDense) { using Mtx = typename TestFixture::Mtx; + using MixedMtx = typename TestFixture::MixedMtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2, 0}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + auto exec = this->mtx4->get_executor(); + gko::array gather_index{exec, {1, 0, 1}}; + auto row_collection = gko::initialize( + {{1.0, 0.5, -1.0}, {-1.5, 0.5, 1.0}, {2.0, -3.0, 1.0}}, exec); + auto alpha = gko::initialize({1.0}, exec); + auto beta = gko::initialize({2.0}, exec); - this->mtx5->inverse_row_permute(&permute_idxs, row_permute); + this->mtx4->row_gather(alpha, &gather_index, beta, row_collection); GKO_ASSERT_MTX_NEAR( - row_permute, - l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), + row_collection, + l( + {{2.0, 6.0, -2.0}, {-2.0, 4.0, 4.0}, {4.0, -1.0, 2.0}}), 0.0); } -TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInverseRowPermutableIntoDense) +TYPED_TEST(DenseWithIndexType, + SquareMatrixGatherRowsIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 0}}; - auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - - this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->inverse_row_permute(&permute_idxs, row_permute); - GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), - 0.0); - ASSERT_EQ(row_permute->get_stride(), 4); + ASSERT_THROW(this->mtx5->row_gather(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixInverseRowPermuteIntoDenseFailsForWrongPermutationSize) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsPermutable) { using Mtx = typename TestFixture::Mtx; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + gko::array permute_idxs{exec, {1, 2, 0}}; - ASSERT_THROW(this->mtx5->inverse_row_permute(&permute_idxs, row_permute), - gko::ValueMismatch); + auto ref_permuted = + gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) + ->column_permute(&permute_idxs)); + auto permuted = gko::as(this->mtx5->permute(&permute_idxs)); + + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); } -TYPED_TEST(DenseWithIndexType, - SquareMatrixInverseRowPermuteIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - ASSERT_THROW( - this->mtx5->inverse_row_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); + auto ref_permuted = + gko::as(gko::as(this->mtx5->row_permute(&permute_idxs)) + ->column_permute(&permute_idxs)); + this->mtx5->permute(&permute_idxs, permuted); + + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); } -TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseColPermutable) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; + gko::array permute_idxs{exec, {1, 0}}; + auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); - auto inv_c_permute = - gko::as(this->mtx5->inverse_column_permute(&inverse_permute_idxs)); + auto ref_permuted = + gko::as(gko::as(mtx->row_permute(&permute_idxs)) + ->column_permute(&permute_idxs)); + mtx->permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR( - inv_c_permute, - l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), - 0.0); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); + ASSERT_EQ(permuted->get_stride(), 4); } -TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsInverseColPermutable) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixPermuteIntoDenseFails) { using Mtx = typename TestFixture::Mtx; - using value_type = typename TestFixture::value_type; using index_type = typename TestFixture::index_type; auto exec = this->mtx4->get_executor(); - gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - - auto inverse_c_permute = - gko::as(this->mtx4->inverse_column_permute(&inverse_permute_idxs)); - - GKO_ASSERT_MTX_NEAR(inverse_c_permute, - l({{2.0, 1.0, 3.0}, {0.0, 0.0, 5.0}}), 0.0); -} - - -TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseColPermutableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - auto c_permute = Mtx::create(exec, this->mtx5->get_size()); - - this->mtx5->inverse_column_permute(&permute_idxs, c_permute); - - GKO_ASSERT_MTX_NEAR( - c_permute, - l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), - 0.0); -} - - -TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInverseColPermutableIntoDense) -{ - using Mtx = typename TestFixture::Mtx; - using value_type = typename TestFixture::value_type; - using index_type = typename TestFixture::index_type; - auto exec = this->mtx5->get_executor(); - gko::array permute_idxs{exec, {1, 0}}; - auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - - this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->column_permute(&permute_idxs, c_permute); - GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), - 0.0); - ASSERT_EQ(c_permute->get_stride(), 4); + ASSERT_THROW(this->mtx4->permute(&permute_idxs, this->mtx4->clone()), + gko::DimensionMismatch); } TYPED_TEST(DenseWithIndexType, - SquareMatrixInverseColPermuteIntoDenseFailsForWrongPermutationSize) + SquareMatrixPermuteIntoDenseFailsForWrongPermutationSize) { using Mtx = typename TestFixture::Mtx; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - ASSERT_THROW(this->mtx5->inverse_column_permute(&permute_idxs, row_permute), + ASSERT_THROW(this->mtx5->permute(&permute_idxs, this->mtx5->clone()), gko::ValueMismatch); } TYPED_TEST(DenseWithIndexType, - SquareMatrixInverseColPermuteIntoDenseFailsForWrongDimensions) + SquareMatrixPermuteIntoDenseFailsForWrongDimensions) { using Mtx = typename TestFixture::Mtx; using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - ASSERT_THROW( - this->mtx5->inverse_column_permute(&permute_idxs, Mtx::create(exec)), - gko::DimensionMismatch); -} - - -TYPED_TEST(Dense, ExtractsDiagonalFromSquareMatrix) -{ - using T = typename TestFixture::value_type; - - auto diag = this->mtx5->extract_diagonal(); - - ASSERT_EQ(diag->get_size()[0], 3); - ASSERT_EQ(diag->get_size()[1], 3); - ASSERT_EQ(diag->get_values()[0], T{1.}); - ASSERT_EQ(diag->get_values()[1], T{2.}); - ASSERT_EQ(diag->get_values()[2], T{1.2}); + ASSERT_THROW(this->mtx5->permute(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } -TYPED_TEST(Dense, ExtractsDiagonalFromTallSkinnyMatrix) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInversePermutable) { - using T = typename TestFixture::value_type; + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - auto diag = this->mtx4->extract_diagonal(); + auto ref_permuted = gko::as( + gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) + ->inverse_column_permute(&permute_idxs)); + auto permuted = gko::as(this->mtx5->inverse_permute(&permute_idxs)); - ASSERT_EQ(diag->get_size()[0], 2); - ASSERT_EQ(diag->get_size()[1], 2); - ASSERT_EQ(diag->get_values()[0], T{1.}); - ASSERT_EQ(diag->get_values()[1], T{5.}); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); } -TYPED_TEST(Dense, ExtractsDiagonalFromShortFatMatrix) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInversePermutableIntoDense) { - using T = typename TestFixture::value_type; + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - auto diag = this->mtx8->extract_diagonal(); + auto ref_permuted = gko::as( + gko::as(this->mtx5->inverse_row_permute(&permute_idxs)) + ->inverse_column_permute(&permute_idxs)); + this->mtx5->inverse_permute(&permute_idxs, permuted); - ASSERT_EQ(diag->get_size()[0], 2); - ASSERT_EQ(diag->get_size()[1], 2); - ASSERT_EQ(diag->get_values()[0], T{1.}); - ASSERT_EQ(diag->get_values()[1], T{2.}); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); } -TYPED_TEST(Dense, ExtractsDiagonalFromSquareMatrixIntoDiagonal) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInversePermutableIntoDense) { - using T = typename TestFixture::value_type; - auto diag = gko::matrix::Diagonal::create(this->exec, 3); + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 0}}; + auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + auto mtx = this->mtx5->create_submatrix({0, 2}, {1, 3}); - this->mtx5->extract_diagonal(diag); + auto ref_permuted = + gko::as(gko::as(mtx->inverse_row_permute(&permute_idxs)) + ->inverse_column_permute(&permute_idxs)); + mtx->inverse_permute(&permute_idxs, permuted); - ASSERT_EQ(diag->get_size()[0], 3); - ASSERT_EQ(diag->get_size()[1], 3); - ASSERT_EQ(diag->get_values()[0], T{1.}); - ASSERT_EQ(diag->get_values()[1], T{2.}); - ASSERT_EQ(diag->get_values()[2], T{1.2}); + GKO_ASSERT_MTX_NEAR(permuted, ref_permuted, 0.0); + ASSERT_EQ(permuted->get_stride(), 4); } -TYPED_TEST(Dense, ExtractsDiagonalFromTallSkinnyMatrixIntoDiagonal) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixInversePermuteIntoDenseFails) { - using T = typename TestFixture::value_type; - auto diag = gko::matrix::Diagonal::create(this->exec, 2); - - this->mtx4->extract_diagonal(diag); + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - ASSERT_EQ(diag->get_size()[0], 2); - ASSERT_EQ(diag->get_size()[1], 2); - ASSERT_EQ(diag->get_values()[0], T{1.}); - ASSERT_EQ(diag->get_values()[1], T{5.}); + ASSERT_THROW( + this->mtx4->inverse_permute(&permute_idxs, this->mtx4->clone()), + gko::DimensionMismatch); } -TYPED_TEST(Dense, ExtractsDiagonalFromShortFatMatrixIntoDiagonal) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInversePermuteIntoDenseFailsForWrongPermutationSize) { - using T = typename TestFixture::value_type; - auto diag = gko::matrix::Diagonal::create(this->exec, 2); - - this->mtx8->extract_diagonal(diag); + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {0, 1}}; - ASSERT_EQ(diag->get_size()[0], 2); - ASSERT_EQ(diag->get_size()[1], 2); - ASSERT_EQ(diag->get_values()[0], T{1.}); - ASSERT_EQ(diag->get_values()[1], T{2.}); + ASSERT_THROW( + this->mtx5->inverse_permute(&permute_idxs, this->mtx5->clone()), + gko::ValueMismatch); } -TYPED_TEST(Dense, InplaceAbsolute) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInversePermuteIntoDenseFailsForWrongDimensions) { - using T = typename TestFixture::value_type; - - this->mtx5->compute_absolute_inplace(); + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - GKO_ASSERT_MTX_NEAR( - this->mtx5, l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}), - 0.0); + ASSERT_THROW(this->mtx5->inverse_permute(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } -TYPED_TEST(Dense, InplaceAbsoluteSubMatrix) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsRowPermutable) { - using T = typename TestFixture::value_type; - auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2}); + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - mtx->compute_absolute_inplace(); + auto row_permute = gko::as(this->mtx5->row_permute(&permute_idxs)); GKO_ASSERT_MTX_NEAR( - this->mtx5, l({{1.0, 1.0, -0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}), + row_permute, + l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), 0.0); } -TYPED_TEST(Dense, OutplaceAbsolute) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsRowPermutable) { - using T = typename TestFixture::value_type; + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array permute_idxs{exec, {1, 0}}; - auto abs_mtx = this->mtx5->compute_absolute(); + auto row_permute = gko::as(this->mtx4->row_permute(&permute_idxs)); - GKO_ASSERT_MTX_NEAR( - abs_mtx, l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}), - 0.0); + GKO_ASSERT_MTX_NEAR(row_permute, + l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); } -TYPED_TEST(Dense, OutplaceAbsoluteIntoDense) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsRowPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto abs_mtx = - gko::remove_complex::create(this->exec, this->mtx5->get_size()); + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - this->mtx5->compute_absolute(abs_mtx); + this->mtx5->row_permute(&permute_idxs, row_permute); GKO_ASSERT_MTX_NEAR( - abs_mtx, l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}), + row_permute, + l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), 0.0); } -TYPED_TEST(Dense, OutplaceAbsoluteSubMatrix) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsRowPermutableIntoDense) { - using T = typename TestFixture::value_type; - auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2}); + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 0}}; + auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto abs_mtx = mtx->compute_absolute(); + this->mtx5->create_submatrix({0, 2}, {0, 2}) + ->row_permute(&permute_idxs, row_permute); - GKO_ASSERT_MTX_NEAR(abs_mtx, l({{1.0, 1.0}, {2.0, 2.0}}), 0); - GKO_ASSERT_EQ(abs_mtx->get_stride(), 2); + GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), + 0.0); + ASSERT_EQ(row_permute->get_stride(), 4); } -TYPED_TEST(Dense, OutplaceSubmatrixAbsoluteIntoDense) +TYPED_TEST(DenseWithIndexType, + SquareMatrixRowPermuteIntoDenseFailsForWrongPermutationSize) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2}); - auto abs_mtx = - gko::remove_complex::create(this->exec, gko::dim<2>{2, 2}, 4); - - mtx->compute_absolute(abs_mtx); + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2}}; + auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - GKO_ASSERT_MTX_NEAR(abs_mtx, l({{1.0, 1.0}, {2.0, 2.0}}), 0); - GKO_ASSERT_EQ(abs_mtx->get_stride(), 4); + ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, row_permute), + gko::ValueMismatch); } -TYPED_TEST(Dense, AppliesToComplex) +TYPED_TEST(DenseWithIndexType, + SquareMatrixRowPermuteIntoDenseFailsForWrongDimensions) { - using value_type = typename TestFixture::value_type; - using complex_type = gko::to_complex; - using Vec = gko::matrix::Dense; - auto exec = gko::ReferenceExecutor::create(); - auto b = - gko::initialize({{complex_type{1.0, 0.0}, complex_type{2.0, 1.0}}, - {complex_type{2.0, 2.0}, complex_type{3.0, 3.0}}, - {complex_type{3.0, 4.0}, complex_type{4.0, 5.0}}}, - exec); - auto x = Vec::create(exec, gko::dim<2>{2, 2}); - - this->mtx1->apply(b, x); + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - GKO_ASSERT_MTX_NEAR( - x, - l({{complex_type{14.0, 16.0}, complex_type{20.0, 22.0}}, - {complex_type{17.0, 19.0}, complex_type{24.5, 26.5}}}), - 0.0); + ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } -TYPED_TEST(Dense, AppliesToMixedComplex) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsColPermutable) { - using mixed_value_type = - gko::next_precision; - using mixed_complex_type = gko::to_complex; - using Vec = gko::matrix::Dense; - auto exec = gko::ReferenceExecutor::create(); - auto b = gko::initialize( - {{mixed_complex_type{1.0, 0.0}, mixed_complex_type{2.0, 1.0}}, - {mixed_complex_type{2.0, 2.0}, mixed_complex_type{3.0, 3.0}}, - {mixed_complex_type{3.0, 4.0}, mixed_complex_type{4.0, 5.0}}}, - exec); - auto x = Vec::create(exec, gko::dim<2>{2, 2}); + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - this->mtx1->apply(b, x); + auto c_permute = gko::as(this->mtx5->column_permute(&permute_idxs)); GKO_ASSERT_MTX_NEAR( - x, - l({{mixed_complex_type{14.0, 16.0}, mixed_complex_type{20.0, 22.0}}, - {mixed_complex_type{17.0, 19.0}, mixed_complex_type{24.5, 26.5}}}), + c_permute, + l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), 0.0); } -TYPED_TEST(Dense, AdvancedAppliesToComplex) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsColPermutable) { + using Mtx = typename TestFixture::Mtx; using value_type = typename TestFixture::value_type; - using complex_type = gko::to_complex; - using Dense = gko::matrix::Dense; - using DenseComplex = gko::matrix::Dense; - auto exec = gko::ReferenceExecutor::create(); - - auto b = gko::initialize( - {{complex_type{1.0, 0.0}, complex_type{2.0, 1.0}}, - {complex_type{2.0, 2.0}, complex_type{3.0, 3.0}}, - {complex_type{3.0, 4.0}, complex_type{4.0, 5.0}}}, - exec); - auto x = gko::initialize( - {{complex_type{1.0, 0.0}, complex_type{2.0, 1.0}}, - {complex_type{2.0, 2.0}, complex_type{3.0, 3.0}}}, - exec); - auto alpha = gko::initialize({-1.0}, this->exec); - auto beta = gko::initialize({2.0}, this->exec); + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - this->mtx1->apply(alpha, b, beta, x); + auto c_permute = gko::as(this->mtx4->column_permute(&permute_idxs)); - GKO_ASSERT_MTX_NEAR( - x, - l({{complex_type{-12.0, -16.0}, complex_type{-16.0, -20.0}}, - {complex_type{-13.0, -15.0}, complex_type{-18.5, -20.5}}}), - 0.0); + GKO_ASSERT_MTX_NEAR(c_permute, + l({{3.0, 2.0, 1.0}, {5.0, 0.0, 0.0}}), 0.0); } -TYPED_TEST(Dense, AdvancedAppliesToMixedComplex) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsColPermutableIntoDense) { - using mixed_value_type = - gko::next_precision; - using mixed_complex_type = gko::to_complex; - using MixedDense = gko::matrix::Dense; - using MixedDenseComplex = gko::matrix::Dense; - auto exec = gko::ReferenceExecutor::create(); - - auto b = gko::initialize( - {{mixed_complex_type{1.0, 0.0}, mixed_complex_type{2.0, 1.0}}, - {mixed_complex_type{2.0, 2.0}, mixed_complex_type{3.0, 3.0}}, - {mixed_complex_type{3.0, 4.0}, mixed_complex_type{4.0, 5.0}}}, - exec); - auto x = gko::initialize( - {{mixed_complex_type{1.0, 0.0}, mixed_complex_type{2.0, 1.0}}, - {mixed_complex_type{2.0, 2.0}, mixed_complex_type{3.0, 3.0}}}, - exec); - auto alpha = gko::initialize({-1.0}, this->exec); - auto beta = gko::initialize({2.0}, this->exec); + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + auto c_permute = Mtx::create(exec, this->mtx5->get_size()); - this->mtx1->apply(alpha, b, beta, x); + this->mtx5->column_permute(&permute_idxs, c_permute); GKO_ASSERT_MTX_NEAR( - x, - l({{mixed_complex_type{-12.0, -16.0}, mixed_complex_type{-16.0, -20.0}}, - {mixed_complex_type{-13.0, -15.0}, - mixed_complex_type{-18.5, -20.5}}}), + c_permute, + l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), 0.0); } -TYPED_TEST(Dense, MakeComplex) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsColPermutableIntoDense) { - using T = typename TestFixture::value_type; + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 0}}; + auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto complex_mtx = this->mtx5->make_complex(); + this->mtx5->create_submatrix({0, 2}, {0, 2}) + ->column_permute(&permute_idxs, c_permute); - GKO_ASSERT_MTX_NEAR(complex_mtx, this->mtx5, 0.0); + GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), + 0.0); + ASSERT_EQ(c_permute->get_stride(), 4); } -TYPED_TEST(Dense, MakeComplexIntoDense) +TYPED_TEST(DenseWithIndexType, + SquareMatrixColPermuteIntoDenseFailsForWrongPermutationSize) { - using T = typename TestFixture::value_type; - using ComplexMtx = typename TestFixture::ComplexMtx; + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2}}; + auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - auto complex_mtx = ComplexMtx::create(exec, this->mtx5->get_size()); - this->mtx5->make_complex(complex_mtx); + ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, row_permute), + gko::ValueMismatch); +} - GKO_ASSERT_MTX_NEAR(complex_mtx, this->mtx5, 0.0); + +TYPED_TEST(DenseWithIndexType, + SquareMatrixColPermuteIntoDenseFailsForWrongDimensions) +{ + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + + ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } -TYPED_TEST(Dense, MakeComplexIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseRowPermutable) { - using T = typename TestFixture::value_type; - using ComplexMtx = typename TestFixture::ComplexMtx; + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); + gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - auto complex_mtx = ComplexMtx::create(exec); + auto inv_row_permute = + gko::as(this->mtx5->inverse_row_permute(&inverse_permute_idxs)); - ASSERT_THROW(this->mtx5->make_complex(complex_mtx), gko::DimensionMismatch); + GKO_ASSERT_MTX_NEAR( + inv_row_permute, + l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), + 0.0); } -TYPED_TEST(Dense, GetReal) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsInverseRowPermutable) { - using T = typename TestFixture::value_type; + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array inverse_permute_idxs{exec, {1, 0}}; - auto real_mtx = this->mtx5->get_real(); + auto inverse_row_permute = + gko::as(this->mtx4->inverse_row_permute(&inverse_permute_idxs)); - GKO_ASSERT_MTX_NEAR(real_mtx, this->mtx5, 0.0); + GKO_ASSERT_MTX_NEAR(inverse_row_permute, + l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); } -TYPED_TEST(Dense, GetRealIntoDense) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseRowPermutableIntoDense) { - using T = typename TestFixture::value_type; - using RealMtx = typename TestFixture::RealMtx; + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - auto real_mtx = RealMtx::create(exec, this->mtx5->get_size()); - this->mtx5->get_real(real_mtx); + this->mtx5->inverse_row_permute(&permute_idxs, row_permute); - GKO_ASSERT_MTX_NEAR(real_mtx, this->mtx5, 0.0); + GKO_ASSERT_MTX_NEAR( + row_permute, + l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), + 0.0); } -TYPED_TEST(Dense, GetRealIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInverseRowPermutableIntoDense) { - using T = typename TestFixture::value_type; - using RealMtx = typename TestFixture::RealMtx; + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 0}}; + auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - auto real_mtx = RealMtx::create(exec); - ASSERT_THROW(this->mtx5->get_real(real_mtx), gko::DimensionMismatch); + this->mtx5->create_submatrix({0, 2}, {0, 2}) + ->inverse_row_permute(&permute_idxs, row_permute); + + GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), + 0.0); + ASSERT_EQ(row_permute->get_stride(), 4); } -TYPED_TEST(Dense, GetImag) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInverseRowPermuteIntoDenseFailsForWrongPermutationSize) { - using T = typename TestFixture::value_type; + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2}}; + auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - auto imag_mtx = this->mtx5->get_imag(); + ASSERT_THROW(this->mtx5->inverse_row_permute(&permute_idxs, row_permute), + gko::ValueMismatch); +} - GKO_ASSERT_MTX_NEAR( - imag_mtx, l({{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}}), - 0.0); + +TYPED_TEST(DenseWithIndexType, + SquareMatrixInverseRowPermuteIntoDenseFailsForWrongDimensions) +{ + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + + ASSERT_THROW( + this->mtx5->inverse_row_permute(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } -TYPED_TEST(Dense, GetImagIntoDense) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseColPermutable) { - using T = typename TestFixture::value_type; - using RealMtx = typename TestFixture::RealMtx; + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); + gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - auto imag_mtx = RealMtx::create(exec, this->mtx5->get_size()); - this->mtx5->get_imag(imag_mtx); + auto inv_c_permute = + gko::as(this->mtx5->inverse_column_permute(&inverse_permute_idxs)); GKO_ASSERT_MTX_NEAR( - imag_mtx, l({{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}}), + inv_c_permute, + l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), 0.0); } -TYPED_TEST(Dense, GetImagIntoDenseFailsForWrongDimensions) +TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsInverseColPermutable) { - using T = typename TestFixture::value_type; - using RealMtx = typename TestFixture::RealMtx; - auto exec = this->mtx5->get_executor(); + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx4->get_executor(); + gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - auto imag_mtx = RealMtx::create(exec); - ASSERT_THROW(this->mtx5->get_imag(imag_mtx), gko::DimensionMismatch); + auto inverse_c_permute = + gko::as(this->mtx4->inverse_column_permute(&inverse_permute_idxs)); + + GKO_ASSERT_MTX_NEAR(inverse_c_permute, + l({{2.0, 1.0, 3.0}, {0.0, 0.0, 5.0}}), 0.0); } -TYPED_TEST(Dense, MakeTemporaryConversionDoesntConvertOnMatch) +TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseColPermutableIntoDense) { using Mtx = typename TestFixture::Mtx; - using T = typename TestFixture::value_type; - auto alpha = gko::initialize({8.0}, this->exec); + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; + auto c_permute = Mtx::create(exec, this->mtx5->get_size()); - ASSERT_EQ(gko::make_temporary_conversion(alpha).get(), alpha.get()); + this->mtx5->inverse_column_permute(&permute_idxs, c_permute); + + GKO_ASSERT_MTX_NEAR( + c_permute, + l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), + 0.0); } -TYPED_TEST(Dense, MakeTemporaryConversionConvertsBack) +TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInverseColPermutableIntoDense) { - using MixedMtx = typename TestFixture::MixedMtx; - using T = typename TestFixture::value_type; - using MixedT = typename MixedMtx::value_type; - auto alpha = gko::initialize({8.0}, this->exec); + using Mtx = typename TestFixture::Mtx; + using value_type = typename TestFixture::value_type; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 0}}; + auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); - { - auto conversion = gko::make_temporary_conversion(alpha); - conversion->at(0, 0) = T{7.0}; - } + this->mtx5->create_submatrix({0, 2}, {0, 2}) + ->column_permute(&permute_idxs, c_permute); - ASSERT_EQ(alpha->at(0, 0), MixedT{7.0}); + GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), + 0.0); + ASSERT_EQ(c_permute->get_stride(), 4); } -TYPED_TEST(Dense, MakeTemporaryConversionConstDoesntConvertBack) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInverseColPermuteIntoDenseFailsForWrongPermutationSize) { - using MixedMtx = typename TestFixture::MixedMtx; - using T = typename TestFixture::value_type; - using MixedT = typename MixedMtx::value_type; - auto alpha = gko::initialize({8.0}, this->exec); - - { - auto conversion = gko::make_temporary_conversion( - static_cast(alpha.get())); - alpha->at(0, 0) = MixedT{7.0}; - } + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2}}; + auto row_permute = Mtx::create(exec, this->mtx5->get_size()); - ASSERT_EQ(alpha->at(0, 0), MixedT{7.0}); + ASSERT_THROW(this->mtx5->inverse_column_permute(&permute_idxs, row_permute), + gko::ValueMismatch); } -TYPED_TEST(Dense, ScaleAddIdentityRectangular) +TYPED_TEST(DenseWithIndexType, + SquareMatrixInverseColPermuteIntoDenseFailsForWrongDimensions) { - using T = typename TestFixture::value_type; - using Vec = typename TestFixture::Mtx; - using MixedVec = typename TestFixture::MixedMtx; - auto alpha = gko::initialize({2.0}, this->exec); - auto beta = gko::initialize({-1.0}, this->exec); - auto b = gko::initialize( - {I{2.0, 0.0}, I{1.0, 2.5}, I{0.0, -4.0}}, this->exec); - - b->add_scaled_identity(alpha, beta); + using Mtx = typename TestFixture::Mtx; + using index_type = typename TestFixture::index_type; + auto exec = this->mtx5->get_executor(); + gko::array permute_idxs{exec, {1, 2, 0}}; - GKO_ASSERT_MTX_NEAR(b, l({{0.0, 0.0}, {-1.0, -0.5}, {0.0, 4.0}}), 0.0); + ASSERT_THROW( + this->mtx5->inverse_column_permute(&permute_idxs, Mtx::create(exec)), + gko::DimensionMismatch); } From 4cc96920057f3c05c2d915dd3f318163a32a31bd Mon Sep 17 00:00:00 2001 From: Tobias Ribizel Date: Tue, 17 Oct 2023 09:52:27 +0200 Subject: [PATCH 3/3] review updates - Remove unused declarations - Consistent variable naming Co-authored-by: Marcel Koch --- reference/test/matrix/dense_kernels.cpp | 108 ++++++++++++------------ 1 file changed, 52 insertions(+), 56 deletions(-) diff --git a/reference/test/matrix/dense_kernels.cpp b/reference/test/matrix/dense_kernels.cpp index 56f082243e6..60713c815de 100644 --- a/reference/test/matrix/dense_kernels.cpp +++ b/reference/test/matrix/dense_kernels.cpp @@ -68,7 +68,6 @@ class Dense : public ::testing::Test { using Mtx = gko::matrix::Dense; using MixedMtx = gko::matrix::Dense>; using ComplexMtx = gko::to_complex; - using MixedComplexMtx = gko::to_complex; using RealMtx = gko::remove_complex; Dense() : exec(gko::ReferenceExecutor::create()), @@ -1297,7 +1296,6 @@ TYPED_TEST(Dense, ScaleAddIdentityRectangular) { using T = typename TestFixture::value_type; using Vec = typename TestFixture::Mtx; - using MixedVec = typename TestFixture::MixedMtx; auto alpha = gko::initialize({2.0}, this->exec); auto beta = gko::initialize({-1.0}, this->exec); auto b = gko::initialize( @@ -1318,8 +1316,6 @@ class DenseWithIndexType typename std::tuple_element<0, decltype(ValueIndexType())>::type; using index_type = typename std::tuple_element<1, decltype(ValueIndexType())>::type; - - index_type invalid_index = gko::invalid_index(); }; TYPED_TEST_SUITE(DenseWithIndexType, gko::test::ValueIndexTypes, @@ -2501,10 +2497,10 @@ TYPED_TEST(DenseWithIndexType, SquareMatrixIsRowPermutable) auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - auto row_permute = gko::as(this->mtx5->row_permute(&permute_idxs)); + auto permuted = gko::as(this->mtx5->row_permute(&permute_idxs)); GKO_ASSERT_MTX_NEAR( - row_permute, + permuted, l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), 0.0); } @@ -2518,9 +2514,9 @@ TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsRowPermutable) auto exec = this->mtx4->get_executor(); gko::array permute_idxs{exec, {1, 0}}; - auto row_permute = gko::as(this->mtx4->row_permute(&permute_idxs)); + auto permuted = gko::as(this->mtx4->row_permute(&permute_idxs)); - GKO_ASSERT_MTX_NEAR(row_permute, + GKO_ASSERT_MTX_NEAR(permuted, l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); } @@ -2532,12 +2528,12 @@ TYPED_TEST(DenseWithIndexType, SquareMatrixIsRowPermutableIntoDense) using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - this->mtx5->row_permute(&permute_idxs, row_permute); + this->mtx5->row_permute(&permute_idxs, permuted); GKO_ASSERT_MTX_NEAR( - row_permute, + permuted, l({{-2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}}), 0.0); } @@ -2550,14 +2546,14 @@ TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsRowPermutableIntoDense) using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 0}}; - auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->row_permute(&permute_idxs, row_permute); + ->row_permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), + GKO_ASSERT_MTX_NEAR(permuted, l({{-2.0, 2.0}, {1.0, -1.0}}), 0.0); - ASSERT_EQ(row_permute->get_stride(), 4); + ASSERT_EQ(permuted->get_stride(), 4); } @@ -2568,9 +2564,9 @@ TYPED_TEST(DenseWithIndexType, using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, row_permute), + ASSERT_THROW(this->mtx5->row_permute(&permute_idxs, permuted), gko::ValueMismatch); } @@ -2596,10 +2592,10 @@ TYPED_TEST(DenseWithIndexType, SquareMatrixIsColPermutable) auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - auto c_permute = gko::as(this->mtx5->column_permute(&permute_idxs)); + auto permuted = gko::as(this->mtx5->column_permute(&permute_idxs)); GKO_ASSERT_MTX_NEAR( - c_permute, + permuted, l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), 0.0); } @@ -2613,9 +2609,9 @@ TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsColPermutable) auto exec = this->mtx4->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - auto c_permute = gko::as(this->mtx4->column_permute(&permute_idxs)); + auto permuted = gko::as(this->mtx4->column_permute(&permute_idxs)); - GKO_ASSERT_MTX_NEAR(c_permute, + GKO_ASSERT_MTX_NEAR(permuted, l({{3.0, 2.0, 1.0}, {5.0, 0.0, 0.0}}), 0.0); } @@ -2627,12 +2623,12 @@ TYPED_TEST(DenseWithIndexType, SquareMatrixIsColPermutableIntoDense) using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - auto c_permute = Mtx::create(exec, this->mtx5->get_size()); + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - this->mtx5->column_permute(&permute_idxs, c_permute); + this->mtx5->column_permute(&permute_idxs, permuted); GKO_ASSERT_MTX_NEAR( - c_permute, + permuted, l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), 0.0); } @@ -2645,14 +2641,14 @@ TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsColPermutableIntoDense) using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 0}}; - auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->column_permute(&permute_idxs, c_permute); + ->column_permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), + GKO_ASSERT_MTX_NEAR(permuted, l({{-1.0, 1.0}, {2.0, -2.0}}), 0.0); - ASSERT_EQ(c_permute->get_stride(), 4); + ASSERT_EQ(permuted->get_stride(), 4); } @@ -2663,9 +2659,9 @@ TYPED_TEST(DenseWithIndexType, using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, row_permute), + ASSERT_THROW(this->mtx5->column_permute(&permute_idxs, permuted), gko::ValueMismatch); } @@ -2691,11 +2687,11 @@ TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseRowPermutable) auto exec = this->mtx5->get_executor(); gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - auto inv_row_permute = + auto permuted = gko::as(this->mtx5->inverse_row_permute(&inverse_permute_idxs)); GKO_ASSERT_MTX_NEAR( - inv_row_permute, + permuted, l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), 0.0); } @@ -2709,10 +2705,10 @@ TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsInverseRowPermutable) auto exec = this->mtx4->get_executor(); gko::array inverse_permute_idxs{exec, {1, 0}}; - auto inverse_row_permute = + auto permuted = gko::as(this->mtx4->inverse_row_permute(&inverse_permute_idxs)); - GKO_ASSERT_MTX_NEAR(inverse_row_permute, + GKO_ASSERT_MTX_NEAR(permuted, l({{0.0, 5.0, 0.0}, {1.0, 3.0, 2.0}}), 0.0); } @@ -2724,12 +2720,12 @@ TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseRowPermutableIntoDense) using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - this->mtx5->inverse_row_permute(&permute_idxs, row_permute); + this->mtx5->inverse_row_permute(&permute_idxs, permuted); GKO_ASSERT_MTX_NEAR( - row_permute, + permuted, l({{2.1, 3.4, 1.2}, {1.0, -1.0, -0.5}, {-2.0, 2.0, 4.5}}), 0.0); } @@ -2742,14 +2738,14 @@ TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInverseRowPermutableIntoDense) using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 0}}; - auto row_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->inverse_row_permute(&permute_idxs, row_permute); + ->inverse_row_permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR(row_permute, l({{-2.0, 2.0}, {1.0, -1.0}}), + GKO_ASSERT_MTX_NEAR(permuted, l({{-2.0, 2.0}, {1.0, -1.0}}), 0.0); - ASSERT_EQ(row_permute->get_stride(), 4); + ASSERT_EQ(permuted->get_stride(), 4); } @@ -2760,9 +2756,9 @@ TYPED_TEST(DenseWithIndexType, using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - ASSERT_THROW(this->mtx5->inverse_row_permute(&permute_idxs, row_permute), + ASSERT_THROW(this->mtx5->inverse_row_permute(&permute_idxs, permuted), gko::ValueMismatch); } @@ -2789,11 +2785,11 @@ TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseColPermutable) auto exec = this->mtx5->get_executor(); gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - auto inv_c_permute = + auto permuted = gko::as(this->mtx5->inverse_column_permute(&inverse_permute_idxs)); GKO_ASSERT_MTX_NEAR( - inv_c_permute, + permuted, l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), 0.0); } @@ -2807,10 +2803,10 @@ TYPED_TEST(DenseWithIndexType, NonSquareMatrixIsInverseColPermutable) auto exec = this->mtx4->get_executor(); gko::array inverse_permute_idxs{exec, {1, 2, 0}}; - auto inverse_c_permute = + auto permuted = gko::as(this->mtx4->inverse_column_permute(&inverse_permute_idxs)); - GKO_ASSERT_MTX_NEAR(inverse_c_permute, + GKO_ASSERT_MTX_NEAR(permuted, l({{2.0, 1.0, 3.0}, {0.0, 0.0, 5.0}}), 0.0); } @@ -2822,12 +2818,12 @@ TYPED_TEST(DenseWithIndexType, SquareMatrixIsInverseColPermutableIntoDense) using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2, 0}}; - auto c_permute = Mtx::create(exec, this->mtx5->get_size()); + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - this->mtx5->inverse_column_permute(&permute_idxs, c_permute); + this->mtx5->inverse_column_permute(&permute_idxs, permuted); GKO_ASSERT_MTX_NEAR( - c_permute, + permuted, l({{-0.5, 1.0, -1.0}, {4.5, -2.0, 2.0}, {1.2, 2.1, 3.4}}), 0.0); } @@ -2840,14 +2836,14 @@ TYPED_TEST(DenseWithIndexType, SquareSubmatrixIsInverseColPermutableIntoDense) using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 0}}; - auto c_permute = Mtx::create(exec, gko::dim<2>{2, 2}, 4); + auto permuted = Mtx::create(exec, gko::dim<2>{2, 2}, 4); this->mtx5->create_submatrix({0, 2}, {0, 2}) - ->column_permute(&permute_idxs, c_permute); + ->column_permute(&permute_idxs, permuted); - GKO_ASSERT_MTX_NEAR(c_permute, l({{-1.0, 1.0}, {2.0, -2.0}}), + GKO_ASSERT_MTX_NEAR(permuted, l({{-1.0, 1.0}, {2.0, -2.0}}), 0.0); - ASSERT_EQ(c_permute->get_stride(), 4); + ASSERT_EQ(permuted->get_stride(), 4); } @@ -2858,9 +2854,9 @@ TYPED_TEST(DenseWithIndexType, using index_type = typename TestFixture::index_type; auto exec = this->mtx5->get_executor(); gko::array permute_idxs{exec, {1, 2}}; - auto row_permute = Mtx::create(exec, this->mtx5->get_size()); + auto permuted = Mtx::create(exec, this->mtx5->get_size()); - ASSERT_THROW(this->mtx5->inverse_column_permute(&permute_idxs, row_permute), + ASSERT_THROW(this->mtx5->inverse_column_permute(&permute_idxs, permuted), gko::ValueMismatch); }