wip

Author: MarcelKoch

core/matrix/row_scatterer.cpp

@@ -78,7 +78,22 @@ void RowScatterer<IndexType>::apply_impl(const LinOp* b, LinOp* x) const
 template <typename IndexType>
 void RowScatterer<IndexType>::apply_impl(const LinOp* alpha, const LinOp* b,
                                          const LinOp* beta, LinOp* x) const
-{}
+{
+    auto x_copy = gko::clone(x);
+    run<Dense,
+#if GINKGO_ENABLE_HALF
+        gko::half, std::complex<gko::half>,
+#endif
+        float, double, std::complex<float>, std::complex<double>>(
+        x, [&](auto* target) {
+            using dense_type = std::decay_t<decltype(*target)>;
+            as<dense_type>(x_copy)->fill(
+                gko::zero<typename dense_type::value_type>());
+            this->apply_impl(b, x_copy);
+            target->scale(beta);
+            target->add_scaled(alpha, x_copy);
+        });
+}
 
 
 #define GKO_DECLARE_ROW_SCATTER(_type) class RowScatterer<_type>

reference/matrix/row_scatterer_kernels.cpp

@@ -25,7 +25,13 @@ void row_scatter(std::shared_ptr<const ReferenceExecutor> exec,
             return;
         }
         for (size_type j = 0; j < orig->get_size()[1]; ++j) {
-            target->at(rows[i], j) = orig->at(i, j);
+            target->at(rows[i], j) = zero<OutputType>();
+        }
+    }
+
+    for (size_type i = 0; i < row_idxs->get_size(); ++i) {
+        for (size_type j = 0; j < orig->get_size()[1]; ++j) {
+            target->at(rows[i], j) += orig->at(i, j);
         }
     }
 }

reference/test/matrix/row_scatterer_kernels.cpp

@@ -21,6 +21,7 @@ class RowScatter : public ::testing::Test {
     using index_type = std::tuple_element_t<2, InValueOutValueIndexType>;
     using DenseIn = gko::matrix::Dense<in_value_type>;
     using DenseOut = gko::matrix::Dense<out_value_type>;
+    using Scatterer = gko::matrix::RowScatterer<index_type>;
 
 
     std::shared_ptr<gko::ReferenceExecutor> exec =
@@ -32,6 +33,9 @@ class RowScatter : public ::testing::Test {
         I<I<out_value_type>>{{11, 22}, {33, 44}, {55, 66}, {77, 88}}, exec);
 
     gko::array<index_type> idxs = {exec, {3, 1}};
+
+    std::unique_ptr<Scatterer> scatterer =
+        Scatterer::create(exec, idxs, out->get_size()[0]);
 };
 
 #ifdef GINKGO_MIXED_PRECISION
@@ -43,7 +47,7 @@ TYPED_TEST_SUITE(RowScatter, gko::test::MixedPresisionValueIndexTypes,
 #endif
 
 
-TYPED_TEST(RowScatter, CanScatter)
+TYPED_TEST(RowScatter, CanRowScatter)
 {
     bool invalid_access = false;
 
@@ -70,3 +74,31 @@ TYPED_TEST(RowScatter, CanDetectInvalidAccess)
 
     ASSERT_TRUE(invalid_access);
 }
+
+
+TYPED_TEST(RowScatter, CanRowScatterSimpleApply)
+{
+    this->scatterer->apply(this->in.get(), this->out.get());
+
+    auto expected = gko::initialize<typename TestFixture::DenseOut>(
+        I<I<typename TestFixture::out_value_type>>{
+            {11, 22}, {3, 4}, {55, 66}, {1, 2}},
+        this->exec);
+    GKO_ASSERT_MTX_NEAR(this->out, expected, 0.0);
+}
+
+
+TYPED_TEST(RowScatter, CanRowScatterAdvancedApply)
+{
+    auto alpha = gko::initialize<typename TestFixture::DenseIn>(
+        {-gko::one<typename TestFixture::in_value_type>()}, this->exec);
+    auto beta = gko::initialize<typename TestFixture::DenseOut>(
+        {-2 * gko::one<typename TestFixture::out_value_type>()}, this->exec);
+    this->scatterer->apply(this->in.get(), this->out.get());
+
+    auto expected = gko::initialize<typename TestFixture::DenseOut>(
+        I<I<typename TestFixture::out_value_type>>{
+            {-11, -22}, {3, 4}, {-55, -66}, {1, 2}},
+        this->exec);
+    GKO_ASSERT_MTX_NEAR(this->out, expected, 0.0);
+}