From 323053296ebd2eb9afdf93c9bc2a6d1e8eae3494 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 11:28:51 +0200
Subject: [PATCH 01/18] wip minimal vector interface

---
 include/ginkgo/core/matrix/multivector.hpp | 141 +++++++++++++++++++++
 1 file changed, 141 insertions(+)
 create mode 100644 include/ginkgo/core/matrix/multivector.hpp

diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
new file mode 100644
index 00000000000..0e7b67aa2af
--- /dev/null
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -0,0 +1,141 @@
+// SPDX-FileCopyrightText: 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+#include <variant>
+
+#include <ginkgo/core/base/lin_op.hpp>
+
+
+namespace gko {
+namespace matrix {
+
+struct local_span : span {};
+
+
+class MultiVector : public EnableAbstractPolymorphicObject<MultiVector> {
+public:
+    [[nodiscard]] static std::unique_ptr<MultiVector> create_with_config_of(
+        ptr_param<const MultiVector> other)
+    {
+        return other->create_with_same_config_impl();
+    }
+
+    [[nodiscard]] static std::unique_ptr<MultiVector> create_with_type_of(
+        ptr_param<const MultiVector> other,
+        std::shared_ptr<const Executor> exec, const dim<2>& size,
+        size_type stride)
+    {
+        return other->create_with_type_of_impl(std::move(exec), size, stride);
+    }
+
+    [[nodiscard]] static std::unique_ptr<MultiVector> create_view_of(
+        ptr_param<MultiVector> other)
+    {
+        return other->create_view_of_impl();
+    }
+
+    [[nodiscard]] static std::unique_ptr<const MultiVector>
+    create_const_view_of(ptr_param<const MultiVector> other)
+    {
+        return other->create_const_view_of_impl();
+    }
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_absolute_type()
+        const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> compute_absolute()
+        const = 0;
+
+    virtual void compute_absolute_inplace() = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> make_complex() const = 0;
+
+    virtual void make_complex(ptr_param<MultiVector> result) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_real() const = 0;
+
+    virtual void get_real(ptr_param<MultiVector> result) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_imag() const = 0;
+
+    virtual void get_imag(ptr_param<MultiVector> result) const = 0;
+
+    virtual void scale(ptr_param<const LinOp> alpha) = 0;
+
+    virtual void inv_scale(ptr_param<const LinOp> alpha) = 0;
+
+    virtual void add_scaled(ptr_param<const LinOp> alpha,
+                            ptr_param<const LinOp> b) = 0;
+
+    virtual void sub_scaled(ptr_param<const LinOp> alpha,
+                            ptr_param<const LinOp> b) = 0;
+
+    virtual void compute_dot(ptr_param<const LinOp> b,
+                             ptr_param<LinOp> result) const = 0;
+
+    virtual void compute_dot(ptr_param<const LinOp> b, ptr_param<LinOp> result,
+                             array<char>& tmp) const = 0;
+
+    virtual void compute_conj_dot(ptr_param<const LinOp> b,
+                                  ptr_param<LinOp> result) const = 0;
+
+    virtual void compute_conj_dot(ptr_param<const LinOp> b,
+                                  ptr_param<LinOp> result,
+                                  array<char>& tmp) const = 0;
+
+    virtual void compute_norm2(ptr_param<LinOp> result) const = 0;
+
+    virtual void compute_norm2(ptr_param<LinOp> result,
+                               array<char>& tmp) const = 0;
+
+    virtual void compute_norm1(ptr_param<LinOp> result) const = 0;
+
+    virtual void compute_norm1(ptr_param<LinOp> result,
+                               array<char>& tmp) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<const MultiVector> create_real_view()
+        const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_real_view() = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview(
+        local_span rows, local_span columns);
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview(
+        local_span rows, local_span columns, size_type global_rows,
+        size_type globals_cols);
+
+    [[nodiscard]] dim<2> get_size() const noexcept { return size_; }
+
+protected:
+    explicit MultiVector(std::shared_ptr<const Executor> exec,
+                         const dim<2>& size = dim<2>{})
+        : EnableAbstractPolymorphicObject<MultiVector>(std::move(exec)),
+          size_{size}
+    {}
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector>
+    create_with_same_config_impl() const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_with_type_of_impl(
+        std::shared_ptr<const Executor> exec, const dim<2>& size,
+        size_type stride) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector>
+    create_view_of_impl() = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<const MultiVector>
+    create_const_view_of_impl() const = 0;
+
+    void set_size(const dim<2>& size) noexcept { size_ = size; }
+
+private:
+    dim<2> size_;
+};
+
+
+}  // namespace matrix
+}  // namespace gko

From d2f80c9ada093cdcc168d2902008811535e392c0 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 11:31:56 +0200
Subject: [PATCH 02/18] wip minimal vector interface

---
 include/ginkgo/core/matrix/multivector.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 0e7b67aa2af..a5599d2063e 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -4,18 +4,19 @@
 
 #pragma once
 
-#include <variant>
-
 #include <ginkgo/core/base/lin_op.hpp>
 
 
 namespace gko {
 namespace matrix {
 
+
 struct local_span : span {};
 
 
-class MultiVector : public EnableAbstractPolymorphicObject<MultiVector> {
+template <typename ValueType>
+class MultiVector
+    : public EnableAbstractPolymorphicObject<MultiVector<ValueType>> {
 public:
     [[nodiscard]] static std::unique_ptr<MultiVector> create_with_config_of(
         ptr_param<const MultiVector> other)

From b578f3bf859b86885173e77489b234e5b0d361bc Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 12:05:24 +0200
Subject: [PATCH 03/18] wip minimal vector interface

---
 core/CMakeLists.txt                        |  1 +
 core/matrix/multivector.cpp                | 67 +++++++++++++++
 include/ginkgo/core/matrix/multivector.hpp | 94 +++++++++-------------
 3 files changed, 107 insertions(+), 55 deletions(-)
 create mode 100644 core/matrix/multivector.cpp

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index b7342bb03d8..3a1a6fd7ca7 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -88,6 +88,7 @@ target_sources(
         matrix/fft.cpp
         matrix/hybrid.cpp
         matrix/identity.cpp
+        matrix/multivector.cpp
         matrix/permutation.cpp
         matrix/row_gatherer.cpp
         matrix/scaled_permutation.cpp
diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
new file mode 100644
index 00000000000..7cbf71809be
--- /dev/null
+++ b/core/matrix/multivector.cpp
@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <ginkgo/core/matrix/multivector.hpp>
+
+namespace gko {
+namespace matrix {
+
+
+template <typename ValueType, typename ConcreteType>
+std::unique_ptr<MultiVector<ValueType, ConcreteType>>
+MultiVector<ValueType, ConcreteType>::create_with_config_of(
+    ptr_param<const MultiVector> other)
+{
+    return other->create_with_same_config_impl();
+}
+
+
+template <typename ValueType, typename ConcreteType>
+std::unique_ptr<MultiVector<ValueType, ConcreteType>>
+MultiVector<ValueType, ConcreteType>::create_with_type_of(
+    ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec)
+{
+    return other->create_with_type_of_impl(std::move(exec), {}, {}, 0);
+}
+
+
+template <typename ValueType, typename ConcreteType>
+std::unique_ptr<MultiVector<ValueType, ConcreteType>>
+MultiVector<ValueType, ConcreteType>::create_with_type_of(
+    ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
+    const dim<2>& global_size, const dim<2>& local_size)
+{
+    GKO_ASSERT_EQUAL_COLS(global_size, local_size);
+    return other->create_with_type_of_impl(std::move(exec), global_size,
+                                           local_size, global_size[1]);
+}
+
+
+template <typename ValueType, typename ConcreteType>
+std::unique_ptr<MultiVector<ValueType, ConcreteType>>
+MultiVector<ValueType, ConcreteType>::create_with_type_of(
+    ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
+    const dim<2>& global_size, const dim<2>& local_size, size_type stride)
+{
+    return other->create_with_type_of_impl(std::move(exec), global_size,
+                                           local_size, stride);
+}
+
+
+template <typename ValueType, typename ConcreteType>
+dim<2> MultiVector<ValueType, ConcreteType>::get_size() const noexcept
+{
+    return size_;
+}
+
+
+template <typename ValueType, typename ConcreteType>
+void MultiVector<ValueType, ConcreteType>::set_size(const dim<2>& size) noexcept
+{
+    size_ = size;
+}
+
+
+}  // namespace matrix
+}  // namespace gko
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index a5599d2063e..889d0fb2d0f 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -14,35 +14,25 @@ namespace matrix {
 struct local_span : span {};
 
 
-template <typename ValueType>
-class MultiVector
-    : public EnableAbstractPolymorphicObject<MultiVector<ValueType>> {
+template <typename ValueType, typename ConcreteType>
+class MultiVector : public EnableLinOp<ConcreteType> {
 public:
     [[nodiscard]] static std::unique_ptr<MultiVector> create_with_config_of(
-        ptr_param<const MultiVector> other)
-    {
-        return other->create_with_same_config_impl();
-    }
+        ptr_param<const MultiVector> other);
 
     [[nodiscard]] static std::unique_ptr<MultiVector> create_with_type_of(
         ptr_param<const MultiVector> other,
-        std::shared_ptr<const Executor> exec, const dim<2>& size,
-        size_type stride)
-    {
-        return other->create_with_type_of_impl(std::move(exec), size, stride);
-    }
-
-    [[nodiscard]] static std::unique_ptr<MultiVector> create_view_of(
-        ptr_param<MultiVector> other)
-    {
-        return other->create_view_of_impl();
-    }
-
-    [[nodiscard]] static std::unique_ptr<const MultiVector>
-    create_const_view_of(ptr_param<const MultiVector> other)
-    {
-        return other->create_const_view_of_impl();
-    }
+        std::shared_ptr<const Executor> exec);
+
+    [[nodiscard]] static std::unique_ptr<MultiVector> create_with_type_of(
+        ptr_param<const MultiVector> other,
+        std::shared_ptr<const Executor> exec, const dim<2>& global_size,
+        const dim<2>& local_size);
+
+    [[nodiscard]] static std::unique_ptr<MultiVector> create_with_type_of(
+        ptr_param<const MultiVector> other,
+        std::shared_ptr<const Executor> exec, const dim<2>& global_size,
+        const dim<2>& local_size, size_type stride);
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector> create_absolute_type()
         const = 0;
@@ -64,37 +54,38 @@ class MultiVector
 
     virtual void get_imag(ptr_param<MultiVector> result) const = 0;
 
-    virtual void scale(ptr_param<const LinOp> alpha) = 0;
+    virtual void scale(ptr_param<const MultiVector> alpha) = 0;
 
-    virtual void inv_scale(ptr_param<const LinOp> alpha) = 0;
+    virtual void inv_scale(ptr_param<const MultiVector> alpha) = 0;
 
-    virtual void add_scaled(ptr_param<const LinOp> alpha,
-                            ptr_param<const LinOp> b) = 0;
+    virtual void add_scaled(ptr_param<const MultiVector> alpha,
+                            ptr_param<const MultiVector> b) = 0;
 
-    virtual void sub_scaled(ptr_param<const LinOp> alpha,
-                            ptr_param<const LinOp> b) = 0;
+    virtual void sub_scaled(ptr_param<const MultiVector> alpha,
+                            ptr_param<const MultiVector> b) = 0;
 
-    virtual void compute_dot(ptr_param<const LinOp> b,
-                             ptr_param<LinOp> result) const = 0;
+    virtual void compute_dot(ptr_param<const MultiVector> b,
+                             ptr_param<MultiVector> result) const = 0;
 
-    virtual void compute_dot(ptr_param<const LinOp> b, ptr_param<LinOp> result,
+    virtual void compute_dot(ptr_param<const MultiVector> b,
+                             ptr_param<MultiVector> result,
                              array<char>& tmp) const = 0;
 
-    virtual void compute_conj_dot(ptr_param<const LinOp> b,
-                                  ptr_param<LinOp> result) const = 0;
+    virtual void compute_conj_dot(ptr_param<const MultiVector> b,
+                                  ptr_param<MultiVector> result) const = 0;
 
-    virtual void compute_conj_dot(ptr_param<const LinOp> b,
-                                  ptr_param<LinOp> result,
+    virtual void compute_conj_dot(ptr_param<const MultiVector> b,
+                                  ptr_param<MultiVector> result,
                                   array<char>& tmp) const = 0;
 
-    virtual void compute_norm2(ptr_param<LinOp> result) const = 0;
+    virtual void compute_norm2(ptr_param<MultiVector> result) const = 0;
 
-    virtual void compute_norm2(ptr_param<LinOp> result,
+    virtual void compute_norm2(ptr_param<MultiVector> result,
                                array<char>& tmp) const = 0;
 
-    virtual void compute_norm1(ptr_param<LinOp> result) const = 0;
+    virtual void compute_norm1(ptr_param<MultiVector> result) const = 0;
 
-    virtual void compute_norm1(ptr_param<LinOp> result,
+    virtual void compute_norm1(ptr_param<MultiVector> result,
                                array<char>& tmp) const = 0;
 
     [[nodiscard]] virtual std::unique_ptr<const MultiVector> create_real_view()
@@ -103,35 +94,28 @@ class MultiVector
     [[nodiscard]] virtual std::unique_ptr<MultiVector> create_real_view() = 0;
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview(
-        local_span rows, local_span columns);
+        local_span rows, local_span columns) = 0;
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview(
         local_span rows, local_span columns, size_type global_rows,
-        size_type globals_cols);
+        size_type globals_cols) = 0;
 
-    [[nodiscard]] dim<2> get_size() const noexcept { return size_; }
+    [[nodiscard]] dim<2> get_size() const noexcept;
 
 protected:
     explicit MultiVector(std::shared_ptr<const Executor> exec,
                          const dim<2>& size = dim<2>{})
-        : EnableAbstractPolymorphicObject<MultiVector>(std::move(exec)),
-          size_{size}
+        : EnableLinOp<MultiVector>(std::move(exec)), size_{size}
     {}
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector>
     create_with_same_config_impl() const = 0;
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector> create_with_type_of_impl(
-        std::shared_ptr<const Executor> exec, const dim<2>& size,
-        size_type stride) const = 0;
-
-    [[nodiscard]] virtual std::unique_ptr<MultiVector>
-    create_view_of_impl() = 0;
-
-    [[nodiscard]] virtual std::unique_ptr<const MultiVector>
-    create_const_view_of_impl() const = 0;
+        std::shared_ptr<const Executor> exec, const dim<2>& global_size,
+        const dim<2>& local_size, size_type stride) const = 0;
 
-    void set_size(const dim<2>& size) noexcept { size_ = size; }
+    void set_size(const dim<2>& size) noexcept;
 
 private:
     dim<2> size_;

From 96d13b338ab66d0f958b3098016fb40a1c46339b Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 13:04:46 +0200
Subject: [PATCH 04/18] wip minimal vector interface

---
 core/matrix/multivector.cpp                | 36 ++++++++--------
 include/ginkgo/core/matrix/multivector.hpp | 49 ++++++++++++----------
 2 files changed, 45 insertions(+), 40 deletions(-)

diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
index 7cbf71809be..8d4996963ba 100644
--- a/core/matrix/multivector.cpp
+++ b/core/matrix/multivector.cpp
@@ -8,27 +8,27 @@ namespace gko {
 namespace matrix {
 
 
-template <typename ValueType, typename ConcreteType>
-std::unique_ptr<MultiVector<ValueType, ConcreteType>>
-MultiVector<ValueType, ConcreteType>::create_with_config_of(
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>>
+MultiVector<ValueType>::create_with_config_of(
     ptr_param<const MultiVector> other)
 {
     return other->create_with_same_config_impl();
 }
 
 
-template <typename ValueType, typename ConcreteType>
-std::unique_ptr<MultiVector<ValueType, ConcreteType>>
-MultiVector<ValueType, ConcreteType>::create_with_type_of(
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>>
+MultiVector<ValueType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec)
 {
     return other->create_with_type_of_impl(std::move(exec), {}, {}, 0);
 }
 
 
-template <typename ValueType, typename ConcreteType>
-std::unique_ptr<MultiVector<ValueType, ConcreteType>>
-MultiVector<ValueType, ConcreteType>::create_with_type_of(
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>>
+MultiVector<ValueType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size)
 {
@@ -38,9 +38,9 @@ MultiVector<ValueType, ConcreteType>::create_with_type_of(
 }
 
 
-template <typename ValueType, typename ConcreteType>
-std::unique_ptr<MultiVector<ValueType, ConcreteType>>
-MultiVector<ValueType, ConcreteType>::create_with_type_of(
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>>
+MultiVector<ValueType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size, size_type stride)
 {
@@ -49,17 +49,17 @@ MultiVector<ValueType, ConcreteType>::create_with_type_of(
 }
 
 
-template <typename ValueType, typename ConcreteType>
-dim<2> MultiVector<ValueType, ConcreteType>::get_size() const noexcept
+template <typename ValueType>
+dim<2> MultiVector<ValueType>::get_size() const noexcept
 {
-    return size_;
+    return LinOp::get_size();
 }
 
 
-template <typename ValueType, typename ConcreteType>
-void MultiVector<ValueType, ConcreteType>::set_size(const dim<2>& size) noexcept
+template <typename ValueType>
+void MultiVector<ValueType>::set_size(const dim<2>& size) noexcept
 {
-    size_ = size;
+    LinOp::set_size(size);
 }
 
 
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 889d0fb2d0f..44ce53bc03d 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -14,9 +14,14 @@ namespace matrix {
 struct local_span : span {};
 
 
-template <typename ValueType, typename ConcreteType>
-class MultiVector : public EnableLinOp<ConcreteType> {
+template <typename ValueType = default_precision>
+class MultiVector : public EnableLinOp<MultiVector<ValueType>> {
 public:
+    using value_type = ValueType;
+    using absolute_type = remove_complex<MultiVector>;
+    using real_type = absolute_type;
+    using complex_type = to_complex<MultiVector>;
+
     [[nodiscard]] static std::unique_ptr<MultiVector> create_with_config_of(
         ptr_param<const MultiVector> other);
 
@@ -34,25 +39,23 @@ class MultiVector : public EnableLinOp<ConcreteType> {
         std::shared_ptr<const Executor> exec, const dim<2>& global_size,
         const dim<2>& local_size, size_type stride);
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_absolute_type()
-        const = 0;
-
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> compute_absolute()
+    [[nodiscard]] virtual std::unique_ptr<absolute_type> compute_absolute()
         const = 0;
 
     virtual void compute_absolute_inplace() = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> make_complex() const = 0;
+    [[nodiscard]] virtual std::unique_ptr<complex_type> make_complex()
+        const = 0;
 
-    virtual void make_complex(ptr_param<MultiVector> result) const = 0;
+    virtual void make_complex(ptr_param<complex_type> result) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_real() const = 0;
+    [[nodiscard]] virtual std::unique_ptr<real_type> get_real() const = 0;
 
-    virtual void get_real(ptr_param<MultiVector> result) const = 0;
+    virtual void get_real(ptr_param<real_type> result) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_imag() const = 0;
+    [[nodiscard]] virtual std::unique_ptr<real_type> get_imag() const = 0;
 
-    virtual void get_imag(ptr_param<MultiVector> result) const = 0;
+    virtual void get_imag(ptr_param<real_type> result) const = 0;
 
     virtual void scale(ptr_param<const MultiVector> alpha) = 0;
 
@@ -78,20 +81,20 @@ class MultiVector : public EnableLinOp<ConcreteType> {
                                   ptr_param<MultiVector> result,
                                   array<char>& tmp) const = 0;
 
-    virtual void compute_norm2(ptr_param<MultiVector> result) const = 0;
+    virtual void compute_norm2(ptr_param<absolute_type> result) const = 0;
 
-    virtual void compute_norm2(ptr_param<MultiVector> result,
+    virtual void compute_norm2(ptr_param<absolute_type> result,
                                array<char>& tmp) const = 0;
 
-    virtual void compute_norm1(ptr_param<MultiVector> result) const = 0;
+    virtual void compute_norm1(ptr_param<absolute_type> result) const = 0;
 
-    virtual void compute_norm1(ptr_param<MultiVector> result,
+    virtual void compute_norm1(ptr_param<absolute_type> result,
                                array<char>& tmp) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<const MultiVector> create_real_view()
+    [[nodiscard]] virtual std::unique_ptr<const real_type> create_real_view()
         const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_real_view() = 0;
+    [[nodiscard]] virtual std::unique_ptr<real_type> create_real_view() = 0;
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview(
         local_span rows, local_span columns) = 0;
@@ -105,7 +108,7 @@ class MultiVector : public EnableLinOp<ConcreteType> {
 protected:
     explicit MultiVector(std::shared_ptr<const Executor> exec,
                          const dim<2>& size = dim<2>{})
-        : EnableLinOp<MultiVector>(std::move(exec)), size_{size}
+        : EnableLinOp<MultiVector>(std::move(exec), size)
     {}
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector>
@@ -115,10 +118,12 @@ class MultiVector : public EnableLinOp<ConcreteType> {
         std::shared_ptr<const Executor> exec, const dim<2>& global_size,
         const dim<2>& local_size, size_type stride) const = 0;
 
-    void set_size(const dim<2>& size) noexcept;
+    void apply_impl(const LinOp* b, LinOp* x) const override {}
+    void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
+                    LinOp* x) const override
+    {}
 
-private:
-    dim<2> size_;
+    void set_size(const dim<2>& size) noexcept;
 };
 
 

From 57a297a1cb48478677658d44aef03e3707055d3a Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 14:41:06 +0200
Subject: [PATCH 05/18] wip minimal vector interface

---
 core/matrix/multivector.cpp                | 32 +++++++++++-----------
 include/ginkgo/core/matrix/multivector.hpp | 12 ++++----
 2 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
index 8d4996963ba..98fd6b6793e 100644
--- a/core/matrix/multivector.cpp
+++ b/core/matrix/multivector.cpp
@@ -8,27 +8,27 @@ namespace gko {
 namespace matrix {
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>>
-MultiVector<ValueType>::create_with_config_of(
+template <typename ValueType, typename ConcreteType>
+std::unique_ptr<MultiVector<ValueType, ConcreteType>>
+MultiVector<ValueType, ConcreteType>::create_with_config_of(
     ptr_param<const MultiVector> other)
 {
     return other->create_with_same_config_impl();
 }
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>>
-MultiVector<ValueType>::create_with_type_of(
+template <typename ValueType, typename ConcreteType>
+std::unique_ptr<MultiVector<ValueType, ConcreteType>>
+MultiVector<ValueType, ConcreteType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec)
 {
     return other->create_with_type_of_impl(std::move(exec), {}, {}, 0);
 }
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>>
-MultiVector<ValueType>::create_with_type_of(
+template <typename ValueType, typename ConcreteType>
+std::unique_ptr<MultiVector<ValueType, ConcreteType>>
+MultiVector<ValueType, ConcreteType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size)
 {
@@ -38,9 +38,9 @@ MultiVector<ValueType>::create_with_type_of(
 }
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>>
-MultiVector<ValueType>::create_with_type_of(
+template <typename ValueType, typename ConcreteType>
+std::unique_ptr<MultiVector<ValueType, ConcreteType>>
+MultiVector<ValueType, ConcreteType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size, size_type stride)
 {
@@ -49,15 +49,15 @@ MultiVector<ValueType>::create_with_type_of(
 }
 
 
-template <typename ValueType>
-dim<2> MultiVector<ValueType>::get_size() const noexcept
+template <typename ValueType, typename ConcreteType>
+dim<2> MultiVector<ValueType, ConcreteType>::get_size() const noexcept
 {
     return LinOp::get_size();
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::set_size(const dim<2>& size) noexcept
+template <typename ValueType, typename ConcreteType>
+void MultiVector<ValueType, ConcreteType>::set_size(const dim<2>& size) noexcept
 {
     LinOp::set_size(size);
 }
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 44ce53bc03d..609b022523c 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -13,14 +13,16 @@ namespace matrix {
 
 struct local_span : span {};
 
-
-template <typename ValueType = default_precision>
-class MultiVector : public EnableLinOp<MultiVector<ValueType>> {
+// @todo: remove ConcreteType
+template <typename ValueType, typename ConcreteType>
+class MultiVector : public EnableLinOp<ConcreteType> {
 public:
     using value_type = ValueType;
-    using absolute_type = remove_complex<MultiVector>;
+    using absolute_type =
+        MultiVector<remove_complex<ValueType>, remove_complex<ConcreteType>>;
     using real_type = absolute_type;
-    using complex_type = to_complex<MultiVector>;
+    using complex_type =
+        MultiVector<to_complex<ValueType>, to_complex<ConcreteType>>;
 
     [[nodiscard]] static std::unique_ptr<MultiVector> create_with_config_of(
         ptr_param<const MultiVector> other);

From 84df76f9683131b513cb2b90057ee077297a87ed Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 14:55:12 +0200
Subject: [PATCH 06/18] remove concrete type

---
 core/matrix/multivector.cpp                | 32 +++++++++++-----------
 include/ginkgo/core/matrix/multivector.hpp | 12 ++++----
 2 files changed, 21 insertions(+), 23 deletions(-)

diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
index 98fd6b6793e..8d4996963ba 100644
--- a/core/matrix/multivector.cpp
+++ b/core/matrix/multivector.cpp
@@ -8,27 +8,27 @@ namespace gko {
 namespace matrix {
 
 
-template <typename ValueType, typename ConcreteType>
-std::unique_ptr<MultiVector<ValueType, ConcreteType>>
-MultiVector<ValueType, ConcreteType>::create_with_config_of(
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>>
+MultiVector<ValueType>::create_with_config_of(
     ptr_param<const MultiVector> other)
 {
     return other->create_with_same_config_impl();
 }
 
 
-template <typename ValueType, typename ConcreteType>
-std::unique_ptr<MultiVector<ValueType, ConcreteType>>
-MultiVector<ValueType, ConcreteType>::create_with_type_of(
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>>
+MultiVector<ValueType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec)
 {
     return other->create_with_type_of_impl(std::move(exec), {}, {}, 0);
 }
 
 
-template <typename ValueType, typename ConcreteType>
-std::unique_ptr<MultiVector<ValueType, ConcreteType>>
-MultiVector<ValueType, ConcreteType>::create_with_type_of(
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>>
+MultiVector<ValueType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size)
 {
@@ -38,9 +38,9 @@ MultiVector<ValueType, ConcreteType>::create_with_type_of(
 }
 
 
-template <typename ValueType, typename ConcreteType>
-std::unique_ptr<MultiVector<ValueType, ConcreteType>>
-MultiVector<ValueType, ConcreteType>::create_with_type_of(
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>>
+MultiVector<ValueType>::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size, size_type stride)
 {
@@ -49,15 +49,15 @@ MultiVector<ValueType, ConcreteType>::create_with_type_of(
 }
 
 
-template <typename ValueType, typename ConcreteType>
-dim<2> MultiVector<ValueType, ConcreteType>::get_size() const noexcept
+template <typename ValueType>
+dim<2> MultiVector<ValueType>::get_size() const noexcept
 {
     return LinOp::get_size();
 }
 
 
-template <typename ValueType, typename ConcreteType>
-void MultiVector<ValueType, ConcreteType>::set_size(const dim<2>& size) noexcept
+template <typename ValueType>
+void MultiVector<ValueType>::set_size(const dim<2>& size) noexcept
 {
     LinOp::set_size(size);
 }
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 609b022523c..70b71a7f6cb 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -13,16 +13,14 @@ namespace matrix {
 
 struct local_span : span {};
 
-// @todo: remove ConcreteType
-template <typename ValueType, typename ConcreteType>
-class MultiVector : public EnableLinOp<ConcreteType> {
+template <typename ValueType>
+class MultiVector
+    : public EnableAbstractPolymorphicObject<MultiVector<ValueType>> {
 public:
     using value_type = ValueType;
-    using absolute_type =
-        MultiVector<remove_complex<ValueType>, remove_complex<ConcreteType>>;
+    using absolute_type = MultiVector<remove_complex<ValueType>>;
     using real_type = absolute_type;
-    using complex_type =
-        MultiVector<to_complex<ValueType>, to_complex<ConcreteType>>;
+    using complex_type = MultiVector<to_complex<ValueType>>;
 
     [[nodiscard]] static std::unique_ptr<MultiVector> create_with_config_of(
         ptr_param<const MultiVector> other);

From 5f49c0e11054204e7599480ad061f2d7869d0079 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 17:12:41 +0200
Subject: [PATCH 07/18] meta programming helpers

---
 .../ginkgo/core/synthesizer/containers.hpp    | 43 ++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

diff --git a/include/ginkgo/core/synthesizer/containers.hpp b/include/ginkgo/core/synthesizer/containers.hpp
index 27cdf027804..b89068ac9a6 100644
--- a/include/ginkgo/core/synthesizer/containers.hpp
+++ b/include/ginkgo/core/synthesizer/containers.hpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -8,6 +8,7 @@
 
 #include <array>
 #include <type_traits>
+#include <variant>
 
 
 namespace gko {
@@ -177,6 +178,46 @@ constexpr std::array<T, sizeof...(Value)> as_array(value_list<T, Value...> vl)
     return std::array<T, sizeof...(Value)>{Value...};
 }
 
+namespace detail {
+
+template <template <typename> typename T, typename InputList,
+          typename ResultList = std::tuple<>>
+struct apply_to_list_impl;
+
+template <template <typename> typename T, typename ResultList>
+struct apply_to_list_impl<T, std::tuple<>, ResultList> {
+    using type = ResultList;
+};
+
+template <template <typename> typename T, typename U, typename... InputTypes,
+          typename... ResultTypes>
+struct apply_to_list_impl<T, std::tuple<U, InputTypes...>,
+                          std::tuple<ResultTypes...>> {
+    using type =
+        typename apply_to_list_impl<T, std::tuple<InputTypes...>,
+                                    std::tuple<ResultTypes..., T<U>>>::type;
+};
+
+}  // namespace detail
+
+
+template <template <typename> typename T, typename TupleList>
+using apply_to_list = detail::apply_to_list_impl<T, TupleList>::type;
+
+namespace detail {
+
+template <typename Tuple>
+struct variant_from_tuple_impl;
+
+template <typename... Types>
+struct variant_from_tuple_impl<std::tuple<Types...>> {
+    using type = std::variant<Types...>;
+};
+
+}  // namespace detail
+
+template <typename Tuple>
+using variant_from_tuple = detail::variant_from_tuple_impl<Tuple>::type;
 
 }  // namespace syn
 }  // namespace gko

From eef57129c7aad3755d3deaea605ed117a4002ad2 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 17:13:14 +0200
Subject: [PATCH 08/18] add dense variant

---
 include/ginkgo/core/matrix/multivector.hpp | 25 ++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 70b71a7f6cb..0a695ee0759 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -4,13 +4,38 @@
 
 #pragma once
 
+#include <ginkgo/config.hpp>
 #include <ginkgo/core/base/lin_op.hpp>
 
 
 namespace gko {
 namespace matrix {
 
+template <typename ValueType>
+class Dense;
+
+
+using supported_value_types =
+    std::tuple<double, float, std::complex<double>, std::complex<float>
+#if GINKGO_ENABLE_HALF
+               ,
+               half, std::complex<half>
+#endif
+#if GINKGO_ENABLE_BFLOAT16
+               ,
+               bfloat16, std::complex<bfloat16>
+#endif
+               >;
+
+using dense_types = syn::apply_to_list<Dense, supported_value_types>;
+
+using any_const_dense_t = syn::variant_from_tuple<syn::apply_to_list<
+    ptr_param, syn::apply_to_list<std::add_const_t, dense_types>>>;
+using any_dense_type =
+    syn::variant_from_tuple<syn::apply_to_list<ptr_param, dense_types>>;
+
 
+// Different type to clarify that only local rows/columns are meant
 struct local_span : span {};
 
 template <typename ValueType>

From 512d938893231d85f0623b4282edf76b6f913945 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 17:14:16 +0200
Subject: [PATCH 09/18] make public function non-virtual

---
 core/matrix/multivector.cpp                | 211 +++++++++++++++++++++
 include/ginkgo/core/matrix/multivector.hpp | 151 ++++++++++-----
 2 files changed, 318 insertions(+), 44 deletions(-)

diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
index 8d4996963ba..5ecdedaca4e 100644
--- a/core/matrix/multivector.cpp
+++ b/core/matrix/multivector.cpp
@@ -49,6 +49,217 @@ MultiVector<ValueType>::create_with_type_of(
 }
 
 
+template <typename ValueType>
+std::unique_ptr<typename MultiVector<ValueType>::absolute_type>
+MultiVector<ValueType>::compute_absolute() const
+{
+    return this->compute_absolute_impl();
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_absolute_inplace()
+{
+    this->compute_absolute_inplace_impl();
+}
+
+
+template <typename ValueType>
+std::unique_ptr<typename MultiVector<ValueType>::complex_type>
+MultiVector<ValueType>::make_complex() const
+{
+    return this->make_complex_impl();
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::make_complex(ptr_param<complex_type> result) const
+{
+    this->make_complex_impl(result.get());
+}
+
+
+template <typename ValueType>
+std::unique_ptr<typename MultiVector<ValueType>::real_type>
+MultiVector<ValueType>::get_real() const
+{
+    return this->get_real_impl();
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::get_real(ptr_param<real_type> result) const
+{
+    this->get_real_impl(result.get());
+}
+
+
+template <typename ValueType>
+std::unique_ptr<typename MultiVector<ValueType>::real_type>
+MultiVector<ValueType>::get_imag() const
+{
+    return this->get_imag_impl();
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::get_imag(ptr_param<real_type> result) const
+{
+    this->get_imag_impl(result.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::fill(ValueType value)
+{
+    this->fill_impl(value.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::scale(any_const_dense_t alpha)
+{
+    this->scale_impl(alpha);
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::inv_scale(any_const_dense_t alpha)
+{
+    this->inv_scale_impl(alpha);
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::add_scaled(any_const_dense_t alpha,
+                                        ptr_param<const MultiVector> b)
+{
+    this->add_scaled_impl(alpha, b.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::sub_scaled(any_const_dense_t alpha,
+                                        ptr_param<const MultiVector> b)
+{
+    this->sub_scaled_impl(alpha, b.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_dot(ptr_param<const MultiVector> b,
+                                         ptr_param<MultiVector> result) const
+{
+    this->compute_dot_impl(b.get(), result.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_dot(ptr_param<const MultiVector> b,
+                                         ptr_param<MultiVector> result,
+                                         array<char>& tmp) const
+{
+    this->compute_dot_impl(b.get(), result.get(), tmp);
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_conj_dot(
+    ptr_param<const MultiVector> b, ptr_param<MultiVector> result) const
+{
+    this->compute_conj_dot_impl(b.get(), result.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_conj_dot(ptr_param<const MultiVector> b,
+                                              ptr_param<MultiVector> result,
+                                              array<char>& tmp) const
+{
+    this->compute_conj_dot_impl(b.get(), result.get(), tmp);
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_norm2(
+    ptr_param<absolute_type> result) const
+{
+    this->compute_norm2_impl(result.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_norm2(ptr_param<absolute_type> result,
+                                           array<char>& tmp) const
+{
+    this->compute_norm2_impl(result.get(), tmp);
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_squared_norm2(
+    ptr_param<absolute_type> result) const
+{
+    this->compute_squared_norm2_impl(result.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_squared_norm2(
+    ptr_param<absolute_type> result, array<char>& tmp) const
+{
+    this->compute_squared_norm2_impl(result.get(), tmp);
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_norm1(
+    ptr_param<absolute_type> result) const
+{
+    this->compute_norm1_impl(result.get());
+}
+
+
+template <typename ValueType>
+void MultiVector<ValueType>::compute_norm1(ptr_param<absolute_type> result,
+                                           array<char>& tmp) const
+{
+    this->compute_norm1_impl(result.get(), tmp);
+}
+
+
+template <typename ValueType>
+std::unique_ptr<const typename MultiVector<ValueType>::real_type>
+MultiVector<ValueType>::create_real_view() const
+{
+    return this->create_real_view_impl();
+}
+
+
+template <typename ValueType>
+std::unique_ptr<typename MultiVector<ValueType>::real_type>
+MultiVector<ValueType>::create_real_view()
+{
+    return this->create_real_view_impl();
+}
+
+
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>> MultiVector<ValueType>::create_subview(
+    local_span rows, local_span columns)
+{
+    return this->create_subview_impl(rows, columns);
+}
+
+
+template <typename ValueType>
+std::unique_ptr<MultiVector<ValueType>> MultiVector<ValueType>::create_subview(
+    local_span rows, local_span columns, size_type global_rows,
+    size_type globals_cols)
+{
+    return this->create_subview_impl(rows, columns, global_rows, globals_cols);
+}
+
 template <typename ValueType>
 dim<2> MultiVector<ValueType>::get_size() const noexcept
 {
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 0a695ee0759..c70107038b8 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -40,7 +40,7 @@ struct local_span : span {};
 
 template <typename ValueType>
 class MultiVector
-    : public EnableAbstractPolymorphicObject<MultiVector<ValueType>> {
+    : public EnableAbstractPolymorphicObject<MultiVector<ValueType>, LinOp> {
 public:
     using value_type = ValueType;
     using absolute_type = MultiVector<remove_complex<ValueType>>;
@@ -64,69 +64,68 @@ class MultiVector
         std::shared_ptr<const Executor> exec, const dim<2>& global_size,
         const dim<2>& local_size, size_type stride);
 
-    [[nodiscard]] virtual std::unique_ptr<absolute_type> compute_absolute()
-        const = 0;
+    [[nodiscard]] std::unique_ptr<absolute_type> compute_absolute() const;
 
-    virtual void compute_absolute_inplace() = 0;
+    void compute_absolute_inplace();
 
-    [[nodiscard]] virtual std::unique_ptr<complex_type> make_complex()
-        const = 0;
+    [[nodiscard]] std::unique_ptr<complex_type> make_complex() const;
 
-    virtual void make_complex(ptr_param<complex_type> result) const = 0;
+    void make_complex(ptr_param<complex_type> result) const;
 
-    [[nodiscard]] virtual std::unique_ptr<real_type> get_real() const = 0;
+    [[nodiscard]] std::unique_ptr<real_type> get_real() const;
 
-    virtual void get_real(ptr_param<real_type> result) const = 0;
+    void get_real(ptr_param<real_type> result) const;
 
-    [[nodiscard]] virtual std::unique_ptr<real_type> get_imag() const = 0;
+    [[nodiscard]] std::unique_ptr<real_type> get_imag() const;
 
-    virtual void get_imag(ptr_param<real_type> result) const = 0;
+    void get_imag(ptr_param<real_type> result) const;
 
-    virtual void scale(ptr_param<const MultiVector> alpha) = 0;
+    void fill(ValueType value);
 
-    virtual void inv_scale(ptr_param<const MultiVector> alpha) = 0;
+    void scale(any_const_dense_t alpha);
 
-    virtual void add_scaled(ptr_param<const MultiVector> alpha,
-                            ptr_param<const MultiVector> b) = 0;
+    void inv_scale(any_const_dense_t alpha);
 
-    virtual void sub_scaled(ptr_param<const MultiVector> alpha,
-                            ptr_param<const MultiVector> b) = 0;
+    void add_scaled(any_const_dense_t alpha, ptr_param<const MultiVector> b);
 
-    virtual void compute_dot(ptr_param<const MultiVector> b,
-                             ptr_param<MultiVector> result) const = 0;
+    void sub_scaled(any_const_dense_t alpha, ptr_param<const MultiVector> b);
 
-    virtual void compute_dot(ptr_param<const MultiVector> b,
-                             ptr_param<MultiVector> result,
-                             array<char>& tmp) const = 0;
+    void compute_dot(ptr_param<const MultiVector> b,
+                     ptr_param<MultiVector> result) const;
 
-    virtual void compute_conj_dot(ptr_param<const MultiVector> b,
-                                  ptr_param<MultiVector> result) const = 0;
+    void compute_dot(ptr_param<const MultiVector> b,
+                     ptr_param<MultiVector> result, array<char>& tmp) const;
 
-    virtual void compute_conj_dot(ptr_param<const MultiVector> b,
-                                  ptr_param<MultiVector> result,
-                                  array<char>& tmp) const = 0;
+    void compute_conj_dot(ptr_param<const MultiVector> b,
+                          ptr_param<MultiVector> result) const;
 
-    virtual void compute_norm2(ptr_param<absolute_type> result) const = 0;
+    void compute_conj_dot(ptr_param<const MultiVector> b,
+                          ptr_param<MultiVector> result,
+                          array<char>& tmp) const;
 
-    virtual void compute_norm2(ptr_param<absolute_type> result,
-                               array<char>& tmp) const = 0;
+    void compute_norm2(ptr_param<absolute_type> result) const;
 
-    virtual void compute_norm1(ptr_param<absolute_type> result) const = 0;
+    void compute_norm2(ptr_param<absolute_type> result, array<char>& tmp) const;
 
-    virtual void compute_norm1(ptr_param<absolute_type> result,
-                               array<char>& tmp) const = 0;
+    void compute_squared_norm2(ptr_param<absolute_type> result) const;
 
-    [[nodiscard]] virtual std::unique_ptr<const real_type> create_real_view()
-        const = 0;
+    void compute_squared_norm2(ptr_param<absolute_type> result,
+                               array<char>& tmp) const;
 
-    [[nodiscard]] virtual std::unique_ptr<real_type> create_real_view() = 0;
+    void compute_norm1(ptr_param<absolute_type> result) const;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview(
-        local_span rows, local_span columns) = 0;
+    void compute_norm1(ptr_param<absolute_type> result, array<char>& tmp) const;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview(
+    [[nodiscard]] std::unique_ptr<const real_type> create_real_view() const;
+
+    [[nodiscard]] std::unique_ptr<real_type> create_real_view();
+
+    [[nodiscard]] std::unique_ptr<MultiVector> create_subview(
+        local_span rows, local_span columns);
+
+    [[nodiscard]] std::unique_ptr<MultiVector> create_subview(
         local_span rows, local_span columns, size_type global_rows,
-        size_type globals_cols) = 0;
+        size_type globals_cols);
 
     [[nodiscard]] dim<2> get_size() const noexcept;
 
@@ -143,10 +142,74 @@ class MultiVector
         std::shared_ptr<const Executor> exec, const dim<2>& global_size,
         const dim<2>& local_size, size_type stride) const = 0;
 
-    void apply_impl(const LinOp* b, LinOp* x) const override {}
-    void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
-                    LinOp* x) const override
-    {}
+    virtual void compute_absolute_inplace_impl() = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<complex_type> make_complex_impl()
+        const = 0;
+
+    virtual void make_complex_impl(complex_type* result) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<real_type> get_real_impl() const = 0;
+
+    virtual void get_real_impl(real_type* result) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<real_type> get_imag_impl() const = 0;
+
+    virtual void get_imag_impl(real_type* result) const = 0;
+
+    virtual void fill_impl(ValueType value) = 0;
+
+    // @todo: need to fix alpha to a our dense type
+    virtual void scale_impl(any_const_dense_t alpha) = 0;
+
+    virtual void inv_scale_impl(any_const_dense_t alpha) = 0;
+
+    virtual void add_scaled_impl(any_const_dense_t alpha,
+                                 const MultiVector* b) = 0;
+
+    virtual void sub_scaled_impl(any_const_dense_t alpha,
+                                 const MultiVector* b) = 0;
+
+    virtual void compute_dot_impl(const MultiVector* b,
+                                  MultiVector* result) const = 0;
+
+    virtual void compute_dot_impl(const MultiVector* b, MultiVector* result,
+                                  array<char>& tmp) const = 0;
+
+    virtual void compute_conj_dot_impl(const MultiVector* b,
+                                       MultiVector* result) const = 0;
+
+    virtual void compute_conj_dot_impl(const MultiVector* b,
+                                       MultiVector* result,
+                                       array<char>& tmp) const = 0;
+
+    virtual void compute_norm2_impl(absolute_type* result) const = 0;
+
+    virtual void compute_norm2_impl(absolute_type* result,
+                                    array<char>& tmp) const = 0;
+
+    virtual void compute_squared_norm2_impl(absolute_type* result) const = 0;
+
+    virtual void compute_squared_norm2_impl(absolute_type* result,
+                                            array<char>& tmp) const = 0;
+
+    virtual void compute_norm1_impl(absolute_type* result) const = 0;
+
+    virtual void compute_norm1_impl(absolute_type* result,
+                                    array<char>& tmp) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<const real_type>
+    create_real_view_impl() const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<real_type>
+    create_real_view_impl() = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview_impl(
+        local_span rows, local_span columns) = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview_impl(
+        local_span rows, local_span columns, size_type global_rows,
+        size_type globals_cols) = 0;
 
     void set_size(const dim<2>& size) noexcept;
 };

From 2bb46ca0b420a61b0738ec31a9c7a1af242a055c Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 17:23:59 +0200
Subject: [PATCH 10/18] remove value template parameter

---
 core/matrix/multivector.cpp                | 156 ++++++++-------------
 include/ginkgo/core/matrix/multivector.hpp |  82 ++++++-----
 2 files changed, 96 insertions(+), 142 deletions(-)

diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
index 5ecdedaca4e..e82416c0333 100644
--- a/core/matrix/multivector.cpp
+++ b/core/matrix/multivector.cpp
@@ -8,27 +8,27 @@ namespace gko {
 namespace matrix {
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>>
-MultiVector<ValueType>::create_with_config_of(
+MultiVector::MultiVector(std::shared_ptr<const Executor> exec,
+                         const dim<2>& size)
+    : EnableAbstractPolymorphicObject<MultiVector, LinOp>(std::move(exec), size)
+{}
+
+
+std::unique_ptr<MultiVector> MultiVector::create_with_config_of(
     ptr_param<const MultiVector> other)
 {
     return other->create_with_same_config_impl();
 }
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>>
-MultiVector<ValueType>::create_with_type_of(
+std::unique_ptr<MultiVector> MultiVector::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec)
 {
     return other->create_with_type_of_impl(std::move(exec), {}, {}, 0);
 }
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>>
-MultiVector<ValueType>::create_with_type_of(
+std::unique_ptr<MultiVector> MultiVector::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size)
 {
@@ -38,9 +38,7 @@ MultiVector<ValueType>::create_with_type_of(
 }
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>>
-MultiVector<ValueType>::create_with_type_of(
+std::unique_ptr<MultiVector> MultiVector::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size, size_type stride)
 {
@@ -49,226 +47,184 @@ MultiVector<ValueType>::create_with_type_of(
 }
 
 
-template <typename ValueType>
-std::unique_ptr<typename MultiVector<ValueType>::absolute_type>
-MultiVector<ValueType>::compute_absolute() const
+std::unique_ptr<MultiVector> MultiVector::compute_absolute() const
 {
     return this->compute_absolute_impl();
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_absolute_inplace()
+void MultiVector::compute_absolute_inplace()
 {
     this->compute_absolute_inplace_impl();
 }
 
 
-template <typename ValueType>
-std::unique_ptr<typename MultiVector<ValueType>::complex_type>
-MultiVector<ValueType>::make_complex() const
+std::unique_ptr<MultiVector> MultiVector::make_complex() const
 {
     return this->make_complex_impl();
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::make_complex(ptr_param<complex_type> result) const
+void MultiVector::make_complex(ptr_param<MultiVector> result) const
 {
     this->make_complex_impl(result.get());
 }
 
 
-template <typename ValueType>
-std::unique_ptr<typename MultiVector<ValueType>::real_type>
-MultiVector<ValueType>::get_real() const
+std::unique_ptr<MultiVector> MultiVector::get_real() const
 {
     return this->get_real_impl();
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::get_real(ptr_param<real_type> result) const
+void MultiVector::get_real(ptr_param<MultiVector> result) const
 {
     this->get_real_impl(result.get());
 }
 
 
-template <typename ValueType>
-std::unique_ptr<typename MultiVector<ValueType>::real_type>
-MultiVector<ValueType>::get_imag() const
+std::unique_ptr<MultiVector> MultiVector::get_imag() const
 {
     return this->get_imag_impl();
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::get_imag(ptr_param<real_type> result) const
+void MultiVector::get_imag(ptr_param<MultiVector> result) const
 {
     this->get_imag_impl(result.get());
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::fill(ValueType value)
+void MultiVector::fill(syn::variant_from_tuple<supported_value_types> value)
 {
-    this->fill_impl(value.get());
+    this->fill_impl(value);
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::scale(any_const_dense_t alpha)
-{
-    this->scale_impl(alpha);
-}
+void MultiVector::scale(any_const_dense_t alpha) { this->scale_impl(alpha); }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::inv_scale(any_const_dense_t alpha)
+void MultiVector::inv_scale(any_const_dense_t alpha)
 {
     this->inv_scale_impl(alpha);
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::add_scaled(any_const_dense_t alpha,
-                                        ptr_param<const MultiVector> b)
+void MultiVector::add_scaled(any_const_dense_t alpha,
+                             ptr_param<const MultiVector> b)
 {
     this->add_scaled_impl(alpha, b.get());
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::sub_scaled(any_const_dense_t alpha,
-                                        ptr_param<const MultiVector> b)
+void MultiVector::sub_scaled(any_const_dense_t alpha,
+                             ptr_param<const MultiVector> b)
 {
     this->sub_scaled_impl(alpha, b.get());
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_dot(ptr_param<const MultiVector> b,
-                                         ptr_param<MultiVector> result) const
+void MultiVector::compute_dot(ptr_param<const MultiVector> b,
+                              ptr_param<MultiVector> result) const
 {
     this->compute_dot_impl(b.get(), result.get());
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_dot(ptr_param<const MultiVector> b,
-                                         ptr_param<MultiVector> result,
-                                         array<char>& tmp) const
+void MultiVector::compute_dot(ptr_param<const MultiVector> b,
+                              ptr_param<MultiVector> result,
+                              array<char>& tmp) const
 {
     this->compute_dot_impl(b.get(), result.get(), tmp);
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_conj_dot(
-    ptr_param<const MultiVector> b, ptr_param<MultiVector> result) const
+void MultiVector::compute_conj_dot(ptr_param<const MultiVector> b,
+                                   ptr_param<MultiVector> result) const
 {
     this->compute_conj_dot_impl(b.get(), result.get());
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_conj_dot(ptr_param<const MultiVector> b,
-                                              ptr_param<MultiVector> result,
-                                              array<char>& tmp) const
+void MultiVector::compute_conj_dot(ptr_param<const MultiVector> b,
+                                   ptr_param<MultiVector> result,
+                                   array<char>& tmp) const
 {
     this->compute_conj_dot_impl(b.get(), result.get(), tmp);
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_norm2(
-    ptr_param<absolute_type> result) const
+void MultiVector::compute_norm2(ptr_param<MultiVector> result) const
 {
     this->compute_norm2_impl(result.get());
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_norm2(ptr_param<absolute_type> result,
-                                           array<char>& tmp) const
+void MultiVector::compute_norm2(ptr_param<MultiVector> result,
+                                array<char>& tmp) const
 {
     this->compute_norm2_impl(result.get(), tmp);
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_squared_norm2(
-    ptr_param<absolute_type> result) const
+void MultiVector::compute_squared_norm2(ptr_param<MultiVector> result) const
 {
     this->compute_squared_norm2_impl(result.get());
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_squared_norm2(
-    ptr_param<absolute_type> result, array<char>& tmp) const
+void MultiVector::compute_squared_norm2(ptr_param<MultiVector> result,
+                                        array<char>& tmp) const
 {
     this->compute_squared_norm2_impl(result.get(), tmp);
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_norm1(
-    ptr_param<absolute_type> result) const
+void MultiVector::compute_norm1(ptr_param<MultiVector> result) const
 {
     this->compute_norm1_impl(result.get());
 }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::compute_norm1(ptr_param<absolute_type> result,
-                                           array<char>& tmp) const
+void MultiVector::compute_norm1(ptr_param<MultiVector> result,
+                                array<char>& tmp) const
 {
     this->compute_norm1_impl(result.get(), tmp);
 }
 
 
-template <typename ValueType>
-std::unique_ptr<const typename MultiVector<ValueType>::real_type>
-MultiVector<ValueType>::create_real_view() const
+std::unique_ptr<const MultiVector> MultiVector::create_real_view() const
 {
     return this->create_real_view_impl();
 }
 
 
-template <typename ValueType>
-std::unique_ptr<typename MultiVector<ValueType>::real_type>
-MultiVector<ValueType>::create_real_view()
+std::unique_ptr<MultiVector> MultiVector::create_real_view()
 {
     return this->create_real_view_impl();
 }
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>> MultiVector<ValueType>::create_subview(
-    local_span rows, local_span columns)
+std::unique_ptr<MultiVector> MultiVector::create_subview(local_span rows,
+                                                         local_span columns)
 {
     return this->create_subview_impl(rows, columns);
 }
 
 
-template <typename ValueType>
-std::unique_ptr<MultiVector<ValueType>> MultiVector<ValueType>::create_subview(
-    local_span rows, local_span columns, size_type global_rows,
-    size_type globals_cols)
+std::unique_ptr<MultiVector> MultiVector::create_subview(local_span rows,
+                                                         local_span columns,
+                                                         size_type global_rows,
+                                                         size_type globals_cols)
 {
     return this->create_subview_impl(rows, columns, global_rows, globals_cols);
 }
 
-template <typename ValueType>
-dim<2> MultiVector<ValueType>::get_size() const noexcept
-{
-    return LinOp::get_size();
-}
+
+dim<2> MultiVector::get_size() const noexcept { return LinOp::get_size(); }
 
 
-template <typename ValueType>
-void MultiVector<ValueType>::set_size(const dim<2>& size) noexcept
+void MultiVector::set_size(const dim<2>& size) noexcept
 {
     LinOp::set_size(size);
 }
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index c70107038b8..252ebab113d 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -34,19 +34,14 @@ using any_const_dense_t = syn::variant_from_tuple<syn::apply_to_list<
 using any_dense_type =
     syn::variant_from_tuple<syn::apply_to_list<ptr_param, dense_types>>;
 
+using any_value_t = syn::variant_from_tuple<supported_value_types>;
+
 
 // Different type to clarify that only local rows/columns are meant
 struct local_span : span {};
 
-template <typename ValueType>
-class MultiVector
-    : public EnableAbstractPolymorphicObject<MultiVector<ValueType>, LinOp> {
+class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
 public:
-    using value_type = ValueType;
-    using absolute_type = MultiVector<remove_complex<ValueType>>;
-    using real_type = absolute_type;
-    using complex_type = MultiVector<to_complex<ValueType>>;
-
     [[nodiscard]] static std::unique_ptr<MultiVector> create_with_config_of(
         ptr_param<const MultiVector> other);
 
@@ -64,23 +59,23 @@ class MultiVector
         std::shared_ptr<const Executor> exec, const dim<2>& global_size,
         const dim<2>& local_size, size_type stride);
 
-    [[nodiscard]] std::unique_ptr<absolute_type> compute_absolute() const;
+    [[nodiscard]] std::unique_ptr<MultiVector> compute_absolute() const;
 
     void compute_absolute_inplace();
 
-    [[nodiscard]] std::unique_ptr<complex_type> make_complex() const;
+    [[nodiscard]] std::unique_ptr<MultiVector> make_complex() const;
 
-    void make_complex(ptr_param<complex_type> result) const;
+    void make_complex(ptr_param<MultiVector> result) const;
 
-    [[nodiscard]] std::unique_ptr<real_type> get_real() const;
+    [[nodiscard]] std::unique_ptr<MultiVector> get_real() const;
 
-    void get_real(ptr_param<real_type> result) const;
+    void get_real(ptr_param<MultiVector> result) const;
 
-    [[nodiscard]] std::unique_ptr<real_type> get_imag() const;
+    [[nodiscard]] std::unique_ptr<MultiVector> get_imag() const;
 
-    void get_imag(ptr_param<real_type> result) const;
+    void get_imag(ptr_param<MultiVector> result) const;
 
-    void fill(ValueType value);
+    void fill(any_value_t value);
 
     void scale(any_const_dense_t alpha);
 
@@ -103,22 +98,22 @@ class MultiVector
                           ptr_param<MultiVector> result,
                           array<char>& tmp) const;
 
-    void compute_norm2(ptr_param<absolute_type> result) const;
+    void compute_norm2(ptr_param<MultiVector> result) const;
 
-    void compute_norm2(ptr_param<absolute_type> result, array<char>& tmp) const;
+    void compute_norm2(ptr_param<MultiVector> result, array<char>& tmp) const;
 
-    void compute_squared_norm2(ptr_param<absolute_type> result) const;
+    void compute_squared_norm2(ptr_param<MultiVector> result) const;
 
-    void compute_squared_norm2(ptr_param<absolute_type> result,
+    void compute_squared_norm2(ptr_param<MultiVector> result,
                                array<char>& tmp) const;
 
-    void compute_norm1(ptr_param<absolute_type> result) const;
+    void compute_norm1(ptr_param<MultiVector> result) const;
 
-    void compute_norm1(ptr_param<absolute_type> result, array<char>& tmp) const;
+    void compute_norm1(ptr_param<MultiVector> result, array<char>& tmp) const;
 
-    [[nodiscard]] std::unique_ptr<const real_type> create_real_view() const;
+    [[nodiscard]] std::unique_ptr<const MultiVector> create_real_view() const;
 
-    [[nodiscard]] std::unique_ptr<real_type> create_real_view();
+    [[nodiscard]] std::unique_ptr<MultiVector> create_real_view();
 
     [[nodiscard]] std::unique_ptr<MultiVector> create_subview(
         local_span rows, local_span columns);
@@ -131,9 +126,7 @@ class MultiVector
 
 protected:
     explicit MultiVector(std::shared_ptr<const Executor> exec,
-                         const dim<2>& size = dim<2>{})
-        : EnableLinOp<MultiVector>(std::move(exec), size)
-    {}
+                         const dim<2>& size = dim<2>{});
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector>
     create_with_same_config_impl() const = 0;
@@ -142,22 +135,27 @@ class MultiVector
         std::shared_ptr<const Executor> exec, const dim<2>& global_size,
         const dim<2>& local_size, size_type stride) const = 0;
 
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> compute_absolute_impl()
+        const = 0;
+
     virtual void compute_absolute_inplace_impl() = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<complex_type> make_complex_impl()
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> make_complex_impl()
         const = 0;
 
-    virtual void make_complex_impl(complex_type* result) const = 0;
+    virtual void make_complex_impl(MultiVector* result) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<real_type> get_real_impl() const = 0;
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_real_impl()
+        const = 0;
 
-    virtual void get_real_impl(real_type* result) const = 0;
+    virtual void get_real_impl(MultiVector* result) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<real_type> get_imag_impl() const = 0;
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_imag_impl()
+        const = 0;
 
-    virtual void get_imag_impl(real_type* result) const = 0;
+    virtual void get_imag_impl(MultiVector* result) const = 0;
 
-    virtual void fill_impl(ValueType value) = 0;
+    virtual void fill_impl(any_value_t value) = 0;
 
     // @todo: need to fix alpha to a our dense type
     virtual void scale_impl(any_const_dense_t alpha) = 0;
@@ -183,25 +181,25 @@ class MultiVector
                                        MultiVector* result,
                                        array<char>& tmp) const = 0;
 
-    virtual void compute_norm2_impl(absolute_type* result) const = 0;
+    virtual void compute_norm2_impl(MultiVector* result) const = 0;
 
-    virtual void compute_norm2_impl(absolute_type* result,
+    virtual void compute_norm2_impl(MultiVector* result,
                                     array<char>& tmp) const = 0;
 
-    virtual void compute_squared_norm2_impl(absolute_type* result) const = 0;
+    virtual void compute_squared_norm2_impl(MultiVector* result) const = 0;
 
-    virtual void compute_squared_norm2_impl(absolute_type* result,
+    virtual void compute_squared_norm2_impl(MultiVector* result,
                                             array<char>& tmp) const = 0;
 
-    virtual void compute_norm1_impl(absolute_type* result) const = 0;
+    virtual void compute_norm1_impl(MultiVector* result) const = 0;
 
-    virtual void compute_norm1_impl(absolute_type* result,
+    virtual void compute_norm1_impl(MultiVector* result,
                                     array<char>& tmp) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<const real_type>
+    [[nodiscard]] virtual std::unique_ptr<const MultiVector>
     create_real_view_impl() const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<real_type>
+    [[nodiscard]] virtual std::unique_ptr<MultiVector>
     create_real_view_impl() = 0;
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview_impl(

From fe0006eb330b28639cafd62b2682d1ffb4d6e840 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Mon, 14 Jul 2025 17:38:53 +0200
Subject: [PATCH 11/18] add multi vector mixin

this mixin automatically casts the parameters to the concrete type.
---
 include/ginkgo/core/matrix/multivector.hpp | 206 +++++++++++++++++++++
 1 file changed, 206 insertions(+)

diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 252ebab113d..6e8c2f7217f 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -213,5 +213,211 @@ class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
 };
 
 
+template <typename ConcreteType>
+class EnableMultiVector
+    : public EnablePolymorphicObject<ConcreteType, MultiVector>,
+      public EnablePolymorphicAssignment<ConcreteType> {
+public:
+    using value_type = typename ConcreteType::value_type;
+    using absolute_type = remove_complex<ConcreteType>;
+    using real_type = absolute_type;
+    using complex_type = to_complex<ConcreteType>;
+
+protected:
+    void make_complex_impl(MultiVector* result) const final;
+
+    void get_real_impl(MultiVector* result) const final;
+
+    void get_imag_impl(MultiVector* result) const final;
+
+    void add_scaled_impl(any_const_dense_t alpha, const MultiVector* b) final;
+
+    void sub_scaled_impl(any_const_dense_t alpha, const MultiVector* b) final;
+
+    void compute_dot_impl(const MultiVector* b,
+                          MultiVector* result) const final;
+
+    void compute_dot_impl(const MultiVector* b, MultiVector* result,
+                          array<char>& tmp) const final;
+
+    void compute_conj_dot_impl(const MultiVector* b,
+                               MultiVector* result) const final;
+
+    void compute_conj_dot_impl(const MultiVector* b, MultiVector* result,
+                               array<char>& tmp) const final;
+
+    void compute_norm2_impl(MultiVector* result) const final;
+
+    void compute_norm2_impl(MultiVector* result, array<char>& tmp) const final;
+
+    void compute_squared_norm2_impl(MultiVector* result) const final;
+
+    void compute_squared_norm2_impl(MultiVector* result,
+                                    array<char>& tmp) const final;
+
+    void compute_norm1_impl(MultiVector* result) const final;
+
+    void compute_norm1_impl(MultiVector* result, array<char>& tmp) const final;
+
+    // Concretized function calls
+    virtual void make_complex_impl(complex_type* result) const = 0;
+
+    virtual void get_real_impl(real_type* result) const = 0;
+
+    virtual void get_imag_impl(real_type* result) const = 0;
+
+    virtual void add_scaled_impl(any_const_dense_t alpha,
+                                 const ConcreteType* b) = 0;
+
+    virtual void sub_scaled_impl(any_const_dense_t alpha,
+                                 const ConcreteType* b) = 0;
+
+    virtual void compute_dot_impl(const ConcreteType* b,
+                                  ConcreteType* result) const = 0;
+
+    virtual void compute_dot_impl(const ConcreteType* b, ConcreteType* result,
+                                  array<char>& tmp) const = 0;
+
+    virtual void compute_conj_dot_impl(const ConcreteType* b,
+                                       ConcreteType* result) const = 0;
+
+    virtual void compute_conj_dot_impl(const ConcreteType* b,
+                                       ConcreteType* result,
+                                       array<char>& tmp) const = 0;
+
+    virtual void compute_norm2_impl(absolute_type* result) const = 0;
+
+    virtual void compute_norm2_impl(absolute_type* result,
+                                    array<char>& tmp) const = 0;
+
+    virtual void compute_norm1_impl(absolute_type* result) const = 0;
+
+    virtual void compute_norm1_impl(absolute_type* result,
+                                    array<char>& tmp) const = 0;
+};
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::make_complex_impl(
+    MultiVector* result) const
+{
+    this->make_complex_impl(as<ConcreteType>(result));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::get_real_impl(MultiVector* result) const
+{
+    this->get_real_impl(as<ConcreteType>(result));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::get_imag_impl(MultiVector* result) const
+{
+    this->get_imag_impl(as<ConcreteType>(result));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::add_scaled_impl(any_const_dense_t alpha,
+                                                      const MultiVector* b)
+{
+    this->add_scaled_impl(alpha, as<const ConcreteType>(b));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::sub_scaled_impl(any_const_dense_t alpha,
+                                                      const MultiVector* b)
+{
+    this->sub_scaled_impl(alpha, as<const ConcreteType>(b));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_dot_impl(
+    const MultiVector* b, MultiVector* result) const
+{
+    this->compute_dot_impl(as<const ConcreteType>(b), as<ConcreteType>(result));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_dot_impl(const MultiVector* b,
+                                                       MultiVector* result,
+                                                       array<char>& tmp) const
+{
+    this->compute_dot_impl(as<const ConcreteType>(b), as<ConcreteType>(result),
+                           tmp);
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_conj_dot_impl(
+    const MultiVector* b, MultiVector* result) const
+{
+    this->compute_conj_dot_impl(as<const ConcreteType>(b),
+                                as<ConcreteType>(result));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_conj_dot_impl(
+    const MultiVector* b, MultiVector* result, array<char>& tmp) const
+{
+    this->compute_conj_dot_impl(as<const ConcreteType>(b),
+                                as<ConcreteType>(result), tmp);
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_norm2_impl(
+    MultiVector* result) const
+{
+    this->compute_norm2_impl(as<ConcreteType>(result));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_norm2_impl(MultiVector* result,
+                                                         array<char>& tmp) const
+{
+    this->compute_norm2_impl(as<ConcreteType>(result), tmp);
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_squared_norm2_impl(
+    MultiVector* result) const
+{
+    this->compute_squared_norm2_impl(as<ConcreteType>(result));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_squared_norm2_impl(
+    MultiVector* result, array<char>& tmp) const
+{
+    this->compute_squared_norm2_impl(as<ConcreteType>(result), tmp);
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_norm1_impl(
+    MultiVector* result) const
+{
+    this->compute_norm1_impl(as<ConcreteType>(result));
+}
+
+
+template <typename ConcreteType>
+void EnableMultiVector<ConcreteType>::compute_norm1_impl(MultiVector* result,
+                                                         array<char>& tmp) const
+{
+    this->compute_norm1_impl(as<ConcreteType>(result), tmp);
+}
+
+
 }  // namespace matrix
 }  // namespace gko

From 93fbca23e27b77afc190b2b8ef7bb71b6c63d52d Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Tue, 15 Jul 2025 12:45:58 +0200
Subject: [PATCH 12/18] fixup! meta programming helpers

---
 include/ginkgo/core/synthesizer/containers.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/ginkgo/core/synthesizer/containers.hpp b/include/ginkgo/core/synthesizer/containers.hpp
index b89068ac9a6..4c19beda3bd 100644
--- a/include/ginkgo/core/synthesizer/containers.hpp
+++ b/include/ginkgo/core/synthesizer/containers.hpp
@@ -202,7 +202,7 @@ struct apply_to_list_impl<T, std::tuple<U, InputTypes...>,
 
 
 template <template <typename> typename T, typename TupleList>
-using apply_to_list = detail::apply_to_list_impl<T, TupleList>::type;
+using apply_to_list = typename detail::apply_to_list_impl<T, TupleList>::type;
 
 namespace detail {
 
@@ -217,7 +217,8 @@ struct variant_from_tuple_impl<std::tuple<Types...>> {
 }  // namespace detail
 
 template <typename Tuple>
-using variant_from_tuple = detail::variant_from_tuple_impl<Tuple>::type;
+using variant_from_tuple =
+    typename detail::variant_from_tuple_impl<Tuple>::type;
 
 }  // namespace syn
 }  // namespace gko

From bcf5e5f9cf6a54af8d4e298040d3582377666239 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Tue, 15 Jul 2025 12:46:47 +0200
Subject: [PATCH 13/18] allow returning concrete type

---
 core/matrix/multivector.cpp                |  45 +-
 include/ginkgo/core/matrix/multivector.hpp | 454 +++++++++++++++++++--
 2 files changed, 446 insertions(+), 53 deletions(-)

diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
index e82416c0333..01a80380213 100644
--- a/core/matrix/multivector.cpp
+++ b/core/matrix/multivector.cpp
@@ -17,14 +17,14 @@ MultiVector::MultiVector(std::shared_ptr<const Executor> exec,
 std::unique_ptr<MultiVector> MultiVector::create_with_config_of(
     ptr_param<const MultiVector> other)
 {
-    return other->create_with_same_config_impl();
+    return other->create_generic_with_same_config_impl();
 }
 
 
 std::unique_ptr<MultiVector> MultiVector::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec)
 {
-    return other->create_with_type_of_impl(std::move(exec), {}, {}, 0);
+    return other->create_generic_with_type_of_impl(std::move(exec), {}, {}, 0);
 }
 
 
@@ -33,8 +33,8 @@ std::unique_ptr<MultiVector> MultiVector::create_with_type_of(
     const dim<2>& global_size, const dim<2>& local_size)
 {
     GKO_ASSERT_EQUAL_COLS(global_size, local_size);
-    return other->create_with_type_of_impl(std::move(exec), global_size,
-                                           local_size, global_size[1]);
+    return other->create_generic_with_type_of_impl(std::move(exec), global_size,
+                                                   local_size, global_size[1]);
 }
 
 
@@ -42,14 +42,14 @@ std::unique_ptr<MultiVector> MultiVector::create_with_type_of(
     ptr_param<const MultiVector> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size, size_type stride)
 {
-    return other->create_with_type_of_impl(std::move(exec), global_size,
-                                           local_size, stride);
+    return other->create_generic_with_type_of_impl(std::move(exec), global_size,
+                                                   local_size, stride);
 }
 
 
 std::unique_ptr<MultiVector> MultiVector::compute_absolute() const
 {
-    return this->compute_absolute_impl();
+    return this->compute_absolute_generic_impl();
 }
 
 
@@ -61,7 +61,7 @@ void MultiVector::compute_absolute_inplace()
 
 std::unique_ptr<MultiVector> MultiVector::make_complex() const
 {
-    return this->make_complex_impl();
+    return this->make_complex_generic_impl();
 }
 
 
@@ -73,7 +73,7 @@ void MultiVector::make_complex(ptr_param<MultiVector> result) const
 
 std::unique_ptr<MultiVector> MultiVector::get_real() const
 {
-    return this->get_real_impl();
+    return this->get_real_generic_impl();
 }
 
 
@@ -85,7 +85,7 @@ void MultiVector::get_real(ptr_param<MultiVector> result) const
 
 std::unique_ptr<MultiVector> MultiVector::get_imag() const
 {
-    return this->get_imag_impl();
+    return this->get_imag_generic_impl();
 }
 
 
@@ -195,20 +195,36 @@ void MultiVector::compute_norm1(ptr_param<MultiVector> result,
 
 std::unique_ptr<const MultiVector> MultiVector::create_real_view() const
 {
-    return this->create_real_view_impl();
+    return this->create_real_view_generic_impl();
 }
 
 
 std::unique_ptr<MultiVector> MultiVector::create_real_view()
 {
-    return this->create_real_view_impl();
+    return this->create_real_view_generic_impl();
 }
 
 
 std::unique_ptr<MultiVector> MultiVector::create_subview(local_span rows,
                                                          local_span columns)
 {
-    return this->create_subview_impl(rows, columns);
+    return this->create_subview_generic_impl(rows, columns);
+}
+
+
+std::unique_ptr<const MultiVector> MultiVector::create_subview(
+    local_span rows, local_span columns) const
+{
+    return this->create_subview_generic_impl(rows, columns);
+}
+
+
+std::unique_ptr<const MultiVector> MultiVector::create_subview(
+    local_span rows, local_span columns, size_type global_rows,
+    size_type globals_cols) const
+{
+    return this->create_subview_generic_impl(rows, columns, global_rows,
+                                             globals_cols);
 }
 
 
@@ -217,7 +233,8 @@ std::unique_ptr<MultiVector> MultiVector::create_subview(local_span rows,
                                                          size_type global_rows,
                                                          size_type globals_cols)
 {
-    return this->create_subview_impl(rows, columns, global_rows, globals_cols);
+    return this->create_subview_generic_impl(rows, columns, global_rows,
+                                             globals_cols);
 }
 
 
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 6e8c2f7217f..aa196936b5c 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -118,10 +118,17 @@ class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
     [[nodiscard]] std::unique_ptr<MultiVector> create_subview(
         local_span rows, local_span columns);
 
+    [[nodiscard]] std::unique_ptr<const MultiVector> create_subview(
+        local_span rows, local_span columns) const;
+
     [[nodiscard]] std::unique_ptr<MultiVector> create_subview(
         local_span rows, local_span columns, size_type global_rows,
         size_type globals_cols);
 
+    [[nodiscard]] std::unique_ptr<const MultiVector> create_subview(
+        local_span rows, local_span columns, size_type global_rows,
+        size_type globals_cols) const;
+
     [[nodiscard]] dim<2> get_size() const noexcept;
 
 protected:
@@ -129,28 +136,30 @@ class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
                          const dim<2>& size = dim<2>{});
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector>
-    create_with_same_config_impl() const = 0;
+    create_generic_with_same_config_impl() const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_with_type_of_impl(
-        std::shared_ptr<const Executor> exec, const dim<2>& global_size,
-        const dim<2>& local_size, size_type stride) const = 0;
+    [[nodiscard]] virtual std::unique_ptr<MultiVector>
+    create_generic_with_type_of_impl(std::shared_ptr<const Executor> exec,
+                                     const dim<2>& global_size,
+                                     const dim<2>& local_size,
+                                     size_type stride) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> compute_absolute_impl()
-        const = 0;
+    [[nodiscard]] virtual std::unique_ptr<MultiVector>
+    compute_absolute_generic_impl() const = 0;
 
     virtual void compute_absolute_inplace_impl() = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> make_complex_impl()
-        const = 0;
+    [[nodiscard]] virtual std::unique_ptr<MultiVector>
+    make_complex_generic_impl() const = 0;
 
     virtual void make_complex_impl(MultiVector* result) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_real_impl()
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_real_generic_impl()
         const = 0;
 
     virtual void get_real_impl(MultiVector* result) const = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_imag_impl()
+    [[nodiscard]] virtual std::unique_ptr<MultiVector> get_imag_generic_impl()
         const = 0;
 
     virtual void get_imag_impl(MultiVector* result) const = 0;
@@ -197,17 +206,26 @@ class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
                                     array<char>& tmp) const = 0;
 
     [[nodiscard]] virtual std::unique_ptr<const MultiVector>
-    create_real_view_impl() const = 0;
+    create_real_view_generic_impl() const = 0;
 
     [[nodiscard]] virtual std::unique_ptr<MultiVector>
-    create_real_view_impl() = 0;
+    create_real_view_generic_impl() = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview_impl(
-        local_span rows, local_span columns) = 0;
+    [[nodiscard]] virtual std::unique_ptr<MultiVector>
+    create_subview_generic_impl(local_span rows, local_span columns) = 0;
 
-    [[nodiscard]] virtual std::unique_ptr<MultiVector> create_subview_impl(
-        local_span rows, local_span columns, size_type global_rows,
-        size_type globals_cols) = 0;
+    [[nodiscard]] virtual std::unique_ptr<const MultiVector>
+    create_subview_generic_impl(local_span rows, local_span columns) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<MultiVector>
+    create_subview_generic_impl(local_span rows, local_span columns,
+                                size_type global_rows,
+                                size_type globals_cols) = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<const MultiVector>
+    create_subview_generic_impl(local_span rows, local_span columns,
+                                size_type global_rows,
+                                size_type globals_cols) const = 0;
 
     void set_size(const dim<2>& size) noexcept;
 };
@@ -218,48 +236,99 @@ class EnableMultiVector
     : public EnablePolymorphicObject<ConcreteType, MultiVector>,
       public EnablePolymorphicAssignment<ConcreteType> {
 public:
-    using value_type = typename ConcreteType::value_type;
     using absolute_type = remove_complex<ConcreteType>;
     using real_type = absolute_type;
     using complex_type = to_complex<ConcreteType>;
 
-protected:
-    void make_complex_impl(MultiVector* result) const final;
+    [[nodiscard]] static std::unique_ptr<ConcreteType> create_with_config_of(
+        ptr_param<const ConcreteType> other);
 
-    void get_real_impl(MultiVector* result) const final;
+    [[nodiscard]] static std::unique_ptr<ConcreteType> create_with_type_of(
+        ptr_param<const ConcreteType> other,
+        std::shared_ptr<const Executor> exec);
 
-    void get_imag_impl(MultiVector* result) const final;
+    [[nodiscard]] static std::unique_ptr<ConcreteType> create_with_type_of(
+        ptr_param<const ConcreteType> other,
+        std::shared_ptr<const Executor> exec, const dim<2>& global_size,
+        const dim<2>& local_size);
 
-    void add_scaled_impl(any_const_dense_t alpha, const MultiVector* b) final;
+    [[nodiscard]] static std::unique_ptr<ConcreteType> create_with_type_of(
+        ptr_param<const ConcreteType> other,
+        std::shared_ptr<const Executor> exec, const dim<2>& global_size,
+        const dim<2>& local_size, size_type stride);
 
-    void sub_scaled_impl(any_const_dense_t alpha, const MultiVector* b) final;
+    [[nodiscard]] std::unique_ptr<ConcreteType> create_subview(
+        local_span rows, local_span columns);
 
-    void compute_dot_impl(const MultiVector* b,
-                          MultiVector* result) const final;
+    [[nodiscard]] std::unique_ptr<const ConcreteType> create_subview(
+        local_span rows, local_span columns) const;
 
-    void compute_dot_impl(const MultiVector* b, MultiVector* result,
-                          array<char>& tmp) const final;
+    [[nodiscard]] std::unique_ptr<ConcreteType> create_subview(
+        local_span rows, local_span columns, size_type global_rows,
+        size_type globals_cols);
 
-    void compute_conj_dot_impl(const MultiVector* b,
-                               MultiVector* result) const final;
+    [[nodiscard]] std::unique_ptr<const ConcreteType> create_subview(
+        local_span rows, local_span columns, size_type global_rows,
+        size_type globals_cols) const;
 
-    void compute_conj_dot_impl(const MultiVector* b, MultiVector* result,
-                               array<char>& tmp) const final;
+    [[nodiscard]] std::unique_ptr<const real_type> create_real_view() const;
 
-    void compute_norm2_impl(MultiVector* result) const final;
+    [[nodiscard]] std::unique_ptr<real_type> create_real_view();
 
-    void compute_norm2_impl(MultiVector* result, array<char>& tmp) const final;
+    [[nodiscard]] std::unique_ptr<absolute_type> compute_absolute() const;
 
-    void compute_squared_norm2_impl(MultiVector* result) const final;
+    [[nodiscard]] std::unique_ptr<complex_type> make_complex() const;
 
-    void compute_squared_norm2_impl(MultiVector* result,
-                                    array<char>& tmp) const final;
+    [[nodiscard]] std::unique_ptr<real_type> get_real() const;
 
-    void compute_norm1_impl(MultiVector* result) const final;
+    [[nodiscard]] std::unique_ptr<real_type> get_imag() const;
 
-    void compute_norm1_impl(MultiVector* result, array<char>& tmp) const final;
+protected:
+    EnableMultiVector(std::shared_ptr<const Executor> exec, dim<2> size = {})
+        : EnablePolymorphicObject<ConcreteType, MultiVector>(exec, size)
+    {}
 
     // Concretized function calls
+    [[nodiscard]] virtual std::unique_ptr<ConcreteType>
+    create_with_same_config_impl() const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<ConcreteType>
+    create_with_type_of_impl(std::shared_ptr<const Executor> exec,
+                             const dim<2>& global_size,
+                             const dim<2>& local_size,
+                             size_type stride) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<ConcreteType> create_subview_impl(
+        local_span rows, local_span columns) = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<const ConcreteType>
+    create_subview_impl(local_span rows, local_span columns) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<ConcreteType> create_subview_impl(
+        local_span rows, local_span columns, size_type global_rows,
+        size_type globals_cols) = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<const ConcreteType>
+    create_subview_impl(local_span rows, local_span columns,
+                        size_type global_rows,
+                        size_type globals_cols) const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<const real_type>
+    create_real_view_impl() const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<real_type>
+    create_real_view_impl() = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<absolute_type> compute_absolute_impl()
+        const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<complex_type> make_complex_impl()
+        const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<real_type> get_real_impl() const = 0;
+
+    [[nodiscard]] virtual std::unique_ptr<real_type> get_imag_impl() const = 0;
+
     virtual void make_complex_impl(complex_type* result) const = 0;
 
     virtual void get_real_impl(real_type* result) const = 0;
@@ -294,9 +363,316 @@ class EnableMultiVector
 
     virtual void compute_norm1_impl(absolute_type* result,
                                     array<char>& tmp) const = 0;
+
+private:
+    [[nodiscard]] std::unique_ptr<MultiVector>
+    create_generic_with_same_config_impl() const final;
+
+    [[nodiscard]] std::unique_ptr<MultiVector> create_generic_with_type_of_impl(
+        std::shared_ptr<const Executor> exec, const dim<2>& global_size,
+        const dim<2>& local_size, size_type stride) const final;
+
+    [[nodiscard]] std::unique_ptr<MultiVector> create_subview_generic_impl(
+        local_span rows, local_span columns) final;
+
+    [[nodiscard]] std::unique_ptr<const MultiVector>
+    create_subview_generic_impl(local_span rows,
+                                local_span columns) const final;
+
+    [[nodiscard]] std::unique_ptr<MultiVector> create_subview_generic_impl(
+        local_span rows, local_span columns, size_type global_rows,
+        size_type globals_cols) final;
+
+    [[nodiscard]] std::unique_ptr<const MultiVector>
+    create_subview_generic_impl(local_span rows, local_span columns,
+                                size_type global_rows,
+                                size_type globals_cols) const final;
+
+    [[nodiscard]] std::unique_ptr<const MultiVector>
+    create_real_view_generic_impl() const final;
+
+    [[nodiscard]] std::unique_ptr<MultiVector> create_real_view_generic_impl()
+        final;
+
+    [[nodiscard]] std::unique_ptr<MultiVector> compute_absolute_generic_impl()
+        const final;
+
+    [[nodiscard]] std::unique_ptr<MultiVector> make_complex_generic_impl()
+        const final;
+
+    [[nodiscard]] std::unique_ptr<MultiVector> get_real_generic_impl()
+        const final;
+
+    [[nodiscard]] std::unique_ptr<MultiVector> get_imag_generic_impl()
+        const final;
+
+    void make_complex_impl(MultiVector* result) const final;
+
+    void get_real_impl(MultiVector* result) const final;
+
+    void get_imag_impl(MultiVector* result) const final;
+
+    void add_scaled_impl(any_const_dense_t alpha, const MultiVector* b) final;
+
+    void sub_scaled_impl(any_const_dense_t alpha, const MultiVector* b) final;
+
+    void compute_dot_impl(const MultiVector* b,
+                          MultiVector* result) const final;
+
+    void compute_dot_impl(const MultiVector* b, MultiVector* result,
+                          array<char>& tmp) const final;
+
+    void compute_conj_dot_impl(const MultiVector* b,
+                               MultiVector* result) const final;
+
+    void compute_conj_dot_impl(const MultiVector* b, MultiVector* result,
+                               array<char>& tmp) const final;
+
+    void compute_norm2_impl(MultiVector* result) const final;
+
+    void compute_norm2_impl(MultiVector* result, array<char>& tmp) const final;
+
+    void compute_squared_norm2_impl(MultiVector* result) const final;
+
+    void compute_squared_norm2_impl(MultiVector* result,
+                                    array<char>& tmp) const final;
+
+    void compute_norm1_impl(MultiVector* result) const final;
+
+    void compute_norm1_impl(MultiVector* result, array<char>& tmp) const final;
 };
 
 
+template <typename ConcreteType>
+std::unique_ptr<ConcreteType>
+EnableMultiVector<ConcreteType>::create_with_config_of(
+    ptr_param<const ConcreteType> other)
+{
+    return other->create_with_same_config_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<ConcreteType>
+EnableMultiVector<ConcreteType>::create_with_type_of(
+    ptr_param<const ConcreteType> other, std::shared_ptr<const Executor> exec)
+{
+    return other->create_with_type_of_impl(std::move(exec));
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<ConcreteType>
+EnableMultiVector<ConcreteType>::create_with_type_of(
+    ptr_param<const ConcreteType> other, std::shared_ptr<const Executor> exec,
+    const dim<2>& global_size, const dim<2>& local_size)
+{
+    return other->create_with_type_of_impl(std::move(exec), global_size,
+                                           local_size);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<ConcreteType>
+EnableMultiVector<ConcreteType>::create_with_type_of(
+    ptr_param<const ConcreteType> other, std::shared_ptr<const Executor> exec,
+    const dim<2>& global_size, const dim<2>& local_size, size_type stride)
+{
+    return other->create_with_type_of_impl(std::move(exec), global_size,
+                                           local_size, stride);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<ConcreteType> EnableMultiVector<ConcreteType>::create_subview(
+    local_span rows, local_span columns)
+{
+    return this->create_subview_impl(rows, columns);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<const ConcreteType>
+EnableMultiVector<ConcreteType>::create_subview(local_span rows,
+                                                local_span columns) const
+{
+    return this->create_subview_impl(rows, columns);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<ConcreteType> EnableMultiVector<ConcreteType>::create_subview(
+    local_span rows, local_span columns, size_type global_rows,
+    size_type globals_cols)
+{
+    return this->create_subview_impl(rows, columns, global_rows, globals_cols);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<const ConcreteType>
+EnableMultiVector<ConcreteType>::create_subview(local_span rows,
+                                                local_span columns,
+                                                size_type global_rows,
+                                                size_type globals_cols) const
+{
+    return this->create_subview_impl(rows, columns, global_rows, globals_cols);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<const typename EnableMultiVector<ConcreteType>::real_type>
+EnableMultiVector<ConcreteType>::create_real_view() const
+{
+    return this->create_real_view_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<typename EnableMultiVector<ConcreteType>::real_type>
+EnableMultiVector<ConcreteType>::create_real_view()
+{
+    return this->create_real_view_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<typename EnableMultiVector<ConcreteType>::absolute_type>
+EnableMultiVector<ConcreteType>::compute_absolute() const
+{
+    return this->compute_absolute_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<typename EnableMultiVector<ConcreteType>::complex_type>
+EnableMultiVector<ConcreteType>::make_complex() const
+{
+    return this->make_complex_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<typename EnableMultiVector<ConcreteType>::real_type>
+EnableMultiVector<ConcreteType>::get_real() const
+{
+    return this->get_real_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<typename EnableMultiVector<ConcreteType>::real_type>
+EnableMultiVector<ConcreteType>::get_imag() const
+{
+    return this->get_imag_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::create_generic_with_same_config_impl() const
+{
+    return this->create_with_same_config_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::create_generic_with_type_of_impl(
+    std::shared_ptr<const Executor> exec, const dim<2>& global_size,
+    const dim<2>& local_size, size_type stride) const
+{
+    return this->create_with_type_of_impl(std::move(exec), global_size,
+                                          local_size, stride);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::create_subview_generic_impl(local_span rows,
+                                                             local_span columns)
+{
+    return this->create_subview_impl(rows, columns);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<const MultiVector>
+EnableMultiVector<ConcreteType>::create_subview_generic_impl(
+    local_span rows, local_span columns) const
+{
+    return this->create_subview_impl(rows, columns);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::create_subview_generic_impl(
+    local_span rows, local_span columns, size_type global_rows,
+    size_type globals_cols)
+{
+    return this->create_subview_impl(rows, columns, global_rows, globals_cols);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<const MultiVector>
+EnableMultiVector<ConcreteType>::create_subview_generic_impl(
+    local_span rows, local_span columns, size_type global_rows,
+    size_type globals_cols) const
+{
+    return this->create_subview_impl(rows, columns, global_rows, globals_cols);
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<const MultiVector>
+EnableMultiVector<ConcreteType>::create_real_view_generic_impl() const
+{
+    return this->create_real_view_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::create_real_view_generic_impl()
+{
+    return this->create_real_view_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::compute_absolute_generic_impl() const
+{
+    return this->compute_absolute_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::make_complex_generic_impl() const
+{
+    return this->make_complex_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::get_real_generic_impl() const
+{
+    return this->get_real_impl();
+}
+
+
+template <typename ConcreteType>
+std::unique_ptr<MultiVector>
+EnableMultiVector<ConcreteType>::get_imag_generic_impl() const
+{
+    return this->get_imag_impl();
+}
+
+
 template <typename ConcreteType>
 void EnableMultiVector<ConcreteType>::make_complex_impl(
     MultiVector* result) const

From 74c2d5a5150ec8471fc9e748546d6d5e6cc3553e Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Tue, 15 Jul 2025 14:38:18 +0200
Subject: [PATCH 14/18] fixup! allow returning concrete type

---
 include/ginkgo/core/matrix/multivector.hpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index aa196936b5c..d1067a93cc0 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -448,7 +448,8 @@ std::unique_ptr<ConcreteType>
 EnableMultiVector<ConcreteType>::create_with_config_of(
     ptr_param<const ConcreteType> other)
 {
-    return other->create_with_same_config_impl();
+    return static_cast<const EnableMultiVector*>(other.get())
+        ->create_with_same_config_impl();
 }
 
 
@@ -457,7 +458,8 @@ std::unique_ptr<ConcreteType>
 EnableMultiVector<ConcreteType>::create_with_type_of(
     ptr_param<const ConcreteType> other, std::shared_ptr<const Executor> exec)
 {
-    return other->create_with_type_of_impl(std::move(exec));
+    return static_cast<const EnableMultiVector*>(other.get())
+        ->create_with_type_of_impl(std::move(exec));
 }
 
 
@@ -467,8 +469,8 @@ EnableMultiVector<ConcreteType>::create_with_type_of(
     ptr_param<const ConcreteType> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size)
 {
-    return other->create_with_type_of_impl(std::move(exec), global_size,
-                                           local_size);
+    return static_cast<const EnableMultiVector*>(other.get())
+        ->create_with_type_of_impl(std::move(exec), global_size, local_size);
 }
 
 
@@ -478,8 +480,9 @@ EnableMultiVector<ConcreteType>::create_with_type_of(
     ptr_param<const ConcreteType> other, std::shared_ptr<const Executor> exec,
     const dim<2>& global_size, const dim<2>& local_size, size_type stride)
 {
-    return other->create_with_type_of_impl(std::move(exec), global_size,
-                                           local_size, stride);
+    return static_cast<const EnableMultiVector*>(other.get())
+        ->create_with_type_of_impl(std::move(exec), global_size, local_size,
+                                   stride);
 }
 
 

From 002f6fde08dfe7d337029da5c0493bf272a754b0 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Tue, 15 Jul 2025 16:53:28 +0200
Subject: [PATCH 15/18] fixup! meta programming helpers

---
 include/ginkgo/core/synthesizer/containers.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/ginkgo/core/synthesizer/containers.hpp b/include/ginkgo/core/synthesizer/containers.hpp
index 4c19beda3bd..825bf882290 100644
--- a/include/ginkgo/core/synthesizer/containers.hpp
+++ b/include/ginkgo/core/synthesizer/containers.hpp
@@ -180,16 +180,16 @@ constexpr std::array<T, sizeof...(Value)> as_array(value_list<T, Value...> vl)
 
 namespace detail {
 
-template <template <typename> typename T, typename InputList,
+template <template <typename...> typename T, typename InputList,
           typename ResultList = std::tuple<>>
 struct apply_to_list_impl;
 
-template <template <typename> typename T, typename ResultList>
+template <template <typename...> typename T, typename ResultList>
 struct apply_to_list_impl<T, std::tuple<>, ResultList> {
     using type = ResultList;
 };
 
-template <template <typename> typename T, typename U, typename... InputTypes,
+template <template <typename...> typename T, typename U, typename... InputTypes,
           typename... ResultTypes>
 struct apply_to_list_impl<T, std::tuple<U, InputTypes...>,
                           std::tuple<ResultTypes...>> {
@@ -201,7 +201,7 @@ struct apply_to_list_impl<T, std::tuple<U, InputTypes...>,
 }  // namespace detail
 
 
-template <template <typename> typename T, typename TupleList>
+template <template <typename...> typename T, typename TupleList>
 using apply_to_list = typename detail::apply_to_list_impl<T, TupleList>::type;
 
 namespace detail {

From 0ee40cd7c5edae3964d364402acabd9a748f31c8 Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Tue, 15 Jul 2025 16:54:02 +0200
Subject: [PATCH 16/18] add stride and local view (should be device view)

---
 core/matrix/multivector.cpp                | 37 ++++++++++++++++++++++
 include/ginkgo/core/matrix/multivector.hpp | 23 ++++++++++++++
 2 files changed, 60 insertions(+)

diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
index 01a80380213..9472c585699 100644
--- a/core/matrix/multivector.cpp
+++ b/core/matrix/multivector.cpp
@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
+#include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/multivector.hpp>
 
 namespace gko {
@@ -241,11 +242,47 @@ std::unique_ptr<MultiVector> MultiVector::create_subview(local_span rows,
 dim<2> MultiVector::get_size() const noexcept { return LinOp::get_size(); }
 
 
+size_type MultiVector::get_stride() const noexcept { return get_stride_impl(); }
+
+
 void MultiVector::set_size(const dim<2>& size) noexcept
 {
     LinOp::set_size(size);
 }
 
 
+template <typename ValueType>
+std::unique_ptr<Dense<ValueType>> MultiVector::create_local_view()
+{
+    using return_type = std::unique_ptr<Dense<ValueType>>;
+    auto variant = this->create_local_view_impl(ValueType());
+    if (!std::holds_alternative<return_type>(variant)) {
+        GKO_INVALID_STATE("Unexpected type of local view");
+    }
+    return std::move(std::get<return_type>(variant));
+}
+
+#define GKO_DECLARE_MULTIVECTOR_CREATE_LOCAL_VIEW(_type) \
+    std::unique_ptr<Dense<_type>> MultiVector::create_local_view()
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_MULTIVECTOR_CREATE_LOCAL_VIEW);
+
+
+template <typename ValueType>
+std::unique_ptr<const Dense<ValueType>> MultiVector::create_local_view() const
+{
+    using return_type = std::unique_ptr<const Dense<ValueType>>;
+    auto variant = this->create_local_view_impl(ValueType());
+    if (!std::holds_alternative<return_type>(variant)) {
+        GKO_INVALID_STATE("Unexpected type of local view");
+    }
+    return std::move(std::get<return_type>(variant));
+}
+
+#define GKO_DECLARE_MULTIVECTOR_CREATE_LOCAL_VIEW_CONST(_type) \
+    std::unique_ptr<const Dense<_type>> MultiVector::create_local_view() const
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(
+    GKO_DECLARE_MULTIVECTOR_CREATE_LOCAL_VIEW_CONST);
+
+
 }  // namespace matrix
 }  // namespace gko
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index d1067a93cc0..057ef90b4fb 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -129,8 +129,18 @@ class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
         local_span rows, local_span columns, size_type global_rows,
         size_type globals_cols) const;
 
+    // @todo: this should return something like a device view
+    template <typename ValueType>
+    [[nodiscard]] std::unique_ptr<Dense<ValueType>> create_local_view();
+
+    template <typename ValueType>
+    [[nodiscard]] std::unique_ptr<const Dense<ValueType>> create_local_view()
+        const;
+
     [[nodiscard]] dim<2> get_size() const noexcept;
 
+    [[nodiscard]] size_type get_stride() const noexcept;
+
 protected:
     explicit MultiVector(std::shared_ptr<const Executor> exec,
                          const dim<2>& size = dim<2>{});
@@ -227,6 +237,19 @@ class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
                                 size_type global_rows,
                                 size_type globals_cols) const = 0;
 
+    [[nodiscard]] virtual auto create_local_view_impl(
+        syn::variant_from_tuple<supported_value_types> type)
+        -> syn::variant_from_tuple<
+            syn::apply_to_list<std::unique_ptr, dense_types>> = 0;
+
+    [[nodiscard]] virtual auto create_local_view_impl(
+        syn::variant_from_tuple<supported_value_types> type) const
+        -> syn::variant_from_tuple<syn::apply_to_list<
+            std::unique_ptr,
+            syn::apply_to_list<std::add_const_t, dense_types>>> = 0;
+
+    [[nodiscard]] virtual auto get_stride_impl() const -> size_type = 0;
+
     void set_size(const dim<2>& size) noexcept;
 };
 

From 4297249443a034174dd1755df8bd660478a729de Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Wed, 16 Jul 2025 10:35:51 +0200
Subject: [PATCH 17/18] add interface for precision conversion

---
 core/matrix/multivector.cpp                | 25 ++++++++++++++++++++++
 include/ginkgo/core/matrix/multivector.hpp | 16 ++++++++++++++
 2 files changed, 41 insertions(+)

diff --git a/core/matrix/multivector.cpp b/core/matrix/multivector.cpp
index 9472c585699..91edf783272 100644
--- a/core/matrix/multivector.cpp
+++ b/core/matrix/multivector.cpp
@@ -284,5 +284,30 @@ GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(
     GKO_DECLARE_MULTIVECTOR_CREATE_LOCAL_VIEW_CONST);
 
 
+template <typename ValueType>
+auto MultiVector::temporary_precision()
+    -> std::unique_ptr<MultiVector, std::function<void(MultiVector*)>>
+{
+    return temporary_precision_impl(ValueType());
+}
+
+#define GKO_DECLARE_MULTIVECTOR_AS_PRECISION(_type)                 \
+    std::unique_ptr<MultiVector, std::function<void(MultiVector*)>> \
+    MultiVector::temporary_precision<_type>()
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_MULTIVECTOR_AS_PRECISION);
+
+
+template <typename ValueType>
+std::unique_ptr<const MultiVector> MultiVector::temporary_precision() const
+{
+    return temporary_precision_impl(ValueType());
+}
+
+#define GKO_DECLARE_MULTIVECTOR_AS_PRECISION_CONST(_type) \
+    std::unique_ptr<const MultiVector>                    \
+    MultiVector::temporary_precision<_type>() const
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_MULTIVECTOR_AS_PRECISION_CONST);
+
+
 }  // namespace matrix
 }  // namespace gko
diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 057ef90b4fb..6d3f562784e 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -137,6 +137,14 @@ class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
     [[nodiscard]] std::unique_ptr<const Dense<ValueType>> create_local_view()
         const;
 
+    template <typename ValueType>
+    [[nodiscard]] auto temporary_precision() const
+        -> std::unique_ptr<const MultiVector>;
+
+    template <typename ValueType>
+    [[nodiscard]] auto temporary_precision()
+        -> std::unique_ptr<MultiVector, std::function<void(MultiVector*)>>;
+
     [[nodiscard]] dim<2> get_size() const noexcept;
 
     [[nodiscard]] size_type get_stride() const noexcept;
@@ -250,6 +258,14 @@ class MultiVector : public EnableAbstractPolymorphicObject<MultiVector, LinOp> {
 
     [[nodiscard]] virtual auto get_stride_impl() const -> size_type = 0;
 
+    [[nodiscard]] virtual auto temporary_precision_impl(
+        syn::variant_from_tuple<supported_value_types> type)
+        -> std::unique_ptr<MultiVector, std::function<void(MultiVector*)>> = 0;
+
+    [[nodiscard]] virtual auto temporary_precision_impl(
+        syn::variant_from_tuple<supported_value_types> type) const
+        -> std::unique_ptr<const MultiVector> = 0;
+
     void set_size(const dim<2>& size) noexcept;
 };
 

From 1c86aa3034a4752772c9ff1820c00e7afb42543f Mon Sep 17 00:00:00 2001
From: Marcel Koch <marcel.koch@kit.edu>
Date: Wed, 16 Jul 2025 17:10:22 +0200
Subject: [PATCH 18/18] [1888/1] fixup! allow returning concrete type

---
 include/ginkgo/core/matrix/multivector.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/ginkgo/core/matrix/multivector.hpp b/include/ginkgo/core/matrix/multivector.hpp
index 6d3f562784e..2143d622a06 100644
--- a/include/ginkgo/core/matrix/multivector.hpp
+++ b/include/ginkgo/core/matrix/multivector.hpp
@@ -498,7 +498,7 @@ EnableMultiVector<ConcreteType>::create_with_type_of(
     ptr_param<const ConcreteType> other, std::shared_ptr<const Executor> exec)
 {
     return static_cast<const EnableMultiVector*>(other.get())
-        ->create_with_type_of_impl(std::move(exec));
+        ->create_with_type_of_impl(std::move(exec), {}, {}, 0);
 }