Feat/conv 1 d

core/matrix/conv.cpp

@@ -33,7 +33,8 @@ void Conv<ValueType>::apply_impl(const LinOp* b, LinOp* x) const
 {
     precision_dispatch_real_complex<ValueType>(
         [this](auto dense_b, auto dense_x) {
-            this->get_executor()->run(conv::make_conv(this, dense_b, dense_x));
+            this->get_executor()->run(
+                conv::make_conv(kernel_, dense_b, dense_x));
         },
         b, x);
 }
@@ -50,7 +51,22 @@ template <typename ValueType>
 void Conv<ValueType>::validate_application_parameters(const LinOp* b,
                                                       const LinOp* x) const
 {
-    // implement dimension validation throw DimensionMismatch when it is wrong
+    using gko::detail::get_size;
+    const auto b_rows = get_size(b)[0];
+    const auto x_rows = get_size(x)[0];
+    const auto kernel_len = kernel_.get_size();
+
+    if (x_rows != b_rows + kernel_len - 1) {
+        throw DimensionMismatch(
+            __FILE__, __LINE__, __func__, "x", x_rows, 1,
+            "(b + 2*padding - kernel)/stride + 1",
+            (b_rows + 2 * 2 - kernel_len) / 1 + 1, 1,
+            "x must have size = (b + 2*padding - kernel)/stride + 1");
+    }
+
+
+    GKO_ASSERT_EQUAL_COLS(b, x);
+    GKO_ASSERT_EQUAL_COLS(b, dim<2>{1, 1});
 }
 
 

core/matrix/conv_kernels.hpp

@@ -18,7 +18,7 @@ namespace kernels {
 
 #define GKO_DECLARE_CONV_KERNEL(ValueType)                 \
     void conv(std::shared_ptr<const DefaultExecutor> exec, \
-              const matrix::Conv<ValueType>* kernel,       \
+              const array<ValueType>& kernel,              \
               const matrix::Dense<ValueType>* b, matrix::Dense<ValueType>* x)
 
 

examples/CMakeLists.txt

@@ -20,6 +20,7 @@ set(EXAMPLES_EXEC_LIST
     preconditioned-solver
     simple-solver
     three-pt-stencil-solver
+    conv
 )
 
 set(EXAMPLES_LIST

examples/conv/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable(conv conv.cpp)
+target_link_libraries(conv PRIVATE Ginkgo::ginkgo)
+target_include_directories(conv PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})

examples/conv/conv.cpp

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include <ginkgo/ginkgo.hpp>
+
+int main()
+{
+    using ValueType = double;
+    using Vec = gko::matrix::Dense<ValueType>;
+
+    // Executor setup
+    auto exec = gko::ReferenceExecutor::create();
+
+    // Convolution kernel (length K) as a gko::array on the executor
+    std::vector<ValueType> kernel_vals{1.0, 2.0, 3.0};
+    gko::array<ValueType> kernel_array(exec, kernel_vals.begin(),
+                                       kernel_vals.end());
+    auto conv_op = gko::matrix::Conv<ValueType>::create(exec, kernel_array);
+
+    // Input signal (length N) as a Dense vector
+    auto input = gko::initialize<Vec>({4.0, 5.0, 6.0, 7.0}, exec);
+
+    // Allocate output Dense vector: floor((N + 2*padding - K) / stride) + 1
+    // elements
+    const gko::size_type output_length =
+        (input->get_size()[0] + 2 * 2 - kernel_vals.size()) / 1 + 1;
+    std::cout << "Output length: " << output_length << std::endl;
+    auto output = Vec::create(exec, gko::dim<2>{output_length, 1});
+    output->fill(0.0);
+
+    // Apply convolution: conv_op * input -> output
+    conv_op->apply(gko::lend(input), gko::lend(output));
+
+    // Output the results
+    std::cout << "Convolution result: ";
+    for (gko::size_type i = 0; i < output_length; ++i) {
+        std::cout << output->at(i, 0) << " ";
+    }
+    std::cout << std::endl;
+}

omp/matrix/conv_kernels.cpp

@@ -24,8 +24,8 @@ namespace conv {
 
 template <typename ValueType>
 void conv(std::shared_ptr<const DefaultExecutor> exec,
-          const matrix::Conv<ValueType>* kernel,
-          const matrix::Dense<ValueType>* b, matrix::Dense<ValueType>* x)
+          const array<ValueType>& kernel, const matrix::Dense<ValueType>* b,
+          matrix::Dense<ValueType>* x)
 {
     GKO_NOT_IMPLEMENTED;
 }

reference/matrix/conv_kernels.cpp

@@ -24,10 +24,34 @@ namespace conv {
 
 template <typename ValueType>
 void conv(std::shared_ptr<const DefaultExecutor> exec,
-          const matrix::Conv<ValueType>* kernel,
-          const matrix::Dense<ValueType>* b, matrix::Dense<ValueType>* x)
+          const array<ValueType>& kernel, const matrix::Dense<ValueType>* b,
+          matrix::Dense<ValueType>* x)
 {
-    GKO_NOT_IMPLEMENTED;
+    const auto b_size = b->get_size();                 // (N, 1)
+    const auto x_size = x->get_size();                 // (N + K - 1, 1)
+    const auto kernel_size = kernel.get_size();        // K
+    const auto* kernel_ptr = kernel.get_const_data();  // pointer to kernel data
+    int stride = 1;
+    int padding = 2;
+    int output_length = (x_size[0] + 2 * padding - kernel_size) / stride + 1;
+
+    for (gko::size_type i = 0; i < x_size[0]; ++i) {
+        ValueType sum = zero<ValueType>();
+        std::ptrdiff_t start =
+            static_cast<std::ptrdiff_t>(i * stride) - padding;
+        for (gko::size_type j = 0; j < kernel_size; ++j) {
+            std::ptrdiff_t b_idx =
+                start +
+                static_cast<std::ptrdiff_t>(
+                    j);  // calculate the index in b's row based on the current
+                         // position in x and the kernel's stride and padding
+            if (b_idx >= 0 && b_idx < static_cast<std::ptrdiff_t>(b_size[0])) {
+                sum += kernel_ptr[j] * b->at(static_cast<gko::size_type>(b_idx),
+                                             0);  // direct pointer access
+            }
+        }
+        x->at(i, 0) = sum;
+    }
 }
 
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_CONV_KERNEL);