From a15d56f915f8f102a29fbda9eba4a0623a0bf4da Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 1 Sep 2020 17:07:06 +0200
Subject: [PATCH 01/15] add template_convertor and remove_complex for class

---
 common/base/math.hpp.inc          |   6 +-
 core/test/base/math.cpp           |  40 +++++++++++
 include/ginkgo/core/base/math.hpp | 109 +++++++++++++++++++++++++++---
 3 files changed, 146 insertions(+), 9 deletions(-)

diff --git a/common/base/math.hpp.inc b/common/base/math.hpp.inc
index 3ba49b585c3..576ab32859c 100644
--- a/common/base/math.hpp.inc
+++ b/common/base/math.hpp.inc
@@ -54,10 +54,14 @@ struct is_complex_impl<thrust::complex<T>>
     : public std::integral_constant<bool, true> {};
 
 
+template <typename T>
+struct is_complex_or_scalar_impl<thrust::complex<T>> : std::is_scalar<T> {};
+
+
 template <typename T>
 struct truncate_type_impl<thrust::complex<T>> {
     using type = thrust::complex<typename truncate_type_impl<T>::type>;
 };
 
 
-}  // namespace detail
\ No newline at end of file
+}  // namespace detail
diff --git a/core/test/base/math.cpp b/core/test/base/math.cpp
index c63cd4ae8e9..0e54c87f788 100644
--- a/core/test/base/math.cpp
+++ b/core/test/base/math.cpp
@@ -53,6 +53,10 @@ static_assert(
     "imag must return a real type");
 
 
+template <typename ValueType, typename IndexType>
+class DummyClass {};
+
+
 template <typename T>
 void test_real_is_finite()
 {
@@ -135,4 +139,40 @@ TEST(Conjugate, DoubleComplex)
 }
 
 
+TEST(RemoveComplexClass, Float)
+{
+    using origin = DummyClass<float, int>;
+    using expect = DummyClass<float, int>;
+    bool check = std::is_same<expect, gko::remove_complex<origin>>::value;
+    ASSERT_TRUE(check);
+}
+
+
+TEST(RemoveComplexClass, Double)
+{
+    using origin = DummyClass<double, int>;
+    using expect = DummyClass<double, int>;
+    bool check = std::is_same<expect, gko::remove_complex<origin>>::value;
+    ASSERT_TRUE(check);
+}
+
+
+TEST(RemoveComplexClass, FloatComplex)
+{
+    using origin = DummyClass<std::complex<float>, int>;
+    using expect = DummyClass<float, int>;
+    bool check = std::is_same<expect, gko::remove_complex<origin>>::value;
+    ASSERT_TRUE(check);
+}
+
+
+TEST(RemoveComplexClass, DoubleComplex)
+{
+    using origin = DummyClass<std::complex<double>, int>;
+    using expect = DummyClass<double, int>;
+    bool check = std::is_same<expect, gko::remove_complex<origin>>::value;
+    ASSERT_TRUE(check);
+}
+
+
 }  // namespace
diff --git a/include/ginkgo/core/base/math.hpp b/include/ginkgo/core/base/math.hpp
index 9f9dabb8f75..564635556cf 100644
--- a/include/ginkgo/core/base/math.hpp
+++ b/include/ginkgo/core/base/math.hpp
@@ -141,6 +141,65 @@ struct is_complex_impl<std::complex<T>>
     : public std::integral_constant<bool, true> {};
 
 
+template <typename T>
+struct is_complex_or_scalar_impl : std::is_scalar<T> {};
+
+template <typename T>
+struct is_complex_or_scalar_impl<std::complex<T>> : std::is_scalar<T> {};
+
+
+/**
+ * template_convertor is converting the template parameters of a class by
+ * convertor<type>.
+ *
+ * @tparam  convertor<type> which convert one type to another type
+ * @tparam  T  type
+ */
+template <template <typename> class convertor, typename T>
+struct template_convertor {};
+
+/**
+ * template_convertor is converting the template parameters of a class by
+ * convertor<type>. Converting class<T1, T2, ...> to class<convertor<T1>,
+ * convertor<T2>, convertor<...>>.
+ *
+ * @tparam  convertor<type> which convert one type to another type
+ * @tparam  template <...> T  class template base
+ * @tparam  ...Rest  the template parameter of T
+ */
+template <template <typename> class convertor, template <typename...> class T,
+          typename... Rest>
+struct template_convertor<convertor, T<Rest...>> {
+    using type = T<typename convertor<Rest>::type...>;
+};
+
+
+template <typename T, typename = void>
+struct remove_complex_s {};
+
+/**
+ * Obtains a real counterpart of a std::complex type, and leaves the type
+ * unchanged if it is not a complex type for complex/scalar type.
+ */
+template <typename T>
+struct remove_complex_s<
+    T, xstd::void_t<std::enable_if_t<is_complex_or_scalar_impl<T>::value>>> {
+    using type = typename detail::remove_complex_impl<T>::type;
+};
+
+/**
+ * Obtains a real counterpart of a class with template parameters, which
+ * converts complex parameters to real parameters.
+ */
+template <typename T>
+struct remove_complex_s<
+    T, xstd::void_t<std::enable_if_t<!is_complex_or_scalar_impl<T>::value>>> {
+    using type =
+        typename detail::template_convertor<detail::remove_complex_impl,
+                                            T>::type;
+};
+
+
 }  // namespace detail
 
 
@@ -167,14 +226,6 @@ struct cpx_real_type<std::complex<T>> {
 };
 
 
-/**
- * Obtains a real counterpart of a std::complex type, and leaves the type
- * unchanged if it is not a complex type.
- */
-template <typename T>
-using remove_complex = typename detail::remove_complex_impl<T>::type;
-
-
 /**
  * Allows to check if T is a complex value during compile time by accessing the
  * `value` attribute of this struct.
@@ -200,6 +251,48 @@ GKO_INLINE GKO_ATTRIBUTES constexpr bool is_complex()
 }
 
 
+/**
+ * Allows to check if T is a complex or scalar value during compile time by
+ * accessing the `value` attribute of this struct. If `value` is `true`, T is a
+ * complex/scalar type, if it is `false`, T is not a complex/scalar type.
+ *
+ * @tparam T  type to check
+ */
+template <typename T>
+using is_complex_or_scalar_s = detail::is_complex_or_scalar_impl<T>;
+
+/**
+ * Checks if T is a complex/scalar type.
+ *
+ * @tparam T  type to check
+ *
+ * @return `true` if T is a complex/scalar type, `false` otherwise
+ */
+template <typename T>
+GKO_INLINE GKO_ATTRIBUTES constexpr bool is_complex_or_scalar()
+{
+    return detail::is_complex_or_scalar_impl<T>::value;
+}
+
+
+/**
+ * Removes the complex of complex/scalar type or the template parameter of class
+ * by accessing the `type` attribute of this struct.
+ *
+ * @tparam T  type to remove complex
+ */
+using detail::remove_complex_s;
+
+/**
+ * Obtain the type which removed the complex of complex/scalar type or the
+ * template parameter of class by accessing the `type` attribute of this struct.
+ *
+ * @tparam T  type to remove complex
+ */
+template <typename T>
+using remove_complex = typename remove_complex_s<T>::type;
+
+
 namespace detail {
 
 

From 2351a455c86616d87ec1d82ea7b4cfcda64139c8 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 3 Sep 2020 23:49:23 +0200
Subject: [PATCH 02/15] implement absolute array

---
 common/components/absolute_array.hpp.inc     |  61 +++++++++
 core/components/absolute_array.hpp           | 109 ++++++++++++++++
 core/device_hooks/common_kernels.inc.cpp     |  11 ++
 cuda/CMakeLists.txt                          |   1 +
 cuda/components/absolute_array.cu            |  82 ++++++++++++
 cuda/test/components/CMakeLists.txt          |   1 +
 cuda/test/components/absolute_array.cpp      | 128 +++++++++++++++++++
 hip/CMakeLists.txt                           |   1 +
 hip/components/absolute_array.hip.cpp        |  86 +++++++++++++
 hip/test/components/CMakeLists.txt           |   1 +
 hip/test/components/absolute_array.hip.cpp   | 128 +++++++++++++++++++
 include/ginkgo/core/base/math.hpp            |  13 +-
 omp/CMakeLists.txt                           |   1 +
 omp/components/absolute_array.cpp            |  72 +++++++++++
 omp/test/components/CMakeLists.txt           |   1 +
 omp/test/components/absolute_array.cpp       | 128 +++++++++++++++++++
 reference/CMakeLists.txt                     |   1 +
 reference/components/absolute_array.cpp      |  70 ++++++++++
 reference/test/components/CMakeLists.txt     |   1 +
 reference/test/components/absolute_array.cpp | 102 +++++++++++++++
 20 files changed, 997 insertions(+), 1 deletion(-)
 create mode 100644 common/components/absolute_array.hpp.inc
 create mode 100644 core/components/absolute_array.hpp
 create mode 100644 cuda/components/absolute_array.cu
 create mode 100644 cuda/test/components/absolute_array.cpp
 create mode 100644 hip/components/absolute_array.hip.cpp
 create mode 100644 hip/test/components/absolute_array.hip.cpp
 create mode 100644 omp/components/absolute_array.cpp
 create mode 100644 omp/test/components/absolute_array.cpp
 create mode 100644 reference/components/absolute_array.cpp
 create mode 100644 reference/test/components/absolute_array.cpp

diff --git a/common/components/absolute_array.hpp.inc b/common/components/absolute_array.hpp.inc
new file mode 100644
index 00000000000..ee6079fb8fc
--- /dev/null
+++ b/common/components/absolute_array.hpp.inc
@@ -0,0 +1,61 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+namespace kernel {
+
+
+template <typename ValueType>
+__global__
+    __launch_bounds__(default_block_size) void inplace_absolute_array_kernel(
+        const size_type n, ValueType *__restrict__ array)
+{
+    const auto tidx = thread::get_thread_id_flat();
+    if (tidx < n) {
+        array[tidx] = abs(array[tidx]);
+    }
+}
+
+
+template <typename ValueType>
+__global__
+    __launch_bounds__(default_block_size) void outplace_absolute_array_kernel(
+        const size_type n, const ValueType *__restrict__ in,
+        remove_complex<ValueType> *__restrict__ out)
+{
+    const auto tidx = thread::get_thread_id_flat();
+    if (tidx < n) {
+        out[tidx] = abs(in[tidx]);
+    }
+}
+
+
+}  // namespace kernel
diff --git a/core/components/absolute_array.hpp b/core/components/absolute_array.hpp
new file mode 100644
index 00000000000..d48d04335fa
--- /dev/null
+++ b/core/components/absolute_array.hpp
@@ -0,0 +1,109 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#ifndef GKO_CORE_COMPONENTS_ABSOLUTE_ARRAY_HPP_
+#define GKO_CORE_COMPONENTS_ABSOLUTE_ARRAY_HPP_
+
+
+#include <memory>
+
+
+#include <ginkgo/core/base/executor.hpp>
+#include <ginkgo/core/base/math.hpp>
+#include <ginkgo/core/base/types.hpp>
+
+
+namespace gko {
+namespace kernels {
+
+
+#define GKO_DECLARE_INPLACE_ABSOLUTE_ARRAY_KERNEL(ValueType)                 \
+    void inplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec, \
+                                ValueType *data, size_type num_entries)
+
+#define GKO_DECLARE_OUTPLACE_ABSOLUTE_ARRAY_KERNEL(ValueType)                 \
+    void outplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec, \
+                                 const ValueType *in, size_type num_entries,  \
+                                 remove_complex<ValueType> *out)
+
+
+#define GKO_DECLARE_ALL_AS_TEMPLATES                      \
+    template <typename ValueType>                         \
+    GKO_DECLARE_INPLACE_ABSOLUTE_ARRAY_KERNEL(ValueType); \
+    template <typename ValueType>                         \
+    GKO_DECLARE_OUTPLACE_ABSOLUTE_ARRAY_KERNEL(ValueType)
+
+
+namespace omp {
+namespace components {
+
+GKO_DECLARE_ALL_AS_TEMPLATES;
+
+}  // namespace components
+}  // namespace omp
+
+
+namespace cuda {
+namespace components {
+
+GKO_DECLARE_ALL_AS_TEMPLATES;
+
+}  // namespace components
+}  // namespace cuda
+
+
+namespace reference {
+namespace components {
+
+GKO_DECLARE_ALL_AS_TEMPLATES;
+
+}  // namespace components
+}  // namespace reference
+
+
+namespace hip {
+namespace components {
+
+GKO_DECLARE_ALL_AS_TEMPLATES;
+
+}  // namespace components
+}  // namespace hip
+
+
+#undef GKO_DECLARE_ALL_AS_TEMPLATES
+
+
+}  // namespace kernels
+}  // namespace gko
+
+
+#endif  // GKO_CORE_COMPONENTS_ABSOLUTE_ARRAY_HPP_
diff --git a/core/device_hooks/common_kernels.inc.cpp b/core/device_hooks/common_kernels.inc.cpp
index 6adb0df0445..7015c9c644e 100644
--- a/core/device_hooks/common_kernels.inc.cpp
+++ b/core/device_hooks/common_kernels.inc.cpp
@@ -33,6 +33,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/base/exception_helpers.hpp>
 
 
+#include "core/components/absolute_array.hpp"
 #include "core/components/fill_array.hpp"
 #include "core/components/precision_conversion.hpp"
 #include "core/components/prefix_sum.hpp"
@@ -94,6 +95,16 @@ GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(GKO_DECLARE_FILL_ARRAY_KERNEL);
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_FILL_ARRAY_KERNEL);
 template GKO_DECLARE_FILL_ARRAY_KERNEL(size_type);
 
+template <typename ValueType>
+GKO_DECLARE_INPLACE_ABSOLUTE_ARRAY_KERNEL(ValueType)
+GKO_NOT_COMPILED(GKO_HOOK_MODULE);
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+template <typename ValueType>
+GKO_DECLARE_OUTPLACE_ABSOLUTE_ARRAY_KERNEL(ValueType)
+GKO_NOT_COMPILED(GKO_HOOK_MODULE);
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_ARRAY_KERNEL);
+
 
 }  // namespace components
 
diff --git a/cuda/CMakeLists.txt b/cuda/CMakeLists.txt
index 52560f7be07..d3a73ab536c 100644
--- a/cuda/CMakeLists.txt
+++ b/cuda/CMakeLists.txt
@@ -70,6 +70,7 @@ target_sources(ginkgo_cuda
     base/exception.cpp
     base/executor.cpp
     base/version.cpp
+    components/absolute_array.cu
     components/fill_array.cu
     components/precision_conversion.cu
     components/prefix_sum.cu
diff --git a/cuda/components/absolute_array.cu b/cuda/components/absolute_array.cu
new file mode 100644
index 00000000000..8ef4901bf2c
--- /dev/null
+++ b/cuda/components/absolute_array.cu
@@ -0,0 +1,82 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include "core/components/absolute_array.hpp"
+
+
+#include "cuda/base/types.hpp"
+#include "cuda/components/thread_ids.cuh"
+
+
+namespace gko {
+namespace kernels {
+namespace cuda {
+namespace components {
+
+
+constexpr int default_block_size = 512;
+
+
+#include "common/components/absolute_array.hpp.inc"
+
+
+template <typename ValueType>
+void inplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec,
+                            ValueType *data, size_type n)
+{
+    const dim3 block_size(default_block_size, 1, 1);
+    const dim3 grid_size(ceildiv(n, block_size.x), 1, 1);
+    kernel::inplace_absolute_array_kernel<<<grid_size, block_size, 0, 0>>>(
+        n, as_cuda_type(data));
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+
+template <typename ValueType>
+void outplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec,
+                             const ValueType *in, size_type n,
+                             remove_complex<ValueType> *out)
+{
+    const dim3 block_size(default_block_size, 1, 1);
+    const dim3 grid_size(ceildiv(n, block_size.x), 1, 1);
+    kernel::outplace_absolute_array_kernel<<<grid_size, block_size, 0, 0>>>(
+        n, as_cuda_type(in), as_cuda_type(out));
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+
+}  // namespace components
+}  // namespace cuda
+}  // namespace kernels
+}  // namespace gko
diff --git a/cuda/test/components/CMakeLists.txt b/cuda/test/components/CMakeLists.txt
index 154a39e963e..1d76a251948 100644
--- a/cuda/test/components/CMakeLists.txt
+++ b/cuda/test/components/CMakeLists.txt
@@ -2,6 +2,7 @@ ginkgo_create_cuda_test(cooperative_groups_kernels)
 ginkgo_create_cuda_test(merging_kernels)
 ginkgo_create_cuda_test(searching_kernels)
 ginkgo_create_cuda_test(sorting_kernels)
+ginkgo_create_test(absolute_array)
 ginkgo_create_test(fill_array)
 ginkgo_create_test(precision_conversion)
 ginkgo_create_test(prefix_sum)
diff --git a/cuda/test/components/absolute_array.cpp b/cuda/test/components/absolute_array.cpp
new file mode 100644
index 00000000000..6bdef3df6dd
--- /dev/null
+++ b/cuda/test/components/absolute_array.cpp
@@ -0,0 +1,128 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include "core/components/absolute_array.hpp"
+
+
+#include <memory>
+#include <random>
+#include <vector>
+
+
+#include <gtest/gtest.h>
+
+
+#include <ginkgo/core/base/array.hpp>
+
+
+#include "core/test/utils/assertions.hpp"
+
+
+namespace {
+
+
+class AbsoluteArray : public ::testing::Test {
+protected:
+    using value_type = double;
+    using complex_type = std::complex<double>;
+    AbsoluteArray()
+        : ref(gko::ReferenceExecutor::create()),
+          exec(gko::CudaExecutor::create(0, ref)),
+          total_size(6344),
+          vals(ref, total_size),
+          dvals(exec, total_size),
+          complex_vals(ref, total_size),
+          dcomplex_vals(exec, total_size)
+    {
+        std::fill_n(vals.get_data(), total_size, -1234.0);
+        dvals = vals;
+        std::fill_n(complex_vals.get_data(), total_size, complex_type{3, 4});
+        dcomplex_vals = complex_vals;
+    }
+
+    std::shared_ptr<gko::ReferenceExecutor> ref;
+    std::shared_ptr<gko::CudaExecutor> exec;
+    gko::size_type total_size;
+    gko::Array<value_type> vals;
+    gko::Array<value_type> dvals;
+    gko::Array<complex_type> complex_vals;
+    gko::Array<complex_type> dcomplex_vals;
+};
+
+
+TEST_F(AbsoluteArray, InplaceEqualsReference)
+{
+    gko::kernels::cuda::components::inplace_absolute_array(
+        exec, dvals.get_data(), total_size);
+    gko::kernels::reference::components::inplace_absolute_array(
+        ref, vals.get_data(), total_size);
+    GKO_ASSERT_ARRAY_EQ(vals, dvals);
+}
+
+
+TEST_F(AbsoluteArray, InplaceComplexEqualsReference)
+{
+    gko::kernels::cuda::components::inplace_absolute_array(
+        exec, dcomplex_vals.get_data(), total_size);
+    gko::kernels::reference::components::inplace_absolute_array(
+        ref, complex_vals.get_data(), total_size);
+    GKO_ASSERT_ARRAY_EQ(complex_vals, dcomplex_vals);
+}
+
+
+TEST_F(AbsoluteArray, OutplaceEqualsReference)
+{
+    gko::Array<value_type> abs_vals(ref, total_size);
+    gko::Array<value_type> dabs_vals(exec, total_size);
+
+    gko::kernels::cuda::components::outplace_absolute_array(
+        exec, dvals.get_const_data(), total_size, dabs_vals.get_data());
+    gko::kernels::reference::components::outplace_absolute_array(
+        ref, vals.get_const_data(), total_size, abs_vals.get_data());
+    GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
+}
+
+
+TEST_F(AbsoluteArray, OutplaceComplexEqualsReference)
+{
+    gko::Array<value_type> abs_vals(ref, total_size);
+    gko::Array<value_type> dabs_vals(exec, total_size);
+
+    gko::kernels::cuda::components::outplace_absolute_array(
+        exec, dcomplex_vals.get_const_data(), total_size, dabs_vals.get_data());
+    gko::kernels::reference::components::outplace_absolute_array(
+        ref, complex_vals.get_const_data(), total_size, abs_vals.get_data());
+    GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
+}
+
+
+}  // namespace
diff --git a/hip/CMakeLists.txt b/hip/CMakeLists.txt
index 57c6503ce36..20fcb0d79a0 100644
--- a/hip/CMakeLists.txt
+++ b/hip/CMakeLists.txt
@@ -143,6 +143,7 @@ set(GINKGO_HIP_SOURCES
     base/exception.hip.cpp
     base/executor.hip.cpp
     base/version.hip.cpp
+    components/absolute_array.hip.cpp
     components/fill_array.hip.cpp
     components/precision_conversion.hip.cpp
     components/prefix_sum.hip.cpp
diff --git a/hip/components/absolute_array.hip.cpp b/hip/components/absolute_array.hip.cpp
new file mode 100644
index 00000000000..3f7ee4c012c
--- /dev/null
+++ b/hip/components/absolute_array.hip.cpp
@@ -0,0 +1,86 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include "core/components/absolute_array.hpp"
+
+
+#include <hip/hip_runtime.h>
+
+
+#include "hip/base/types.hip.hpp"
+#include "hip/components/thread_ids.hip.hpp"
+
+
+namespace gko {
+namespace kernels {
+namespace hip {
+namespace components {
+
+
+constexpr int default_block_size = 512;
+
+
+#include "common/components/absolute_array.hpp.inc"
+
+
+template <typename ValueType>
+void inplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec,
+                            ValueType *data, size_type n)
+{
+    const dim3 block_size(default_block_size, 1, 1);
+    const dim3 grid_size(ceildiv(n, block_size.x), 1, 1);
+    hipLaunchKernelGGL(kernel::inplace_absolute_array_kernel, dim3(grid_size),
+                       dim3(block_size), 0, 0, n, as_hip_type(data));
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+
+template <typename ValueType>
+void outplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec,
+                             const ValueType *in, size_type n,
+                             remove_complex<ValueType> *out)
+{
+    const dim3 block_size(default_block_size, 1, 1);
+    const dim3 grid_size(ceildiv(n, block_size.x), 1, 1);
+    hipLaunchKernelGGL(kernel::outplace_absolute_array_kernel, dim3(grid_size),
+                       dim3(block_size), 0, 0, n, as_hip_type(in),
+                       as_hip_type(out));
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+
+}  // namespace components
+}  // namespace hip
+}  // namespace kernels
+}  // namespace gko
diff --git a/hip/test/components/CMakeLists.txt b/hip/test/components/CMakeLists.txt
index b3bec2595f9..f0bae60fe60 100644
--- a/hip/test/components/CMakeLists.txt
+++ b/hip/test/components/CMakeLists.txt
@@ -1,3 +1,4 @@
+ginkgo_create_hip_test(absolute_array)
 ginkgo_create_hip_test(cooperative_groups_kernels)
 ginkgo_create_hip_test(fill_array)
 ginkgo_create_hip_test(merging_kernels)
diff --git a/hip/test/components/absolute_array.hip.cpp b/hip/test/components/absolute_array.hip.cpp
new file mode 100644
index 00000000000..8df8e79109d
--- /dev/null
+++ b/hip/test/components/absolute_array.hip.cpp
@@ -0,0 +1,128 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include "core/components/absolute_array.hpp"
+
+
+#include <memory>
+#include <random>
+#include <vector>
+
+
+#include <gtest/gtest.h>
+
+
+#include <ginkgo/core/base/array.hpp>
+
+
+#include "core/test/utils/assertions.hpp"
+
+
+namespace {
+
+
+class AbsoluteArray : public ::testing::Test {
+protected:
+    using value_type = double;
+    using complex_type = std::complex<double>;
+    AbsoluteArray()
+        : ref(gko::ReferenceExecutor::create()),
+          exec(gko::HipExecutor::create(0, ref)),
+          total_size(6344),
+          vals(ref, total_size),
+          dvals(exec, total_size),
+          complex_vals(ref, total_size),
+          dcomplex_vals(exec, total_size)
+    {
+        std::fill_n(vals.get_data(), total_size, -1234.0);
+        dvals = vals;
+        std::fill_n(complex_vals.get_data(), total_size, complex_type{3, 4});
+        dcomplex_vals = complex_vals;
+    }
+
+    std::shared_ptr<gko::ReferenceExecutor> ref;
+    std::shared_ptr<gko::HipExecutor> exec;
+    gko::size_type total_size;
+    gko::Array<value_type> vals;
+    gko::Array<value_type> dvals;
+    gko::Array<complex_type> complex_vals;
+    gko::Array<complex_type> dcomplex_vals;
+};
+
+
+TEST_F(AbsoluteArray, InplaceEqualsReference)
+{
+    gko::kernels::hip::components::inplace_absolute_array(
+        exec, dvals.get_data(), total_size);
+    gko::kernels::reference::components::inplace_absolute_array(
+        ref, vals.get_data(), total_size);
+    GKO_ASSERT_ARRAY_EQ(vals, dvals);
+}
+
+
+TEST_F(AbsoluteArray, InplaceComplexEqualsReference)
+{
+    gko::kernels::hip::components::inplace_absolute_array(
+        exec, dcomplex_vals.get_data(), total_size);
+    gko::kernels::reference::components::inplace_absolute_array(
+        ref, complex_vals.get_data(), total_size);
+    GKO_ASSERT_ARRAY_EQ(complex_vals, dcomplex_vals);
+}
+
+
+TEST_F(AbsoluteArray, OutplaceEqualsReference)
+{
+    gko::Array<value_type> abs_vals(ref, total_size);
+    gko::Array<value_type> dabs_vals(exec, total_size);
+
+    gko::kernels::hip::components::outplace_absolute_array(
+        exec, dvals.get_const_data(), total_size, dabs_vals.get_data());
+    gko::kernels::reference::components::outplace_absolute_array(
+        ref, vals.get_const_data(), total_size, abs_vals.get_data());
+    GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
+}
+
+
+TEST_F(AbsoluteArray, OutplaceComplexEqualsReference)
+{
+    gko::Array<value_type> abs_vals(ref, total_size);
+    gko::Array<value_type> dabs_vals(exec, total_size);
+
+    gko::kernels::hip::components::outplace_absolute_array(
+        exec, dcomplex_vals.get_const_data(), total_size, dabs_vals.get_data());
+    gko::kernels::reference::components::outplace_absolute_array(
+        ref, complex_vals.get_const_data(), total_size, abs_vals.get_data());
+    GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
+}
+
+
+}  // namespace
diff --git a/include/ginkgo/core/base/math.hpp b/include/ginkgo/core/base/math.hpp
index 564635556cf..946b6b4608b 100644
--- a/include/ginkgo/core/base/math.hpp
+++ b/include/ginkgo/core/base/math.hpp
@@ -698,12 +698,23 @@ GKO_INLINE GKO_ATTRIBUTES constexpr T one(const T &)
  * @return x >= zero<T>() ? x : -x;
  */
 template <typename T>
-GKO_INLINE GKO_ATTRIBUTES constexpr T abs(const T &x)
+GKO_INLINE
+    GKO_ATTRIBUTES constexpr xstd::enable_if_t<!is_complex_s<T>::value, T>
+    abs(const T &x)
 {
     return x >= zero<T>() ? x : -x;
 }
 
 
+template <typename T>
+GKO_INLINE GKO_ATTRIBUTES constexpr xstd::enable_if_t<is_complex_s<T>::value,
+                                                      remove_complex<T>>
+abs(const T &x)
+{
+    return sqrt(squared_norm(x));
+}
+
+
 /**
  * Returns the larger of the arguments.
  *
diff --git a/omp/CMakeLists.txt b/omp/CMakeLists.txt
index 1f1f5aca534..bcfde819760 100644
--- a/omp/CMakeLists.txt
+++ b/omp/CMakeLists.txt
@@ -4,6 +4,7 @@ add_library(ginkgo_omp $<TARGET_OBJECTS:ginkgo_omp_device> "")
 target_sources(ginkgo_omp
     PRIVATE
     base/version.cpp
+    components/absolute_array.cpp
     components/fill_array.cpp
     components/precision_conversion.cpp
     components/prefix_sum.cpp
diff --git a/omp/components/absolute_array.cpp b/omp/components/absolute_array.cpp
new file mode 100644
index 00000000000..36d94ec8471
--- /dev/null
+++ b/omp/components/absolute_array.cpp
@@ -0,0 +1,72 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include "core/components/absolute_array.hpp"
+
+
+namespace gko {
+namespace kernels {
+namespace omp {
+namespace components {
+
+
+template <typename ValueType>
+void inplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec,
+                            ValueType *data, size_type n)
+{
+#pragma omp parallel for
+    for (size_type i = 0; i < n; ++i) {
+        data[i] = abs(data[i]);
+    }
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+
+template <typename ValueType>
+void outplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec,
+                             const ValueType *in, size_type n,
+                             remove_complex<ValueType> *out)
+{
+#pragma omp parallel for
+    for (size_type i = 0; i < n; ++i) {
+        out[i] = abs(in[i]);
+    }
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+
+}  // namespace components
+}  // namespace omp
+}  // namespace kernels
+}  // namespace gko
diff --git a/omp/test/components/CMakeLists.txt b/omp/test/components/CMakeLists.txt
index 9c1dca5bcfa..1e55ad12a4d 100644
--- a/omp/test/components/CMakeLists.txt
+++ b/omp/test/components/CMakeLists.txt
@@ -1,3 +1,4 @@
+ginkgo_create_test(absolute_array)
 ginkgo_create_test(fill_array)
 ginkgo_create_test(precision_conversion)
 ginkgo_create_test(prefix_sum)
diff --git a/omp/test/components/absolute_array.cpp b/omp/test/components/absolute_array.cpp
new file mode 100644
index 00000000000..9304def3fa9
--- /dev/null
+++ b/omp/test/components/absolute_array.cpp
@@ -0,0 +1,128 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include "core/components/absolute_array.hpp"
+
+
+#include <memory>
+#include <random>
+#include <vector>
+
+
+#include <gtest/gtest.h>
+
+
+#include <ginkgo/core/base/array.hpp>
+
+
+#include "core/test/utils.hpp"
+
+
+namespace {
+
+
+class AbsoluteArray : public ::testing::Test {
+protected:
+    using value_type = double;
+    using complex_type = std::complex<double>;
+    AbsoluteArray()
+        : ref(gko::ReferenceExecutor::create()),
+          exec(gko::OmpExecutor::create()),
+          total_size(6344),
+          vals(ref, total_size),
+          dvals(exec, total_size),
+          complex_vals(ref, total_size),
+          dcomplex_vals(exec, total_size)
+    {
+        std::fill_n(vals.get_data(), total_size, -1234.0);
+        dvals = vals;
+        std::fill_n(complex_vals.get_data(), total_size, complex_type{3, 4});
+        dcomplex_vals = complex_vals;
+    }
+
+    std::shared_ptr<gko::ReferenceExecutor> ref;
+    std::shared_ptr<gko::OmpExecutor> exec;
+    gko::size_type total_size;
+    gko::Array<value_type> vals;
+    gko::Array<value_type> dvals;
+    gko::Array<complex_type> complex_vals;
+    gko::Array<complex_type> dcomplex_vals;
+};
+
+
+TEST_F(AbsoluteArray, InplaceEqualsReference)
+{
+    gko::kernels::omp::components::inplace_absolute_array(
+        exec, dvals.get_data(), total_size);
+    gko::kernels::reference::components::inplace_absolute_array(
+        ref, vals.get_data(), total_size);
+    GKO_ASSERT_ARRAY_EQ(vals, dvals);
+}
+
+
+TEST_F(AbsoluteArray, InplaceComplexEqualsReference)
+{
+    gko::kernels::omp::components::inplace_absolute_array(
+        exec, dcomplex_vals.get_data(), total_size);
+    gko::kernels::reference::components::inplace_absolute_array(
+        ref, complex_vals.get_data(), total_size);
+    GKO_ASSERT_ARRAY_EQ(complex_vals, dcomplex_vals);
+}
+
+
+TEST_F(AbsoluteArray, OutplaceEqualsReference)
+{
+    gko::Array<value_type> abs_vals(ref, total_size);
+    gko::Array<value_type> dabs_vals(exec, total_size);
+
+    gko::kernels::omp::components::outplace_absolute_array(
+        exec, dvals.get_const_data(), total_size, dabs_vals.get_data());
+    gko::kernels::reference::components::outplace_absolute_array(
+        ref, vals.get_const_data(), total_size, abs_vals.get_data());
+    GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
+}
+
+
+TEST_F(AbsoluteArray, OutplaceComplexEqualsReference)
+{
+    gko::Array<value_type> abs_vals(ref, total_size);
+    gko::Array<value_type> dabs_vals(exec, total_size);
+
+    gko::kernels::omp::components::outplace_absolute_array(
+        exec, dcomplex_vals.get_const_data(), total_size, dabs_vals.get_data());
+    gko::kernels::reference::components::outplace_absolute_array(
+        ref, complex_vals.get_const_data(), total_size, abs_vals.get_data());
+    GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
+}
+
+
+}  // namespace
diff --git a/reference/CMakeLists.txt b/reference/CMakeLists.txt
index e4bcd9ee2c2..f92060c036c 100644
--- a/reference/CMakeLists.txt
+++ b/reference/CMakeLists.txt
@@ -2,6 +2,7 @@ add_library(ginkgo_reference $<TARGET_OBJECTS:ginkgo_reference_device> "")
 target_sources(ginkgo_reference
     PRIVATE
     base/version.cpp
+    components/absolute_array.cpp
     components/fill_array.cpp
     components/precision_conversion.cpp
     components/prefix_sum.cpp
diff --git a/reference/components/absolute_array.cpp b/reference/components/absolute_array.cpp
new file mode 100644
index 00000000000..688945886f9
--- /dev/null
+++ b/reference/components/absolute_array.cpp
@@ -0,0 +1,70 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include "core/components/absolute_array.hpp"
+
+
+namespace gko {
+namespace kernels {
+namespace reference {
+namespace components {
+
+
+template <typename ValueType>
+void inplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec,
+                            ValueType *data, size_type n)
+{
+    for (size_type i = 0; i < n; i++) {
+        data[i] = abs(data[i]);
+    }
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+
+template <typename ValueType>
+void outplace_absolute_array(std::shared_ptr<const DefaultExecutor> exec,
+                             const ValueType *in, size_type n,
+                             remove_complex<ValueType> *out)
+{
+    for (size_type i = 0; i < n; i++) {
+        out[i] = abs(in[i]);
+    }
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_ARRAY_KERNEL);
+
+
+}  // namespace components
+}  // namespace reference
+}  // namespace kernels
+}  // namespace gko
diff --git a/reference/test/components/CMakeLists.txt b/reference/test/components/CMakeLists.txt
index 9c1dca5bcfa..1e55ad12a4d 100644
--- a/reference/test/components/CMakeLists.txt
+++ b/reference/test/components/CMakeLists.txt
@@ -1,3 +1,4 @@
+ginkgo_create_test(absolute_array)
 ginkgo_create_test(fill_array)
 ginkgo_create_test(precision_conversion)
 ginkgo_create_test(prefix_sum)
diff --git a/reference/test/components/absolute_array.cpp b/reference/test/components/absolute_array.cpp
new file mode 100644
index 00000000000..1c2f2952551
--- /dev/null
+++ b/reference/test/components/absolute_array.cpp
@@ -0,0 +1,102 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2020, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include "core/components/absolute_array.hpp"
+
+
+#include <memory>
+#include <random>
+#include <vector>
+
+
+#include <gtest/gtest.h>
+
+
+#include <ginkgo/core/base/array.hpp>
+#include <ginkgo/core/base/math.hpp>
+
+
+#include "core/test/utils.hpp"
+
+
+namespace {
+
+
+template <typename T>
+class AbsoluteArray : public ::testing::Test {
+protected:
+    using value_type = T;
+    using abs_type = gko::remove_complex<T>;
+    AbsoluteArray()
+        : ref(gko::ReferenceExecutor::create()),
+          total_size(6344),
+          inplace_expected(ref, total_size),
+          outplace_expected(ref, total_size),
+          vals(ref, total_size)
+    {
+        std::fill_n(inplace_expected.get_data(), total_size, T(6453));
+        std::fill_n(vals.get_data(), total_size, T(-6453));
+        std::fill_n(outplace_expected.get_data(), total_size, abs_type(6453));
+    }
+
+    std::shared_ptr<gko::ReferenceExecutor> ref;
+    gko::size_type total_size;
+    gko::Array<value_type> inplace_expected;
+    gko::Array<abs_type> outplace_expected;
+    gko::Array<value_type> vals;
+};
+
+TYPED_TEST_CASE(AbsoluteArray, gko::test::ValueTypes);
+
+
+TYPED_TEST(AbsoluteArray, InplaceEqualsReference)
+{
+    using T = typename TestFixture::value_type;
+    gko::kernels::reference::components::inplace_absolute_array(
+        this->ref, this->vals.get_data(), this->total_size);
+    GKO_ASSERT_ARRAY_EQ(this->vals, this->inplace_expected);
+}
+
+
+TYPED_TEST(AbsoluteArray, OutplaceEqualsReference)
+{
+    using T = typename TestFixture::value_type;
+    using AbsT = typename TestFixture::abs_type;
+    gko::Array<AbsT> abs_vals(this->ref, this->total_size);
+    gko::kernels::reference::components::outplace_absolute_array(
+        this->ref, this->vals.get_const_data(), this->total_size,
+        abs_vals.get_data());
+    GKO_ASSERT_ARRAY_EQ(abs_vals, this->outplace_expected);
+}
+
+
+}  // namespace

From 3c5d7ff6a338e1463624a859207f587825d541e2 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 4 Sep 2020 13:18:47 +0200
Subject: [PATCH 03/15] implement Csr absolute

---
 core/matrix/csr.cpp                   | 36 +++++++++++-
 cuda/test/matrix/csr_kernels.cpp      | 46 ++++++++++++++-
 hip/test/matrix/csr_kernels.hip.cpp   | 60 +++++++++++++++++++-
 include/ginkgo/core/base/lin_op.hpp   | 36 ++++++++++++
 include/ginkgo/core/base/math.hpp     | 64 +++++++++++++++++++++
 include/ginkgo/core/matrix/csr.hpp    | 17 +++++-
 omp/test/matrix/csr_kernels.cpp       | 44 +++++++++++++++
 reference/test/matrix/csr_kernels.cpp | 80 +++++++++++++++++++++++++--
 8 files changed, 374 insertions(+), 9 deletions(-)

diff --git a/core/matrix/csr.cpp b/core/matrix/csr.cpp
index 1863eea2959..0a51503c5f0 100644
--- a/core/matrix/csr.cpp
+++ b/core/matrix/csr.cpp
@@ -46,6 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/matrix/sparsity_csr.hpp>
 
 
+#include "core/components/absolute_array.hpp"
 #include "core/components/fill_array.hpp"
 #include "core/matrix/csr_kernels.hpp"
 
@@ -81,7 +82,10 @@ GKO_REGISTER_OPERATION(is_sorted_by_column_index,
                        csr::is_sorted_by_column_index);
 GKO_REGISTER_OPERATION(extract_diagonal, csr::extract_diagonal);
 GKO_REGISTER_OPERATION(fill_array, components::fill_array);
-
+GKO_REGISTER_OPERATION(inplace_absolute_array,
+                       components::inplace_absolute_array);
+GKO_REGISTER_OPERATION(outplace_absolute_array,
+                       components::outplace_absolute_array);
 
 }  // namespace csr
 
@@ -482,6 +486,36 @@ Csr<ValueType, IndexType>::extract_diagonal() const
 }
 
 
+template <typename ValueType, typename IndexType>
+void Csr<ValueType, IndexType>::turn_absolute()
+{
+    auto exec = this->get_executor();
+
+    exec->run(csr::make_inplace_absolute_array(
+        this->get_values(), this->get_num_stored_elements()));
+}
+
+
+template <typename ValueType, typename IndexType>
+std::unique_ptr<typename Csr<ValueType, IndexType>::outplace_absolute_type>
+Csr<ValueType, IndexType>::get_absolute() const
+{
+    auto exec = this->get_executor();
+
+    auto abs_csr = outplace_absolute_type::create(
+        exec, this->get_size(), this->get_num_stored_elements());
+
+    abs_csr->col_idxs_ = col_idxs_;
+    abs_csr->row_ptrs_ = row_ptrs_;
+    exec->run(csr::make_outplace_absolute_array(this->get_const_values(),
+                                                this->get_num_stored_elements(),
+                                                abs_csr->get_values()));
+
+    convert_strategy_helper(abs_csr.get());
+    return abs_csr;
+}
+
+
 #define GKO_DECLARE_CSR_MATRIX(ValueType, IndexType) \
     class Csr<ValueType, IndexType>
 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_CSR_MATRIX);
diff --git a/cuda/test/matrix/csr_kernels.cpp b/cuda/test/matrix/csr_kernels.cpp
index 2f1bb544ac3..b05ca46327c 100644
--- a/cuda/test/matrix/csr_kernels.cpp
+++ b/cuda/test/matrix/csr_kernels.cpp
@@ -60,8 +60,8 @@ namespace {
 
 class Csr : public ::testing::Test {
 protected:
-    using Mtx = gko::matrix::Csr<>;
     using Vec = gko::matrix::Dense<>;
+    using Mtx = gko::matrix::Csr<>;
     using ComplexVec = gko::matrix::Dense<std::complex<double>>;
     using ComplexMtx = gko::matrix::Csr<std::complex<double>>;
 
@@ -740,4 +740,48 @@ TEST_F(Csr, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data(std::make_shared<Mtx::automatical>(cuda));
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data(std::make_shared<Mtx::automatical>(cuda));
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
+{
+    set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(cuda));
+
+    complex_mtx->turn_absolute();
+    complex_dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
+{
+    set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(cuda));
+
+    auto abs_mtx = complex_mtx->get_absolute();
+    auto dabs_mtx = complex_dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/hip/test/matrix/csr_kernels.hip.cpp b/hip/test/matrix/csr_kernels.hip.cpp
index 14ec43d6a4a..4a55b6a6ef8 100644
--- a/hip/test/matrix/csr_kernels.hip.cpp
+++ b/hip/test/matrix/csr_kernels.hip.cpp
@@ -60,8 +60,10 @@ namespace {
 
 class Csr : public ::testing::Test {
 protected:
-    using Mtx = gko::matrix::Csr<>;
     using Vec = gko::matrix::Dense<>;
+    using Mtx = gko::matrix::Csr<>;
+    using ComplexVec = gko::matrix::Dense<std::complex<double>>;
+    using ComplexMtx = gko::matrix::Csr<std::complex<double>>;
 
     Csr() : mtx_size(532, 231), rand_engine(42) {}
 
@@ -114,6 +116,16 @@ class Csr : public ::testing::Test {
         dbeta->copy_from(beta.get());
     }
 
+    void set_up_apply_complex_data(
+        std::shared_ptr<ComplexMtx::strategy_type> strategy)
+    {
+        complex_mtx = ComplexMtx::create(ref, strategy);
+        complex_mtx->copy_from(
+            gen_mtx<ComplexVec>(mtx_size[0], mtx_size[1], 1));
+        complex_dmtx = ComplexMtx::create(hip, strategy);
+        complex_dmtx->copy_from(complex_mtx.get());
+    }
+
     struct matrix_pair {
         std::unique_ptr<Mtx> ref;
         std::unique_ptr<Mtx> hip;
@@ -153,6 +165,7 @@ class Csr : public ::testing::Test {
     std::ranlux48 rand_engine;
 
     std::unique_ptr<Mtx> mtx;
+    std::unique_ptr<ComplexMtx> complex_mtx;
     std::unique_ptr<Mtx> square_mtx;
     std::unique_ptr<Vec> expected;
     std::unique_ptr<Vec> y;
@@ -160,6 +173,7 @@ class Csr : public ::testing::Test {
     std::unique_ptr<Vec> beta;
 
     std::unique_ptr<Mtx> dmtx;
+    std::unique_ptr<ComplexMtx> complex_dmtx;
     std::unique_ptr<Mtx> square_dmtx;
     std::unique_ptr<Vec> dresult;
     std::unique_ptr<Vec> dy;
@@ -711,4 +725,48 @@ TEST_F(Csr, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data(std::make_shared<Mtx::automatical>(hip));
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data(std::make_shared<Mtx::automatical>(hip));
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
+{
+    set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(hip));
+
+    complex_mtx->turn_absolute();
+    complex_dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
+{
+    set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(hip));
+
+    auto abs_mtx = complex_mtx->get_absolute();
+    auto dabs_mtx = complex_dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/include/ginkgo/core/base/lin_op.hpp b/include/ginkgo/core/base/lin_op.hpp
index dcf5a1a88cf..2a38b84d31a 100644
--- a/include/ginkgo/core/base/lin_op.hpp
+++ b/include/ginkgo/core/base/lin_op.hpp
@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/base/abstract_factory.hpp>
 #include <ginkgo/core/base/dim.hpp>
 #include <ginkgo/core/base/exception_helpers.hpp>
+#include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/matrix_data.hpp>
 #include <ginkgo/core/base/polymorphic_object.hpp>
 #include <ginkgo/core/base/types.hpp>
@@ -622,6 +623,41 @@ class DiagonalExtractable {
         const = 0;
 };
 
+
+/**
+ * The EnableAbsoluteComputation mixin implementing this interface can be
+ * computed. get_absolute gets a new LinOp which contains absolute values from a
+ * LinOp and the valuetype will be removed complex. turn_absolute applies
+ * absolute inplace, so it still keeps the valuetype of the class.
+ *
+ * @tparam ConcreteLinOp  the concrete LinOp which is being implemented
+ *                        [CRTP parameter]
+ *
+ * @ingroup LinOp
+ */
+template <typename ConcreteLinOp>
+class EnableAbsoluteComputation {
+public:
+    using outplace_type = remove_complex<ConcreteLinOp>;
+
+    virtual ~EnableAbsoluteComputation() = default;
+
+    /**
+     * Gets the absolute LinOp
+     *
+     * @return a pointer to the new absolute object
+     */
+    virtual std::unique_ptr<outplace_type> get_absolute() const = 0;
+
+    /**
+     * Turns the value
+     *
+     * @return a pointer to the new absolute object
+     */
+    virtual void turn_absolute() = 0;
+};
+
+
 /**
  * The EnableLinOp mixin can be used to provide sensible default implementations
  * of the majority of the LinOp and PolymorphicObject interface.
diff --git a/include/ginkgo/core/base/math.hpp b/include/ginkgo/core/base/math.hpp
index 946b6b4608b..ce62ed82e7f 100644
--- a/include/ginkgo/core/base/math.hpp
+++ b/include/ginkgo/core/base/math.hpp
@@ -133,6 +133,27 @@ struct remove_complex_impl<std::complex<T>> {
 };
 
 
+/**
+ * Use the complex type if it is not complex.
+ *
+ * @tparam T  the type being made complex
+ */
+template <typename T>
+struct make_complex_impl {
+    using type = std::complex<T>;
+};
+
+/**
+ * Use the same type if it is complex type.
+ *
+ * @tparam T  the type being made complex
+ */
+template <typename T>
+struct make_complex_impl<std::complex<T>> {
+    using type = std::complex<T>;
+};
+
+
 template <typename T>
 struct is_complex_impl : public std::integral_constant<bool, false> {};
 
@@ -200,6 +221,31 @@ struct remove_complex_s<
 };
 
 
+template <typename T, typename = void>
+struct make_complex_s {};
+
+/**
+ * Obtains a complex counterpart of a real type, and leaves the type
+ * unchanged if it is a complex type for complex/scalar type.
+ */
+template <typename T>
+struct make_complex_s<
+    T, xstd::void_t<std::enable_if_t<is_complex_or_scalar_impl<T>::value>>> {
+    using type = typename detail::make_complex_impl<T>::type;
+};
+
+/**
+ * Obtains a complex counterpart of a class with template parameters, which
+ * converts real parameters to complex parameters.
+ */
+template <typename T>
+struct make_complex_s<
+    T, xstd::void_t<std::enable_if_t<!is_complex_or_scalar_impl<T>::value>>> {
+    using type =
+        typename detail::template_convertor<detail::make_complex_impl, T>::type;
+};
+
+
 }  // namespace detail
 
 
@@ -293,6 +339,24 @@ template <typename T>
 using remove_complex = typename remove_complex_s<T>::type;
 
 
+/**
+ * Removes the complex of complex/scalar type or the template parameter of class
+ * by accessing the `type` attribute of this struct.
+ *
+ * @tparam T  type to remove complex
+ */
+using detail::make_complex_s;
+
+/**
+ * Obtain the type which removed the complex of complex/scalar type or the
+ * template parameter of class by accessing the `type` attribute of this struct.
+ *
+ * @tparam T  type to remove complex
+ */
+template <typename T>
+using make_complex = typename make_complex_s<T>::type;
+
+
 namespace detail {
 
 
diff --git a/include/ginkgo/core/matrix/csr.hpp b/include/ginkgo/core/matrix/csr.hpp
index 11ef09907fb..ad9d77ee907 100644
--- a/include/ginkgo/core/matrix/csr.hpp
+++ b/include/ginkgo/core/matrix/csr.hpp
@@ -36,6 +36,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <ginkgo/core/base/array.hpp>
 #include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/base/math.hpp>
 
 
 namespace gko {
@@ -129,7 +130,8 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
             public ReadableFromMatrixData<ValueType, IndexType>,
             public WritableToMatrixData<ValueType, IndexType>,
             public Transposable,
-            public Permutable<IndexType> {
+            public Permutable<IndexType>,
+            public EnableAbsoluteComputation<Csr<ValueType, IndexType>> {
     friend class EnableCreateMethod<Csr>;
     friend class EnablePolymorphicObject<Csr, LinOp>;
     friend class Coo<ValueType, IndexType>;
@@ -139,12 +141,21 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
     friend class Sellp<ValueType, IndexType>;
     friend class SparsityCsr<ValueType, IndexType>;
     friend class CsrBuilder<ValueType, IndexType>;
+    friend class Csr<make_complex<ValueType>, IndexType>;
+    // friend make_complex<Csr>;
+    //   error: can not recognize it is class correctly.
+    // friend class make_complex<Csr>;
+    //   error: using alias template specialization
+    // friend class make_complex_s<Csr<ValueType,IndexType>>::type;
+    //   error: can not recognize it is class correctly.
 
 public:
     using value_type = ValueType;
     using index_type = IndexType;
     using transposed_type = Csr<ValueType, IndexType>;
     using mat_data = matrix_data<ValueType, IndexType>;
+    using outplace_absolute_type =
+        typename EnableAbsoluteComputation<Csr>::outplace_type;
 
     class automatical;
 
@@ -701,6 +712,10 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
+    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+
+    void turn_absolute() override;
+
     /**
      * Sorts all (value, col_idx) pairs in each row by column index
      */
diff --git a/omp/test/matrix/csr_kernels.cpp b/omp/test/matrix/csr_kernels.cpp
index 745ad71a5f0..9674b2da1e3 100644
--- a/omp/test/matrix/csr_kernels.cpp
+++ b/omp/test/matrix/csr_kernels.cpp
@@ -549,4 +549,48 @@ TEST_F(Csr, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    complex_mtx->turn_absolute();
+    complex_dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = complex_mtx->get_absolute();
+    auto dabs_mtx = complex_dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/reference/test/matrix/csr_kernels.cpp b/reference/test/matrix/csr_kernels.cpp
index dbf8423b910..aef675a9f13 100644
--- a/reference/test/matrix/csr_kernels.cpp
+++ b/reference/test/matrix/csr_kernels.cpp
@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/base/array.hpp>
 #include <ginkgo/core/base/exception.hpp>
 #include <ginkgo/core/base/executor.hpp>
+#include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/matrix/coo.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/diagonal.hpp>
@@ -1306,6 +1307,34 @@ TYPED_TEST(Csr, ExtractsDiagonal)
 }
 
 
+TYPED_TEST(Csr, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+    ASSERT_EQ(mtx->get_strategy()->get_name(),
+              abs_mtx->get_strategy()->get_name());
+}
+
+
+TYPED_TEST(Csr, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
 template <typename ValueIndexType>
 class CsrComplex : public ::testing::Test {
 protected:
@@ -1323,14 +1352,13 @@ TYPED_TEST(CsrComplex, MtxIsConjugateTransposable)
 {
     using Csr = typename TestFixture::Mtx;
     using T = typename TestFixture::value_type;
-    using value_type = typename TestFixture::value_type;
 
     auto exec = gko::ReferenceExecutor::create();
     // clang-format off
-        auto mtx2 = gko::initialize<Csr>(
-            {{T{1.0, 2.0}, T{3.0, 0.0}, T{2.0, 0.0}},
-             {T{0.0, 0.0}, T{5.0, - 3.5}, T{0.0,0.0}},
-             {T{0.0, 0.0}, T{0.0, 1.5}, T{2.0,0.0}}}, exec);
+    auto mtx2 = gko::initialize<Csr>(
+        {{T{1.0, 2.0}, T{3.0, 0.0}, T{2.0, 0.0}},
+         {T{0.0, 0.0}, T{5.0, - 3.5}, T{0.0,0.0}},
+         {T{0.0, 0.0}, T{0.0, 1.5}, T{2.0,0.0}}}, exec);
     // clang-format on
 
     auto trans = mtx2->conj_transpose();
@@ -1345,4 +1373,46 @@ TYPED_TEST(CsrComplex, MtxIsConjugateTransposable)
 }
 
 
+TYPED_TEST(CsrComplex, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+    ASSERT_EQ(mtx->get_strategy()->get_name(),
+              abs_mtx->get_strategy()->get_name());
+}
+
+
+TYPED_TEST(CsrComplex, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
 }  // namespace

From 648a6a8ad2f07c780acefb7500824f3bf1568509 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 4 Sep 2020 14:16:58 +0200
Subject: [PATCH 04/15] always use bigobj

---
 .github/workflows/windows-build.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/windows-build.yml b/.github/workflows/windows-build.yml
index c1bda6bc2f3..126a029e942 100644
--- a/.github/workflows/windows-build.yml
+++ b/.github/workflows/windows-build.yml
@@ -22,6 +22,9 @@ jobs:
       if: matrix.config.version == 'latest'
       run: |
         choco install cuda -y
+    - name: bigobj_env
+      run: |
+        echo "::set-env name=CXXFLAGS::/bigobj"
     - name: configure
       run: |
         $env:ChocolateyInstall = Convert-Path "$((Get-Command choco).Path)\..\.."
@@ -51,8 +54,7 @@ jobs:
       run: |
         echo "::set-env name=origin_path::$env:PATH"
         echo "::add-path::$pwd\build\windows_shared_library"
-    - name: debug_env
-      if: matrix.config.build_type == 'Debug'
+    - name: bigobj_env
       run: |
         echo "::set-env name=CXXFLAGS::/bigobj"
     - name: configure

From 728b7f41595d3e10a91a2ccd6d35aa6c96daf339 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 4 Sep 2020 15:54:28 +0200
Subject: [PATCH 05/15] coo/ell/sellp/hybrid/diagonal absolute

---
 core/matrix/coo.cpp                        | 34 ++++++++++
 core/matrix/diagonal.cpp                   | 32 +++++++++
 core/matrix/ell.cpp                        | 34 ++++++++++
 core/matrix/hybrid.cpp                     | 33 +++++++++
 core/matrix/sellp.cpp                      | 36 ++++++++++
 cuda/test/matrix/coo_kernels.cpp           | 22 ++++++
 cuda/test/matrix/diagonal_kernels.cpp      | 22 ++++++
 cuda/test/matrix/ell_kernels.cpp           | 22 ++++++
 cuda/test/matrix/hybrid_kernels.cpp        | 22 ++++++
 cuda/test/matrix/sellp_kernels.cpp         | 22 ++++++
 hip/test/matrix/coo_kernels.hip.cpp        | 22 ++++++
 hip/test/matrix/diagonal_kernels.hip.cpp   | 22 ++++++
 hip/test/matrix/ell_kernels.hip.cpp        | 22 ++++++
 hip/test/matrix/hybrid_kernels.hip.cpp     | 22 ++++++
 hip/test/matrix/sellp_kernels.hip.cpp      | 22 ++++++
 include/ginkgo/core/matrix/coo.hpp         | 10 ++-
 include/ginkgo/core/matrix/diagonal.hpp    | 10 ++-
 include/ginkgo/core/matrix/ell.hpp         | 10 ++-
 include/ginkgo/core/matrix/hybrid.hpp      | 12 +++-
 include/ginkgo/core/matrix/sellp.hpp       | 10 ++-
 omp/test/matrix/coo_kernels.cpp            | 22 ++++++
 omp/test/matrix/diagonal_kernels.cpp       | 22 ++++++
 omp/test/matrix/ell_kernels.cpp            | 22 ++++++
 omp/test/matrix/hybrid_kernels.cpp         | 22 ++++++
 omp/test/matrix/sellp_kernels.cpp          | 22 ++++++
 reference/test/matrix/coo_kernels.cpp      | 79 ++++++++++++++++++++++
 reference/test/matrix/csr_kernels.cpp      | 32 ++++-----
 reference/test/matrix/diagonal_kernels.cpp | 67 ++++++++++++++++++
 reference/test/matrix/ell_kernels.cpp      | 79 ++++++++++++++++++++++
 reference/test/matrix/hybrid_kernels.cpp   | 79 ++++++++++++++++++++++
 reference/test/matrix/sellp_kernels.cpp    | 79 ++++++++++++++++++++++
 31 files changed, 945 insertions(+), 21 deletions(-)

diff --git a/core/matrix/coo.cpp b/core/matrix/coo.cpp
index dd5a4dda553..ecff61e6d4e 100644
--- a/core/matrix/coo.cpp
+++ b/core/matrix/coo.cpp
@@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/matrix/dense.hpp>
 
 
+#include "core/components/absolute_array.hpp"
 #include "core/components/fill_array.hpp"
 #include "core/matrix/coo_kernels.hpp"
 
@@ -64,6 +65,10 @@ GKO_REGISTER_OPERATION(convert_to_csr, coo::convert_to_csr);
 GKO_REGISTER_OPERATION(convert_to_dense, coo::convert_to_dense);
 GKO_REGISTER_OPERATION(extract_diagonal, coo::extract_diagonal);
 GKO_REGISTER_OPERATION(fill_array, components::fill_array);
+GKO_REGISTER_OPERATION(inplace_absolute_array,
+                       components::inplace_absolute_array);
+GKO_REGISTER_OPERATION(outplace_absolute_array,
+                       components::outplace_absolute_array);
 
 
 }  // namespace coo
@@ -233,6 +238,35 @@ Coo<ValueType, IndexType>::extract_diagonal() const
 }
 
 
+template <typename ValueType, typename IndexType>
+void Coo<ValueType, IndexType>::turn_absolute()
+{
+    auto exec = this->get_executor();
+
+    exec->run(coo::make_inplace_absolute_array(
+        this->get_values(), this->get_num_stored_elements()));
+}
+
+
+template <typename ValueType, typename IndexType>
+std::unique_ptr<typename Coo<ValueType, IndexType>::outplace_absolute_type>
+Coo<ValueType, IndexType>::get_absolute() const
+{
+    auto exec = this->get_executor();
+
+    auto abs_coo = outplace_absolute_type::create(
+        exec, this->get_size(), this->get_num_stored_elements());
+
+    abs_coo->col_idxs_ = col_idxs_;
+    abs_coo->row_idxs_ = row_idxs_;
+    exec->run(coo::make_outplace_absolute_array(this->get_const_values(),
+                                                this->get_num_stored_elements(),
+                                                abs_coo->get_values()));
+
+    return abs_coo;
+}
+
+
 #define GKO_DECLARE_COO_MATRIX(ValueType, IndexType) \
     class Coo<ValueType, IndexType>
 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_COO_MATRIX);
diff --git a/core/matrix/diagonal.cpp b/core/matrix/diagonal.cpp
index 04130cd4604..83b8d826019 100644
--- a/core/matrix/diagonal.cpp
+++ b/core/matrix/diagonal.cpp
@@ -38,6 +38,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/matrix/dense.hpp>
 
 
+#include "core/components/absolute_array.hpp"
 #include "core/matrix/diagonal_kernels.hpp"
 
 
@@ -52,6 +53,10 @@ GKO_REGISTER_OPERATION(apply_to_csr, diagonal::apply_to_csr);
 GKO_REGISTER_OPERATION(right_apply_to_csr, diagonal::right_apply_to_csr);
 GKO_REGISTER_OPERATION(convert_to_csr, diagonal::convert_to_csr);
 GKO_REGISTER_OPERATION(conj_transpose, diagonal::conj_transpose);
+GKO_REGISTER_OPERATION(inplace_absolute_array,
+                       components::inplace_absolute_array);
+GKO_REGISTER_OPERATION(outplace_absolute_array,
+                       components::outplace_absolute_array);
 
 
 }  // namespace diagonal
@@ -261,6 +266,33 @@ void Diagonal<ValueType>::write(mat_data32 &data) const
 }
 
 
+template <typename ValueType>
+void Diagonal<ValueType>::turn_absolute()
+{
+    auto exec = this->get_executor();
+
+    exec->run(diagonal::make_inplace_absolute_array(this->get_values(),
+                                                    this->get_size()[0]));
+}
+
+
+template <typename ValueType>
+std::unique_ptr<typename Diagonal<ValueType>::outplace_absolute_type>
+Diagonal<ValueType>::get_absolute() const
+{
+    auto exec = this->get_executor();
+
+    auto abs_diagonal =
+        outplace_absolute_type::create(exec, this->get_size()[0]);
+
+    exec->run(diagonal::make_outplace_absolute_array(
+        this->get_const_values(), this->get_size()[0],
+        abs_diagonal->get_values()));
+
+    return abs_diagonal;
+}
+
+
 #define GKO_DECLARE_DIAGONAL_MATRIX(value_type) class Diagonal<value_type>
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_DIAGONAL_MATRIX);
 
diff --git a/core/matrix/ell.cpp b/core/matrix/ell.cpp
index 5f7591421e1..a16ec65631b 100644
--- a/core/matrix/ell.cpp
+++ b/core/matrix/ell.cpp
@@ -44,6 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/matrix/dense.hpp>
 
 
+#include "core/components/absolute_array.hpp"
 #include "core/components/fill_array.hpp"
 #include "core/matrix/ell_kernels.hpp"
 
@@ -62,6 +63,10 @@ GKO_REGISTER_OPERATION(calculate_nonzeros_per_row,
                        ell::calculate_nonzeros_per_row);
 GKO_REGISTER_OPERATION(extract_diagonal, ell::extract_diagonal);
 GKO_REGISTER_OPERATION(fill_array, components::fill_array);
+GKO_REGISTER_OPERATION(inplace_absolute_array,
+                       components::inplace_absolute_array);
+GKO_REGISTER_OPERATION(outplace_absolute_array,
+                       components::outplace_absolute_array);
 
 
 }  // namespace ell
@@ -251,6 +256,35 @@ Ell<ValueType, IndexType>::extract_diagonal() const
 }
 
 
+template <typename ValueType, typename IndexType>
+void Ell<ValueType, IndexType>::turn_absolute()
+{
+    auto exec = this->get_executor();
+
+    exec->run(ell::make_inplace_absolute_array(
+        this->get_values(), this->get_num_stored_elements()));
+}
+
+
+template <typename ValueType, typename IndexType>
+std::unique_ptr<typename Ell<ValueType, IndexType>::outplace_absolute_type>
+Ell<ValueType, IndexType>::get_absolute() const
+{
+    auto exec = this->get_executor();
+
+    auto abs_ell = outplace_absolute_type::create(
+        exec, this->get_size(), this->get_num_stored_elements_per_row(),
+        this->get_stride());
+
+    abs_ell->col_idxs_ = col_idxs_;
+    exec->run(ell::make_outplace_absolute_array(this->get_const_values(),
+                                                this->get_num_stored_elements(),
+                                                abs_ell->get_values()));
+
+    return abs_ell;
+}
+
+
 #define GKO_DECLARE_ELL_MATRIX(ValueType, IndexType) \
     class Ell<ValueType, IndexType>
 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_ELL_MATRIX);
diff --git a/core/matrix/hybrid.cpp b/core/matrix/hybrid.cpp
index d5f012b79c7..b6d9552c9e5 100644
--- a/core/matrix/hybrid.cpp
+++ b/core/matrix/hybrid.cpp
@@ -43,6 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/matrix/dense.hpp>
 
 
+#include "core/components/absolute_array.hpp"
 #include "core/components/fill_array.hpp"
 #include "core/matrix/coo_kernels.hpp"
 #include "core/matrix/ell_kernels.hpp"
@@ -60,6 +61,10 @@ GKO_REGISTER_OPERATION(count_nonzeros, hybrid::count_nonzeros);
 GKO_REGISTER_OPERATION(extract_coo_diagonal, coo::extract_diagonal);
 GKO_REGISTER_OPERATION(extract_ell_diagonal, ell::extract_diagonal);
 GKO_REGISTER_OPERATION(fill_array, components::fill_array);
+GKO_REGISTER_OPERATION(inplace_absolute_array,
+                       components::inplace_absolute_array);
+GKO_REGISTER_OPERATION(outplace_absolute_array,
+                       components::outplace_absolute_array);
 
 
 }  // namespace hybrid
@@ -285,6 +290,34 @@ Hybrid<ValueType, IndexType>::extract_diagonal() const
 }
 
 
+template <typename ValueType, typename IndexType>
+void Hybrid<ValueType, IndexType>::turn_absolute()
+{
+    auto exec = this->get_executor();
+
+    exec->run(hybrid::make_inplace_absolute_array(
+        this->get_ell_values(), this->get_ell_num_stored_elements()));
+    exec->run(hybrid::make_inplace_absolute_array(
+        this->get_coo_values(), this->get_coo_num_stored_elements()));
+}
+
+
+template <typename ValueType, typename IndexType>
+std::unique_ptr<typename Hybrid<ValueType, IndexType>::outplace_absolute_type>
+Hybrid<ValueType, IndexType>::get_absolute() const
+{
+    auto exec = this->get_executor();
+
+    // use default strategy
+    auto abs_hybrid = outplace_absolute_type::create(exec, this->get_size());
+
+    abs_hybrid->ell_->copy_from(ell_->get_absolute());
+    abs_hybrid->coo_->copy_from(coo_->get_absolute());
+
+    return abs_hybrid;
+}
+
+
 #define GKO_DECLARE_HYBRID_MATRIX(ValueType, IndexType) \
     class Hybrid<ValueType, IndexType>
 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_HYBRID_MATRIX);
diff --git a/core/matrix/sellp.cpp b/core/matrix/sellp.cpp
index 7164af154f4..916d531d072 100644
--- a/core/matrix/sellp.cpp
+++ b/core/matrix/sellp.cpp
@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include "core/base/allocator.hpp"
+#include "core/components/absolute_array.hpp"
 #include "core/components/fill_array.hpp"
 #include "core/matrix/sellp_kernels.hpp"
 
@@ -58,6 +59,10 @@ GKO_REGISTER_OPERATION(convert_to_csr, sellp::convert_to_csr);
 GKO_REGISTER_OPERATION(count_nonzeros, sellp::count_nonzeros);
 GKO_REGISTER_OPERATION(extract_diagonal, sellp::extract_diagonal);
 GKO_REGISTER_OPERATION(fill_array, components::fill_array);
+GKO_REGISTER_OPERATION(inplace_absolute_array,
+                       components::inplace_absolute_array);
+GKO_REGISTER_OPERATION(outplace_absolute_array,
+                       components::outplace_absolute_array);
 
 
 }  // namespace sellp
@@ -304,6 +309,37 @@ Sellp<ValueType, IndexType>::extract_diagonal() const
 }
 
 
+template <typename ValueType, typename IndexType>
+void Sellp<ValueType, IndexType>::turn_absolute()
+{
+    auto exec = this->get_executor();
+
+    exec->run(sellp::make_inplace_absolute_array(
+        this->get_values(), this->get_num_stored_elements()));
+}
+
+
+template <typename ValueType, typename IndexType>
+std::unique_ptr<typename Sellp<ValueType, IndexType>::outplace_absolute_type>
+Sellp<ValueType, IndexType>::get_absolute() const
+{
+    auto exec = this->get_executor();
+
+    auto abs_sellp = outplace_absolute_type::create(
+        exec, this->get_size(), this->get_slice_size(),
+        this->get_stride_factor(), this->get_total_cols());
+
+    abs_sellp->col_idxs_ = col_idxs_;
+    abs_sellp->slice_lengths_ = slice_lengths_;
+    abs_sellp->slice_sets_ = slice_sets_;
+    exec->run(sellp::make_outplace_absolute_array(
+        this->get_const_values(), this->get_num_stored_elements(),
+        abs_sellp->get_values()));
+
+    return abs_sellp;
+}
+
+
 #define GKO_DECLARE_SELLP_MATRIX(ValueType, IndexType) \
     class Sellp<ValueType, IndexType>
 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_SELLP_MATRIX);
diff --git a/cuda/test/matrix/coo_kernels.cpp b/cuda/test/matrix/coo_kernels.cpp
index 3522e918cc6..330e7d7301a 100644
--- a/cuda/test/matrix/coo_kernels.cpp
+++ b/cuda/test/matrix/coo_kernels.cpp
@@ -271,4 +271,26 @@ TEST_F(Coo, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/cuda/test/matrix/diagonal_kernels.cpp b/cuda/test/matrix/diagonal_kernels.cpp
index 8c8bbe207e2..8da64b3b8dc 100644
--- a/cuda/test/matrix/diagonal_kernels.cpp
+++ b/cuda/test/matrix/diagonal_kernels.cpp
@@ -249,4 +249,26 @@ TEST_F(Diagonal, ConjTransposeIsEquivalentToRef)
 }
 
 
+TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    diag->turn_absolute();
+    ddiag->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
+}
+
+
+TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_diag = diag->get_absolute();
+    auto dabs_diag = ddiag->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/cuda/test/matrix/ell_kernels.cpp b/cuda/test/matrix/ell_kernels.cpp
index 960faaed20e..6a4d3b643f3 100644
--- a/cuda/test/matrix/ell_kernels.cpp
+++ b/cuda/test/matrix/ell_kernels.cpp
@@ -356,4 +356,26 @@ TEST_F(Ell, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/cuda/test/matrix/hybrid_kernels.cpp b/cuda/test/matrix/hybrid_kernels.cpp
index 5e7048632bc..4ce0f86943c 100644
--- a/cuda/test/matrix/hybrid_kernels.cpp
+++ b/cuda/test/matrix/hybrid_kernels.cpp
@@ -231,4 +231,26 @@ TEST_F(Hybrid, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/cuda/test/matrix/sellp_kernels.cpp b/cuda/test/matrix/sellp_kernels.cpp
index a3cdeed95ad..8b993e2f964 100644
--- a/cuda/test/matrix/sellp_kernels.cpp
+++ b/cuda/test/matrix/sellp_kernels.cpp
@@ -350,4 +350,26 @@ TEST_F(Sellp, ExtractDiagonalWithSliceSizeAndStrideFactorIsEquivalentToRef)
 }
 
 
+TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_matrix(32, 2);
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_matrix(32, 2);
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/hip/test/matrix/coo_kernels.hip.cpp b/hip/test/matrix/coo_kernels.hip.cpp
index 3e23bb6f4a4..a3bc99afd6a 100644
--- a/hip/test/matrix/coo_kernels.hip.cpp
+++ b/hip/test/matrix/coo_kernels.hip.cpp
@@ -271,4 +271,26 @@ TEST_F(Coo, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/hip/test/matrix/diagonal_kernels.hip.cpp b/hip/test/matrix/diagonal_kernels.hip.cpp
index 6b87034006e..1d3c118a271 100644
--- a/hip/test/matrix/diagonal_kernels.hip.cpp
+++ b/hip/test/matrix/diagonal_kernels.hip.cpp
@@ -249,4 +249,26 @@ TEST_F(Diagonal, ConjTransposeIsEquivalentToRef)
 }
 
 
+TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    diag->turn_absolute();
+    ddiag->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
+}
+
+
+TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_diag = diag->get_absolute();
+    auto dabs_diag = ddiag->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/hip/test/matrix/ell_kernels.hip.cpp b/hip/test/matrix/ell_kernels.hip.cpp
index fa9a2df717a..0646691b88d 100644
--- a/hip/test/matrix/ell_kernels.hip.cpp
+++ b/hip/test/matrix/ell_kernels.hip.cpp
@@ -356,4 +356,26 @@ TEST_F(Ell, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/hip/test/matrix/hybrid_kernels.hip.cpp b/hip/test/matrix/hybrid_kernels.hip.cpp
index a765cbc2717..04fcae927bf 100644
--- a/hip/test/matrix/hybrid_kernels.hip.cpp
+++ b/hip/test/matrix/hybrid_kernels.hip.cpp
@@ -231,4 +231,26 @@ TEST_F(Hybrid, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/hip/test/matrix/sellp_kernels.hip.cpp b/hip/test/matrix/sellp_kernels.hip.cpp
index 80c3cf7c113..9a1d12fe3c7 100644
--- a/hip/test/matrix/sellp_kernels.hip.cpp
+++ b/hip/test/matrix/sellp_kernels.hip.cpp
@@ -349,4 +349,26 @@ TEST_F(Sellp, ExtractDiagonalWithSliceSizeAndStrideFactorIsEquivalentToRef)
 }
 
 
+TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_matrix(32, 2);
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_matrix(32, 2);
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/include/ginkgo/core/matrix/coo.hpp b/include/ginkgo/core/matrix/coo.hpp
index b897d50e6d3..7508d312fdc 100644
--- a/include/ginkgo/core/matrix/coo.hpp
+++ b/include/ginkgo/core/matrix/coo.hpp
@@ -81,12 +81,14 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
             public ConvertibleTo<Dense<ValueType>>,
             public DiagonalExtractable<ValueType>,
             public ReadableFromMatrixData<ValueType, IndexType>,
-            public WritableToMatrixData<ValueType, IndexType> {
+            public WritableToMatrixData<ValueType, IndexType>,
+            public EnableAbsoluteComputation<Coo<ValueType, IndexType>> {
     friend class EnableCreateMethod<Coo>;
     friend class EnablePolymorphicObject<Coo, LinOp>;
     friend class Csr<ValueType, IndexType>;
     friend class Dense<ValueType>;
     friend class CooBuilder<ValueType, IndexType>;
+    friend class Coo<make_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Coo>::convert_to;
@@ -95,6 +97,8 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
+    using outplace_absolute_type =
+        typename EnableAbsoluteComputation<Coo>::outplace_type;
 
     friend class Coo<next_precision<ValueType>, IndexType>;
 
@@ -117,6 +121,10 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
+    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+
+    void turn_absolute() override;
+
     /**
      * Returns the values of the matrix.
      *
diff --git a/include/ginkgo/core/matrix/diagonal.hpp b/include/ginkgo/core/matrix/diagonal.hpp
index c70c7889b37..38526439d95 100644
--- a/include/ginkgo/core/matrix/diagonal.hpp
+++ b/include/ginkgo/core/matrix/diagonal.hpp
@@ -72,11 +72,13 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
                  public WritableToMatrixData<ValueType, int32>,
                  public WritableToMatrixData<ValueType, int64>,
                  public ReadableFromMatrixData<ValueType, int32>,
-                 public ReadableFromMatrixData<ValueType, int64> {
+                 public ReadableFromMatrixData<ValueType, int64>,
+                 public EnableAbsoluteComputation<Diagonal<ValueType>> {
     friend class EnablePolymorphicObject<Diagonal, LinOp>;
     friend class EnableCreateMethod<Diagonal>;
     friend class Csr<ValueType, int32>;
     friend class Csr<ValueType, int64>;
+    friend class Diagonal<make_complex<ValueType>>;
 
 public:
     using EnableLinOp<Diagonal>::convert_to;
@@ -86,6 +88,8 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
     using index_type = int64;
     using mat_data = gko::matrix_data<ValueType, int64>;
     using mat_data32 = gko::matrix_data<ValueType, int32>;
+    using outplace_absolute_type =
+        typename EnableAbsoluteComputation<Diagonal>::outplace_type;
 
     std::unique_ptr<LinOp> transpose() const override;
 
@@ -99,6 +103,10 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
 
     void move_to(Csr<ValueType, int64> *result) override;
 
+    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+
+    void turn_absolute() override;
+
     /**
      * Returns a pointer to the array of values of the matrix.
      *
diff --git a/include/ginkgo/core/matrix/ell.hpp b/include/ginkgo/core/matrix/ell.hpp
index b29aba22a46..f9c68fb0171 100644
--- a/include/ginkgo/core/matrix/ell.hpp
+++ b/include/ginkgo/core/matrix/ell.hpp
@@ -75,11 +75,13 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
             public ConvertibleTo<Csr<ValueType, IndexType>>,
             public DiagonalExtractable<ValueType>,
             public ReadableFromMatrixData<ValueType, IndexType>,
-            public WritableToMatrixData<ValueType, IndexType> {
+            public WritableToMatrixData<ValueType, IndexType>,
+            public EnableAbsoluteComputation<Ell<ValueType, IndexType>> {
     friend class EnableCreateMethod<Ell>;
     friend class EnablePolymorphicObject<Ell, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
+    friend class Ell<make_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Ell>::convert_to;
@@ -88,6 +90,8 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
+    using outplace_absolute_type =
+        typename EnableAbsoluteComputation<Ell>::outplace_type;
 
     friend class Ell<next_precision<ValueType>, IndexType>;
 
@@ -110,6 +114,10 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
+    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+
+    void turn_absolute() override;
+
     /**
      * Returns the values of the matrix.
      *
diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index 4d35165e10e..7f544da8b10 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -76,11 +76,14 @@ class Hybrid
       public ConvertibleTo<Csr<ValueType, IndexType>>,
       public DiagonalExtractable<ValueType>,
       public ReadableFromMatrixData<ValueType, IndexType>,
-      public WritableToMatrixData<ValueType, IndexType> {
+      public WritableToMatrixData<ValueType, IndexType>,
+      public EnableAbsoluteComputation<Hybrid<ValueType, IndexType>> {
     friend class EnableCreateMethod<Hybrid>;
     friend class EnablePolymorphicObject<Hybrid, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
+    friend class Hybrid<make_complex<ValueType>, IndexType>;
+
 
 public:
     using EnableLinOp<Hybrid>::convert_to;
@@ -91,6 +94,9 @@ class Hybrid
     using mat_data = matrix_data<ValueType, IndexType>;
     using coo_type = Coo<ValueType, IndexType>;
     using ell_type = Ell<ValueType, IndexType>;
+    using outplace_absolute_type =
+        typename EnableAbsoluteComputation<Hybrid>::outplace_type;
+
 
     /**
      * strategy_type is to decide how to set the hybrid config. It
@@ -357,6 +363,10 @@ class Hybrid
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
+    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+
+    void turn_absolute() override;
+
     /**
      * Returns the values of the ell part.
      *
diff --git a/include/ginkgo/core/matrix/sellp.hpp b/include/ginkgo/core/matrix/sellp.hpp
index caaa6c20fbb..3c6cb087be5 100644
--- a/include/ginkgo/core/matrix/sellp.hpp
+++ b/include/ginkgo/core/matrix/sellp.hpp
@@ -72,11 +72,13 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
               public ConvertibleTo<Csr<ValueType, IndexType>>,
               public DiagonalExtractable<ValueType>,
               public ReadableFromMatrixData<ValueType, IndexType>,
-              public WritableToMatrixData<ValueType, IndexType> {
+              public WritableToMatrixData<ValueType, IndexType>,
+              public EnableAbsoluteComputation<Sellp<ValueType, IndexType>> {
     friend class EnableCreateMethod<Sellp>;
     friend class EnablePolymorphicObject<Sellp, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
+    friend class Sellp<make_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Sellp>::convert_to;
@@ -85,6 +87,8 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
+    using outplace_absolute_type =
+        typename EnableAbsoluteComputation<Sellp>::outplace_type;
 
     friend class Sellp<next_precision<ValueType>, IndexType>;
 
@@ -107,6 +111,10 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
+    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+
+    void turn_absolute() override;
+
     /**
      * Returns the values of the matrix.
      *
diff --git a/omp/test/matrix/coo_kernels.cpp b/omp/test/matrix/coo_kernels.cpp
index a775a80b4cb..cc1da48c5ea 100644
--- a/omp/test/matrix/coo_kernels.cpp
+++ b/omp/test/matrix/coo_kernels.cpp
@@ -234,4 +234,26 @@ TEST_F(Coo, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/omp/test/matrix/diagonal_kernels.cpp b/omp/test/matrix/diagonal_kernels.cpp
index f4a8a77767f..d9075a450d2 100644
--- a/omp/test/matrix/diagonal_kernels.cpp
+++ b/omp/test/matrix/diagonal_kernels.cpp
@@ -248,4 +248,26 @@ TEST_F(Diagonal, ConjTransposeIsEquivalentToRef)
 }
 
 
+TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    diag->turn_absolute();
+    ddiag->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
+}
+
+
+TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_diag = diag->get_absolute();
+    auto dabs_diag = ddiag->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/omp/test/matrix/ell_kernels.cpp b/omp/test/matrix/ell_kernels.cpp
index 03b4e42579b..f37c313591b 100644
--- a/omp/test/matrix/ell_kernels.cpp
+++ b/omp/test/matrix/ell_kernels.cpp
@@ -232,4 +232,26 @@ TEST_F(Ell, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/omp/test/matrix/hybrid_kernels.cpp b/omp/test/matrix/hybrid_kernels.cpp
index 303853561b0..c0b3a329d93 100644
--- a/omp/test/matrix/hybrid_kernels.cpp
+++ b/omp/test/matrix/hybrid_kernels.cpp
@@ -230,4 +230,26 @@ TEST_F(Hybrid, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/omp/test/matrix/sellp_kernels.cpp b/omp/test/matrix/sellp_kernels.cpp
index 996f4a672f2..1c758de6113 100644
--- a/omp/test/matrix/sellp_kernels.cpp
+++ b/omp/test/matrix/sellp_kernels.cpp
@@ -266,4 +266,26 @@ TEST_F(Sellp, ExtractDiagonalWithSliceSizeAndStrideFactorIsEquivalentToRef)
 }
 
 
+TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    mtx->turn_absolute();
+    dmtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+}
+
+
+TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_mtx = mtx->get_absolute();
+    auto dabs_mtx = dmtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/reference/test/matrix/coo_kernels.cpp b/reference/test/matrix/coo_kernels.cpp
index 704efff502d..e0666b7ccda 100644
--- a/reference/test/matrix/coo_kernels.cpp
+++ b/reference/test/matrix/coo_kernels.cpp
@@ -534,4 +534,83 @@ TYPED_TEST(Coo, ExtractsDiagonal)
 }
 
 
+TYPED_TEST(Coo, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
+TYPED_TEST(Coo, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
+template <typename ValueIndexType>
+class CooComplex : public ::testing::Test {
+protected:
+    using value_type =
+        typename std::tuple_element<0, decltype(ValueIndexType())>::type;
+    using index_type =
+        typename std::tuple_element<1, decltype(ValueIndexType())>::type;
+    using Mtx = gko::matrix::Coo<value_type, index_type>;
+};
+
+TYPED_TEST_CASE(CooComplex, gko::test::ComplexValueIndexTypes);
+
+
+TYPED_TEST(CooComplex, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
+TYPED_TEST(CooComplex, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
 }  // namespace
diff --git a/reference/test/matrix/csr_kernels.cpp b/reference/test/matrix/csr_kernels.cpp
index aef675a9f13..3ab5fbe3269 100644
--- a/reference/test/matrix/csr_kernels.cpp
+++ b/reference/test/matrix/csr_kernels.cpp
@@ -1307,31 +1307,31 @@ TYPED_TEST(Csr, ExtractsDiagonal)
 }
 
 
-TYPED_TEST(Csr, OutplaceAbsolute)
+TYPED_TEST(Csr, InplaceAbsolute)
 {
     using Mtx = typename TestFixture::Mtx;
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    auto abs_mtx = mtx->get_absolute();
+    mtx->turn_absolute();
 
     GKO_ASSERT_MTX_NEAR(
-        abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
-    ASSERT_EQ(mtx->get_strategy()->get_name(),
-              abs_mtx->get_strategy()->get_name());
+        mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
 }
 
 
-TYPED_TEST(Csr, InplaceAbsolute)
+TYPED_TEST(Csr, OutplaceAbsolute)
 {
     using Mtx = typename TestFixture::Mtx;
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->turn_absolute();
+    auto abs_mtx = mtx->get_absolute();
 
     GKO_ASSERT_MTX_NEAR(
-        mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+        abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+    ASSERT_EQ(mtx->get_strategy()->get_name(),
+              abs_mtx->get_strategy()->get_name());
 }
 
 
@@ -1373,7 +1373,7 @@ TYPED_TEST(CsrComplex, MtxIsConjugateTransposable)
 }
 
 
-TYPED_TEST(CsrComplex, OutplaceAbsolute)
+TYPED_TEST(CsrComplex, InplaceAbsolute)
 {
     using Mtx = typename TestFixture::Mtx;
     using T = typename TestFixture::value_type;
@@ -1386,16 +1386,14 @@ TYPED_TEST(CsrComplex, OutplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    auto abs_mtx = mtx->get_absolute();
+    mtx->turn_absolute();
 
     GKO_ASSERT_MTX_NEAR(
-        abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
-    ASSERT_EQ(mtx->get_strategy()->get_name(),
-              abs_mtx->get_strategy()->get_name());
+        mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
 }
 
 
-TYPED_TEST(CsrComplex, InplaceAbsolute)
+TYPED_TEST(CsrComplex, OutplaceAbsolute)
 {
     using Mtx = typename TestFixture::Mtx;
     using T = typename TestFixture::value_type;
@@ -1408,10 +1406,12 @@ TYPED_TEST(CsrComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->turn_absolute();
+    auto abs_mtx = mtx->get_absolute();
 
     GKO_ASSERT_MTX_NEAR(
-        mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+        abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+    ASSERT_EQ(mtx->get_strategy()->get_name(),
+              abs_mtx->get_strategy()->get_name());
 }
 
 
diff --git a/reference/test/matrix/diagonal_kernels.cpp b/reference/test/matrix/diagonal_kernels.cpp
index 6da642d6305..d2ab3f3453c 100644
--- a/reference/test/matrix/diagonal_kernels.cpp
+++ b/reference/test/matrix/diagonal_kernels.cpp
@@ -356,6 +356,31 @@ TYPED_TEST(Diagonal, ConvertsToCsr)
 }
 
 
+TYPED_TEST(Diagonal, InplaceAbsolute)
+{
+    using value_type = typename TestFixture::value_type;
+
+    this->diag1->turn_absolute();
+    auto values = this->diag1->get_values();
+
+    EXPECT_EQ(values[0], value_type(2.0));
+    EXPECT_EQ(values[1], value_type(3.0));
+}
+
+
+TYPED_TEST(Diagonal, OutplaceAbsolute)
+{
+    using value_type = typename TestFixture::value_type;
+    using abs_type = gko::remove_complex<value_type>;
+
+    auto abs_diag = this->diag1->get_absolute();
+    auto values = abs_diag->get_values();
+
+    EXPECT_EQ(values[0], value_type(2.0));
+    EXPECT_EQ(values[1], value_type(3.0));
+}
+
+
 template <typename ValueType>
 class DiagonalComplex : public ::testing::Test {
 protected:
@@ -388,4 +413,46 @@ TYPED_TEST(DiagonalComplex, MtxIsConjugateTransposable)
 }
 
 
+TYPED_TEST(DiagonalComplex, InplaceAbsolute)
+{
+    using Diag = typename TestFixture::Diag;
+    using value_type = typename TestFixture::value_type;
+
+    auto exec = gko::ReferenceExecutor::create();
+    auto diag = Diag::create(exec, 3);
+    auto diag_values = diag->get_values();
+    diag_values[0] = value_type{3.0, -4.0};
+    diag_values[1] = value_type{-3.0, 0.0};
+    diag_values[2] = value_type{0.0, -1.5};
+
+    diag->turn_absolute();
+
+    EXPECT_EQ(diag_values[0], (value_type{5.0, 0.0}));
+    EXPECT_EQ(diag_values[1], (value_type{3.0, 0.0}));
+    EXPECT_EQ(diag_values[2], (value_type{1.5, 0.0}));
+}
+
+
+TYPED_TEST(DiagonalComplex, OutplaceAbsolute)
+{
+    using Diag = typename TestFixture::Diag;
+    using value_type = typename TestFixture::value_type;
+    using abs_type = gko::remove_complex<value_type>;
+
+    auto exec = gko::ReferenceExecutor::create();
+    auto diag = Diag::create(exec, 3);
+    auto diag_values = diag->get_values();
+    diag_values[0] = value_type{3.0, -4.0};
+    diag_values[1] = value_type{-3.0, 0.0};
+    diag_values[2] = value_type{0.0, -1.5};
+
+    auto abs_diag = diag->get_absolute();
+    auto abs_values = abs_diag->get_values();
+
+    EXPECT_EQ(abs_values[0], (value_type{5.0}));
+    EXPECT_EQ(abs_values[1], (value_type{3.0}));
+    EXPECT_EQ(abs_values[2], (value_type{1.5}));
+}
+
+
 }  // namespace
diff --git a/reference/test/matrix/ell_kernels.cpp b/reference/test/matrix/ell_kernels.cpp
index 2e513b96f7d..47221ecfeb2 100644
--- a/reference/test/matrix/ell_kernels.cpp
+++ b/reference/test/matrix/ell_kernels.cpp
@@ -612,4 +612,83 @@ TYPED_TEST(Ell, ExtractsDiagonal)
 }
 
 
+TYPED_TEST(Ell, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
+TYPED_TEST(Ell, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
+template <typename ValueIndexType>
+class EllComplex : public ::testing::Test {
+protected:
+    using value_type =
+        typename std::tuple_element<0, decltype(ValueIndexType())>::type;
+    using index_type =
+        typename std::tuple_element<1, decltype(ValueIndexType())>::type;
+    using Mtx = gko::matrix::Ell<value_type, index_type>;
+};
+
+TYPED_TEST_CASE(EllComplex, gko::test::ComplexValueIndexTypes);
+
+
+TYPED_TEST(EllComplex, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
+TYPED_TEST(EllComplex, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
 }  // namespace
diff --git a/reference/test/matrix/hybrid_kernels.cpp b/reference/test/matrix/hybrid_kernels.cpp
index f108b3375e7..e5bd30fa00e 100644
--- a/reference/test/matrix/hybrid_kernels.cpp
+++ b/reference/test/matrix/hybrid_kernels.cpp
@@ -656,4 +656,83 @@ TYPED_TEST(Hybrid, ExtractsDiagonalWithoutZeros)
 }
 
 
+TYPED_TEST(Hybrid, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
+TYPED_TEST(Hybrid, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
+template <typename ValueIndexType>
+class HybridComplex : public ::testing::Test {
+protected:
+    using value_type =
+        typename std::tuple_element<0, decltype(ValueIndexType())>::type;
+    using index_type =
+        typename std::tuple_element<1, decltype(ValueIndexType())>::type;
+    using Mtx = gko::matrix::Hybrid<value_type, index_type>;
+};
+
+TYPED_TEST_CASE(HybridComplex, gko::test::ComplexValueIndexTypes);
+
+
+TYPED_TEST(HybridComplex, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
+TYPED_TEST(HybridComplex, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
 }  // namespace
diff --git a/reference/test/matrix/sellp_kernels.cpp b/reference/test/matrix/sellp_kernels.cpp
index 48a60f24a6b..6ab86e8ce1a 100644
--- a/reference/test/matrix/sellp_kernels.cpp
+++ b/reference/test/matrix/sellp_kernels.cpp
@@ -615,4 +615,83 @@ TYPED_TEST(Sellp, ExtractsDiagonalWithSliceSizeAndStrideFactor)
 }
 
 
+TYPED_TEST(Sellp, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
+TYPED_TEST(Sellp, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    auto mtx = gko::initialize<Mtx>(
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+}
+
+
+template <typename ValueIndexType>
+class SellpComplex : public ::testing::Test {
+protected:
+    using value_type =
+        typename std::tuple_element<0, decltype(ValueIndexType())>::type;
+    using index_type =
+        typename std::tuple_element<1, decltype(ValueIndexType())>::type;
+    using Mtx = gko::matrix::Sellp<value_type, index_type>;
+};
+
+TYPED_TEST_CASE(SellpComplex, gko::test::ComplexValueIndexTypes);
+
+
+TYPED_TEST(SellpComplex, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
+TYPED_TEST(SellpComplex, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
 }  // namespace

From f5433aa9c5b3e9d2e43c95d03a588ec7e39e0e1f Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 4 Sep 2020 22:38:41 +0200
Subject: [PATCH 06/15] implement dense absolute

---
 common/matrix/dense_kernels.hpp.inc      |  29 +++++++
 core/device_hooks/common_kernels.inc.cpp |  10 +++
 core/matrix/dense.cpp                    |  26 ++++++
 core/matrix/dense_kernels.hpp            |  17 +++-
 cuda/matrix/dense_kernels.cu             |  32 +++++++
 cuda/test/matrix/dense_kernels.cpp       |  22 +++++
 hip/matrix/dense_kernels.hip.cpp         |  33 +++++++
 hip/test/matrix/dense_kernels.hip.cpp    |  22 +++++
 include/ginkgo/core/matrix/dense.hpp     |  10 ++-
 omp/matrix/dense_kernels.cpp             |  35 ++++++++
 omp/test/matrix/dense_kernels.cpp        |  22 +++++
 reference/matrix/dense_kernels.cpp       |  31 +++++++
 reference/test/matrix/dense_kernels.cpp  | 106 +++++++++++++++++++++++
 13 files changed, 393 insertions(+), 2 deletions(-)

diff --git a/common/matrix/dense_kernels.hpp.inc b/common/matrix/dense_kernels.hpp.inc
index 9d0285e71f7..49be1ba3724 100644
--- a/common/matrix/dense_kernels.hpp.inc
+++ b/common/matrix/dense_kernels.hpp.inc
@@ -510,4 +510,33 @@ __global__ __launch_bounds__(default_block_size) void extract_diagonal(
 }
 
 
+template <typename ValueType>
+__global__ __launch_bounds__(default_block_size) void inplace_absolute_dense(
+    size_type num_rows, size_type num_cols, ValueType *__restrict__ data,
+    size_type stride)
+{
+    const auto tidx = thread::get_thread_id_flat();
+    auto row = tidx / num_cols;
+    auto col = tidx % num_cols;
+    if (row < num_rows) {
+        data[row * stride + col] = abs(data[row * stride + col]);
+    }
+}
+
+
+template <typename ValueType>
+__global__ __launch_bounds__(default_block_size) void outplace_absolute_dense(
+    size_type num_rows, size_type num_cols, const ValueType *__restrict__ in,
+    size_type stride_in, remove_complex<ValueType> *__restrict__ out,
+    size_type stride_out)
+{
+    const auto tidx = thread::get_thread_id_flat();
+    auto row = tidx / num_cols;
+    auto col = tidx % num_cols;
+    if (row < num_rows) {
+        out[row * stride_out + col] = abs(in[row * stride_out + col]);
+    }
+}
+
+
 }  // namespace kernel
diff --git a/core/device_hooks/common_kernels.inc.cpp b/core/device_hooks/common_kernels.inc.cpp
index 7015c9c644e..2f52d52ce8f 100644
--- a/core/device_hooks/common_kernels.inc.cpp
+++ b/core/device_hooks/common_kernels.inc.cpp
@@ -244,6 +244,16 @@ GKO_DECLARE_EXTRACT_DIAGONAL_KERNEL(ValueType)
 GKO_NOT_COMPILED(GKO_HOOK_MODULE);
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_EXTRACT_DIAGONAL_KERNEL);
 
+template <typename ValueType>
+GKO_DECLARE_INPLACE_ABSOLUTE_DENSE_KERNEL(ValueType)
+GKO_NOT_COMPILED(GKO_HOOK_MODULE);
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_DENSE_KERNEL);
+
+template <typename ValueType>
+GKO_DECLARE_OUTPLACE_ABSOLUTE_DENSE_KERNEL(ValueType)
+GKO_NOT_COMPILED(GKO_HOOK_MODULE);
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_DENSE_KERNEL);
+
 
 }  // namespace dense
 
diff --git a/core/matrix/dense.cpp b/core/matrix/dense.cpp
index aab1d2e598a..306c83cde71 100644
--- a/core/matrix/dense.cpp
+++ b/core/matrix/dense.cpp
@@ -85,6 +85,8 @@ GKO_REGISTER_OPERATION(convert_to_hybrid, dense::convert_to_hybrid);
 GKO_REGISTER_OPERATION(convert_to_sellp, dense::convert_to_sellp);
 GKO_REGISTER_OPERATION(convert_to_sparsity_csr, dense::convert_to_sparsity_csr);
 GKO_REGISTER_OPERATION(extract_diagonal, dense::extract_diagonal);
+GKO_REGISTER_OPERATION(inplace_absolute_dense, dense::inplace_absolute_dense);
+GKO_REGISTER_OPERATION(outplace_absolute_dense, dense::outplace_absolute_dense);
 
 
 }  // namespace dense
@@ -752,6 +754,30 @@ std::unique_ptr<Diagonal<ValueType>> Dense<ValueType>::extract_diagonal() const
 }
 
 
+template <typename ValueType>
+void Dense<ValueType>::turn_absolute()
+{
+    auto exec = this->get_executor();
+
+    exec->run(dense::make_inplace_absolute_dense(this));
+}
+
+
+template <typename ValueType>
+std::unique_ptr<typename Dense<ValueType>::outplace_absolute_type>
+Dense<ValueType>::get_absolute() const
+{
+    auto exec = this->get_executor();
+
+    // do not inherit the stride
+    auto abs_dense = outplace_absolute_type::create(exec, this->get_size());
+
+    exec->run(dense::make_outplace_absolute_dense(this, abs_dense.get()));
+
+    return abs_dense;
+}
+
+
 #define GKO_DECLARE_DENSE_MATRIX(_type) class Dense<_type>
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_DENSE_MATRIX);
 
diff --git a/core/matrix/dense_kernels.hpp b/core/matrix/dense_kernels.hpp
index 8edeec6878e..30ad6ca4729 100644
--- a/core/matrix/dense_kernels.hpp
+++ b/core/matrix/dense_kernels.hpp
@@ -172,6 +172,17 @@ namespace kernels {
                           const matrix::Dense<_vtype> *orig,           \
                           matrix::Diagonal<_vtype> *diag)
 
+#define GKO_DECLARE_INPLACE_ABSOLUTE_DENSE_KERNEL(_vtype)                    \
+    void inplace_absolute_dense(std::shared_ptr<const DefaultExecutor> exec, \
+                                matrix::Dense<_vtype> *source)
+
+#define GKO_DECLARE_OUTPLACE_ABSOLUTE_DENSE_KERNEL(_vtype) \
+    void outplace_absolute_dense(                          \
+        std::shared_ptr<const DefaultExecutor> exec,       \
+        const matrix::Dense<_vtype> *source,               \
+        matrix::Dense<remove_complex<_vtype>> *result)
+
+
 #define GKO_DECLARE_ALL_AS_TEMPLATES                                        \
     template <typename ValueType>                                           \
     GKO_DECLARE_DENSE_SIMPLE_APPLY_KERNEL(ValueType);                       \
@@ -220,7 +231,11 @@ namespace kernels {
     template <typename ValueType, typename IndexType>                       \
     GKO_DECLARE_INVERSE_COLUMN_PERMUTE_KERNEL(ValueType, IndexType);        \
     template <typename ValueType>                                           \
-    GKO_DECLARE_EXTRACT_DIAGONAL_KERNEL(ValueType)
+    GKO_DECLARE_EXTRACT_DIAGONAL_KERNEL(ValueType);                         \
+    template <typename ValueType>                                           \
+    GKO_DECLARE_INPLACE_ABSOLUTE_DENSE_KERNEL(ValueType);                   \
+    template <typename ValueType>                                           \
+    GKO_DECLARE_OUTPLACE_ABSOLUTE_DENSE_KERNEL(ValueType)
 
 
 namespace omp {
diff --git a/cuda/matrix/dense_kernels.cu b/cuda/matrix/dense_kernels.cu
index f0fe2cfae7e..b1c4ae747f8 100644
--- a/cuda/matrix/dense_kernels.cu
+++ b/cuda/matrix/dense_kernels.cu
@@ -701,6 +701,38 @@ void extract_diagonal(std::shared_ptr<const CudaExecutor> exec,
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_EXTRACT_DIAGONAL_KERNEL);
 
 
+template <typename ValueType>
+void inplace_absolute_dense(std::shared_ptr<const CudaExecutor> exec,
+                            matrix::Dense<ValueType> *source)
+{
+    auto dim = source->get_size();
+    const dim3 grid_dim = ceildiv(dim[0] * dim[1], default_block_size);
+
+    kernel::inplace_absolute_dense<<<grid_dim, default_block_size>>>(
+        dim[0], dim[1], as_cuda_type(source->get_values()),
+        source->get_stride());
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_DENSE_KERNEL);
+
+
+template <typename ValueType>
+void outplace_absolute_dense(std::shared_ptr<const CudaExecutor> exec,
+                             const matrix::Dense<ValueType> *source,
+                             matrix::Dense<remove_complex<ValueType>> *result)
+{
+    auto dim = source->get_size();
+    const dim3 grid_dim = ceildiv(dim[0] * dim[1], default_block_size);
+
+    kernel::outplace_absolute_dense<<<grid_dim, default_block_size>>>(
+        dim[0], dim[1], as_cuda_type(source->get_const_values()),
+        source->get_stride(), as_cuda_type(result->get_values()),
+        result->get_stride());
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_DENSE_KERNEL);
+
+
 }  // namespace dense
 }  // namespace cuda
 }  // namespace kernels
diff --git a/cuda/test/matrix/dense_kernels.cpp b/cuda/test/matrix/dense_kernels.cpp
index c520dfcf2a3..a2cbccfc8f3 100644
--- a/cuda/test/matrix/dense_kernels.cpp
+++ b/cuda/test/matrix/dense_kernels.cpp
@@ -587,4 +587,26 @@ TEST_F(Dense, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    x->turn_absolute();
+    dx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
+}
+
+
+TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_x = x->get_absolute();
+    auto dabs_x = dx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/hip/matrix/dense_kernels.hip.cpp b/hip/matrix/dense_kernels.hip.cpp
index 824d2712b7f..2793d09832f 100644
--- a/hip/matrix/dense_kernels.hip.cpp
+++ b/hip/matrix/dense_kernels.hip.cpp
@@ -729,6 +729,39 @@ void extract_diagonal(std::shared_ptr<const HipExecutor> exec,
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_EXTRACT_DIAGONAL_KERNEL);
 
 
+template <typename ValueType>
+void inplace_absolute_dense(std::shared_ptr<const HipExecutor> exec,
+                            matrix::Dense<ValueType> *source)
+{
+    auto dim = source->get_size();
+    const dim3 grid_dim = ceildiv(dim[0] * dim[1], default_block_size);
+
+    hipLaunchKernelGGL(kernel::inplace_absolute_dense, dim3(grid_dim),
+                       dim3(default_block_size), 0, 0, dim[0], dim[1],
+                       as_hip_type(source->get_values()), source->get_stride());
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_DENSE_KERNEL);
+
+
+template <typename ValueType>
+void outplace_absolute_dense(std::shared_ptr<const HipExecutor> exec,
+                             const matrix::Dense<ValueType> *source,
+                             matrix::Dense<remove_complex<ValueType>> *result)
+{
+    auto dim = source->get_size();
+    const dim3 grid_dim = ceildiv(dim[0] * dim[1], default_block_size);
+
+    hipLaunchKernelGGL(kernel::outplace_absolute_dense, dim3(grid_dim),
+                       dim3(default_block_size), 0, 0, dim[0], dim[1],
+                       as_hip_type(source->get_const_values()),
+                       source->get_stride(), as_hip_type(result->get_values()),
+                       result->get_stride());
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_DENSE_KERNEL);
+
+
 }  // namespace dense
 }  // namespace hip
 }  // namespace kernels
diff --git a/hip/test/matrix/dense_kernels.hip.cpp b/hip/test/matrix/dense_kernels.hip.cpp
index 40de01b14e8..0abb142e1e9 100644
--- a/hip/test/matrix/dense_kernels.hip.cpp
+++ b/hip/test/matrix/dense_kernels.hip.cpp
@@ -569,4 +569,26 @@ TEST_F(Dense, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    x->turn_absolute();
+    dx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
+}
+
+
+TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_x = x->get_absolute();
+    auto dabs_x = dx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/include/ginkgo/core/matrix/dense.hpp b/include/ginkgo/core/matrix/dense.hpp
index e4dc05e7017..912040345cd 100644
--- a/include/ginkgo/core/matrix/dense.hpp
+++ b/include/ginkgo/core/matrix/dense.hpp
@@ -110,7 +110,8 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
               public WritableToMatrixData<ValueType, int64>,
               public Transposable,
               public Permutable<int32>,
-              public Permutable<int64> {
+              public Permutable<int64>,
+              public EnableAbsoluteComputation<Dense<ValueType>> {
     friend class EnableCreateMethod<Dense>;
     friend class EnablePolymorphicObject<Dense, LinOp>;
     friend class Coo<ValueType, int32>;
@@ -126,6 +127,7 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
     friend class Sellp<ValueType, int64>;
     friend class SparsityCsr<ValueType, int32>;
     friend class SparsityCsr<ValueType, int64>;
+    friend class Dense<make_complex<ValueType>>;
 
 public:
     using EnableLinOp<Dense>::convert_to;
@@ -136,6 +138,8 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
     using transposed_type = Dense<ValueType>;
     using mat_data = gko::matrix_data<ValueType, int64>;
     using mat_data32 = gko::matrix_data<ValueType, int32>;
+    using outplace_absolute_type =
+        typename EnableAbsoluteComputation<Dense>::outplace_type;
 
     using row_major_range = gko::range<gko::accessor::row_major<ValueType, 2>>;
 
@@ -245,6 +249,10 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
+    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+
+    void turn_absolute() override;
+
     /**
      * Returns a pointer to the array of values of the matrix.
      *
diff --git a/omp/matrix/dense_kernels.cpp b/omp/matrix/dense_kernels.cpp
index abf8037bc9b..c3a5234d956 100644
--- a/omp/matrix/dense_kernels.cpp
+++ b/omp/matrix/dense_kernels.cpp
@@ -769,6 +769,41 @@ void extract_diagonal(std::shared_ptr<const OmpExecutor> exec,
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_EXTRACT_DIAGONAL_KERNEL);
 
 
+template <typename ValueType>
+void inplace_absolute_dense(std::shared_ptr<const OmpExecutor> exec,
+                            matrix::Dense<ValueType> *source)
+{
+    auto dim = source->get_size();
+
+#pragma omp parallel for
+    for (size_type row = 0; row < dim[0]; row++) {
+        for (size_type col = 0; col < dim[1]; col++) {
+            source->at(row, col) = abs(source->at(row, col));
+        }
+    }
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_DENSE_KERNEL);
+
+
+template <typename ValueType>
+void outplace_absolute_dense(std::shared_ptr<const OmpExecutor> exec,
+                             const matrix::Dense<ValueType> *source,
+                             matrix::Dense<remove_complex<ValueType>> *result)
+{
+    auto dim = source->get_size();
+
+#pragma omp parallel for
+    for (size_type row = 0; row < dim[0]; row++) {
+        for (size_type col = 0; col < dim[1]; col++) {
+            result->at(row, col) = abs(source->at(row, col));
+        }
+    }
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_DENSE_KERNEL);
+
+
 }  // namespace dense
 }  // namespace omp
 }  // namespace kernels
diff --git a/omp/test/matrix/dense_kernels.cpp b/omp/test/matrix/dense_kernels.cpp
index 0d82dbd261b..42b91f5bdcd 100644
--- a/omp/test/matrix/dense_kernels.cpp
+++ b/omp/test/matrix/dense_kernels.cpp
@@ -702,4 +702,26 @@ TEST_F(Dense, ExtractDiagonalIsEquivalentToRef)
 }
 
 
+TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    x->turn_absolute();
+    dx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
+}
+
+
+TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
+{
+    set_up_apply_data();
+
+    auto abs_x = x->get_absolute();
+    auto dabs_x = dx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
+}
+
+
 }  // namespace
diff --git a/reference/matrix/dense_kernels.cpp b/reference/matrix/dense_kernels.cpp
index db66b30e0df..75a6ddef342 100644
--- a/reference/matrix/dense_kernels.cpp
+++ b/reference/matrix/dense_kernels.cpp
@@ -684,6 +684,37 @@ void extract_diagonal(std::shared_ptr<const ReferenceExecutor> exec,
 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_EXTRACT_DIAGONAL_KERNEL);
 
 
+template <typename ValueType>
+void inplace_absolute_dense(std::shared_ptr<const ReferenceExecutor> exec,
+                            matrix::Dense<ValueType> *source)
+{
+    auto dim = source->get_size();
+    for (size_type row = 0; row < dim[0]; row++) {
+        for (size_type col = 0; col < dim[1]; col++) {
+            source->at(row, col) = abs(source->at(row, col));
+        }
+    }
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_INPLACE_ABSOLUTE_DENSE_KERNEL);
+
+
+template <typename ValueType>
+void outplace_absolute_dense(std::shared_ptr<const ReferenceExecutor> exec,
+                             const matrix::Dense<ValueType> *source,
+                             matrix::Dense<remove_complex<ValueType>> *result)
+{
+    auto dim = source->get_size();
+    for (size_type row = 0; row < dim[0]; row++) {
+        for (size_type col = 0; col < dim[1]; col++) {
+            result->at(row, col) = abs(source->at(row, col));
+        }
+    }
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(GKO_DECLARE_OUTPLACE_ABSOLUTE_DENSE_KERNEL);
+
+
 }  // namespace dense
 }  // namespace reference
 }  // namespace kernels
diff --git a/reference/test/matrix/dense_kernels.cpp b/reference/test/matrix/dense_kernels.cpp
index 82fefe8f1df..c41a748d6d5 100644
--- a/reference/test/matrix/dense_kernels.cpp
+++ b/reference/test/matrix/dense_kernels.cpp
@@ -2009,6 +2009,74 @@ TYPED_TEST(Dense, ExtractsDiagonalFromNonSquareMatrix)
 }
 
 
+TYPED_TEST(Dense, InplaceAbsolute)
+{
+    using T = typename TestFixture::value_type;
+    // clang-format off
+    // {1.0, -1.0, -0.5},
+    // {-2.0, 2.0, 4.5},
+    // {2.1, 3.4, 1.2}
+    // clang-format on
+    this->mtx5->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(this->mtx5,
+                        l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}),
+                        r<TypeParam>::value);
+}
+
+
+TYPED_TEST(Dense, InplaceAbsoluteSubMatrix)
+{
+    using T = typename TestFixture::value_type;
+    // mtx takes the left top corner 2 x 2 matrix
+    auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2});
+    // clang-format off
+    // {1.0, -1.0, -0.5},
+    // {-2.0, 2.0, 4.5},
+    // {2.1, 3.4, 1.2}
+    // clang-format on
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(this->mtx5,
+                        l({{1.0, 1.0, -0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}),
+                        r<TypeParam>::value);
+}
+
+
+TYPED_TEST(Dense, OutplaceAbsolute)
+{
+    using T = typename TestFixture::value_type;
+    // clang-format off
+    // {1.0, -1.0, -0.5},
+    // {-2.0, 2.0, 4.5},
+    // {2.1, 3.4, 1.2}
+    // clang-format on
+    auto abs_mtx = this->mtx5->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx,
+                        l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}),
+                        r<TypeParam>::value);
+}
+
+
+TYPED_TEST(Dense, OutplaceAbsoluteSubMatrix)
+{
+    using T = typename TestFixture::value_type;
+    // mtx takes the left top corner 2 x 2 matrix
+    auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2});
+    // clang-format off
+    // {1.0, -1.0, -0.5},
+    // {-2.0, 2.0, 4.5},
+    // {2.1, 3.4, 1.2}
+    // clang-format on
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(abs_mtx, l({{1.0, 1.0}, {2.0, 2.0}}),
+                        r<TypeParam>::value);
+    GKO_ASSERT_EQ(abs_mtx->get_stride(), 2);
+}
+
+
 template <typename T>
 class DenseComplex : public ::testing::Test {
 protected:
@@ -2039,4 +2107,42 @@ TYPED_TEST(DenseComplex, NonSquareMatrixIsConjugateTransposable)
 }
 
 
+TYPED_TEST(DenseComplex, InplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    mtx->turn_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
+TYPED_TEST(DenseComplex, OutplaceAbsolute)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using T = typename TestFixture::value_type;
+    auto exec = gko::ReferenceExecutor::create();
+    // clang-format off
+    auto mtx = gko::initialize<Mtx>(
+        {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
+         {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+    // clang-format on
+
+    auto abs_mtx = mtx->get_absolute();
+
+    GKO_ASSERT_MTX_NEAR(
+        abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+}
+
+
 }  // namespace

From 4c2f70d634ed4bb72c77b6d5d553c4f41a015212 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Mon, 7 Sep 2020 17:47:05 +0200
Subject: [PATCH 07/15] rename turn_absolute and add interface for LinOp 1.
 rename turn_absolute -> apply_absolute 2. add AbsoluteComputable for LinOp
 usage

---
 core/matrix/coo.cpp                        |   2 +-
 core/matrix/csr.cpp                        |   2 +-
 core/matrix/dense.cpp                      |   2 +-
 core/matrix/diagonal.cpp                   |   2 +-
 core/matrix/ell.cpp                        |   2 +-
 core/matrix/hybrid.cpp                     |   2 +-
 core/matrix/sellp.cpp                      |   2 +-
 core/test/base/lin_op.cpp                  | 102 ++++++++++++++++++++-
 cuda/test/matrix/coo_kernels.cpp           |   4 +-
 cuda/test/matrix/csr_kernels.cpp           |   8 +-
 cuda/test/matrix/dense_kernels.cpp         |   4 +-
 cuda/test/matrix/diagonal_kernels.cpp      |   4 +-
 cuda/test/matrix/ell_kernels.cpp           |   4 +-
 cuda/test/matrix/hybrid_kernels.cpp        |   4 +-
 cuda/test/matrix/sellp_kernels.cpp         |   4 +-
 hip/test/matrix/coo_kernels.hip.cpp        |   4 +-
 hip/test/matrix/csr_kernels.hip.cpp        |   8 +-
 hip/test/matrix/dense_kernels.hip.cpp      |   4 +-
 hip/test/matrix/diagonal_kernels.hip.cpp   |   4 +-
 hip/test/matrix/ell_kernels.hip.cpp        |   4 +-
 hip/test/matrix/hybrid_kernels.hip.cpp     |   4 +-
 hip/test/matrix/sellp_kernels.hip.cpp      |   4 +-
 include/ginkgo/core/base/lin_op.hpp        |  43 ++++++---
 include/ginkgo/core/base/math.hpp          |  54 +++++------
 include/ginkgo/core/matrix/coo.hpp         |   2 +-
 include/ginkgo/core/matrix/csr.hpp         |   2 +-
 include/ginkgo/core/matrix/dense.hpp       |   2 +-
 include/ginkgo/core/matrix/diagonal.hpp    |   2 +-
 include/ginkgo/core/matrix/ell.hpp         |   2 +-
 include/ginkgo/core/matrix/hybrid.hpp      |   2 +-
 include/ginkgo/core/matrix/sellp.hpp       |   2 +-
 omp/test/matrix/coo_kernels.cpp            |   4 +-
 omp/test/matrix/csr_kernels.cpp            |   8 +-
 omp/test/matrix/dense_kernels.cpp          |   4 +-
 omp/test/matrix/diagonal_kernels.cpp       |   4 +-
 omp/test/matrix/ell_kernels.cpp            |   4 +-
 omp/test/matrix/hybrid_kernels.cpp         |   4 +-
 omp/test/matrix/sellp_kernels.cpp          |   4 +-
 reference/test/matrix/coo_kernels.cpp      |   4 +-
 reference/test/matrix/csr_kernels.cpp      |   4 +-
 reference/test/matrix/dense_kernels.cpp    |   6 +-
 reference/test/matrix/diagonal_kernels.cpp |   4 +-
 reference/test/matrix/ell_kernels.cpp      |   4 +-
 reference/test/matrix/hybrid_kernels.cpp   |   4 +-
 reference/test/matrix/sellp_kernels.cpp    |   4 +-
 45 files changed, 236 insertions(+), 117 deletions(-)

diff --git a/core/matrix/coo.cpp b/core/matrix/coo.cpp
index ecff61e6d4e..b9648d1dc70 100644
--- a/core/matrix/coo.cpp
+++ b/core/matrix/coo.cpp
@@ -239,7 +239,7 @@ Coo<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Coo<ValueType, IndexType>::turn_absolute()
+void Coo<ValueType, IndexType>::apply_absolute()
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/csr.cpp b/core/matrix/csr.cpp
index 0a51503c5f0..8a6ad620885 100644
--- a/core/matrix/csr.cpp
+++ b/core/matrix/csr.cpp
@@ -487,7 +487,7 @@ Csr<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Csr<ValueType, IndexType>::turn_absolute()
+void Csr<ValueType, IndexType>::apply_absolute()
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/dense.cpp b/core/matrix/dense.cpp
index 306c83cde71..19152c62d9a 100644
--- a/core/matrix/dense.cpp
+++ b/core/matrix/dense.cpp
@@ -755,7 +755,7 @@ std::unique_ptr<Diagonal<ValueType>> Dense<ValueType>::extract_diagonal() const
 
 
 template <typename ValueType>
-void Dense<ValueType>::turn_absolute()
+void Dense<ValueType>::apply_absolute()
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/diagonal.cpp b/core/matrix/diagonal.cpp
index 83b8d826019..e136e90a919 100644
--- a/core/matrix/diagonal.cpp
+++ b/core/matrix/diagonal.cpp
@@ -267,7 +267,7 @@ void Diagonal<ValueType>::write(mat_data32 &data) const
 
 
 template <typename ValueType>
-void Diagonal<ValueType>::turn_absolute()
+void Diagonal<ValueType>::apply_absolute()
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/ell.cpp b/core/matrix/ell.cpp
index a16ec65631b..28acf7a3a39 100644
--- a/core/matrix/ell.cpp
+++ b/core/matrix/ell.cpp
@@ -257,7 +257,7 @@ Ell<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Ell<ValueType, IndexType>::turn_absolute()
+void Ell<ValueType, IndexType>::apply_absolute()
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/hybrid.cpp b/core/matrix/hybrid.cpp
index b6d9552c9e5..cd5adcfbdcd 100644
--- a/core/matrix/hybrid.cpp
+++ b/core/matrix/hybrid.cpp
@@ -291,7 +291,7 @@ Hybrid<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Hybrid<ValueType, IndexType>::turn_absolute()
+void Hybrid<ValueType, IndexType>::apply_absolute()
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/sellp.cpp b/core/matrix/sellp.cpp
index 916d531d072..e57555c067b 100644
--- a/core/matrix/sellp.cpp
+++ b/core/matrix/sellp.cpp
@@ -310,7 +310,7 @@ Sellp<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Sellp<ValueType, IndexType>::turn_absolute()
+void Sellp<ValueType, IndexType>::apply_absolute()
 {
     auto exec = this->get_executor();
 
diff --git a/core/test/base/lin_op.cpp b/core/test/base/lin_op.cpp
index 622158d9b42..e5eea7d7c70 100644
--- a/core/test/base/lin_op.cpp
+++ b/core/test/base/lin_op.cpp
@@ -30,8 +30,9 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************<GINKGO LICENSE>*******************************/
 
+#include <complex>
 #include <ginkgo/core/base/lin_op.hpp>
-
+#include <ginkgo/core/base/math.hpp>
 
 #include <gtest/gtest.h>
 
@@ -314,4 +315,103 @@ TEST_F(EnableLinOpFactory, PassesParametersToLinOp)
 }
 
 
+template <typename Type>
+class DummyLinOpWithType
+    : public gko::EnableLinOp<DummyLinOpWithType<Type>>,
+      public gko::EnableCreateMethod<DummyLinOpWithType<Type>>,
+      public gko::EnableAbsoluteComputation<DummyLinOpWithType<Type>> {
+public:
+    using outplace_absolute_type = gko::remove_complex<DummyLinOpWithType>;
+    DummyLinOpWithType(std::shared_ptr<const gko::Executor> exec)
+        : gko::EnableLinOp<DummyLinOpWithType>(exec)
+    {}
+
+    DummyLinOpWithType(std::shared_ptr<const gko::Executor> exec,
+                       gko::dim<2> size, Type value)
+        : gko::EnableLinOp<DummyLinOpWithType>(exec, size), value_(value)
+    {}
+
+    void apply_absolute() override { value_ = gko::abs(value_); }
+
+    std::unique_ptr<outplace_absolute_type> get_absolute() const override
+    {
+        return std::make_unique<outplace_absolute_type>(
+            this->get_executor(), this->get_size(), gko::abs(value_));
+    }
+
+    Type get_value() const { return value_; }
+
+protected:
+    void apply_impl(const gko::LinOp *b, gko::LinOp *x) const override {}
+
+    void apply_impl(const gko::LinOp *alpha, const gko::LinOp *b,
+                    const gko::LinOp *beta, gko::LinOp *x) const override
+    {}
+
+private:
+    Type value_;
+};
+
+
+class EnableAbsoluteComputation : public ::testing::Test {
+protected:
+    using dummy_type = DummyLinOpWithType<std::complex<double>>;
+    EnableAbsoluteComputation()
+        : ref{gko::ReferenceExecutor::create()},
+          op{dummy_type::create(ref, gko::dim<2>{1, 1},
+                                std::complex<double>{-3.0, 4.0})}
+    {}
+
+    std::shared_ptr<const gko::ReferenceExecutor> ref;
+    std::shared_ptr<dummy_type> op;
+};
+
+
+TEST_F(EnableAbsoluteComputation, InplaceAbsoluteOnConcreteType)
+{
+    op->apply_absolute();
+
+    ASSERT_EQ(op->get_value(), std::complex<double>{5.0});
+}
+
+
+TEST_F(EnableAbsoluteComputation, OutplaceAbsoluteOnConcreteType)
+{
+    auto abs_op = op->get_absolute();
+
+    ASSERT_EQ(typeid(abs_op),
+              typeid(std::unique_ptr<gko::remove_complex<dummy_type>>));
+    ASSERT_EQ(abs_op->get_value(), 5.0);
+}
+
+
+TEST_F(EnableAbsoluteComputation, InplaceAbsoluteOnAbsoluteComputable)
+{
+    auto linop = gko::as<gko::LinOp>(op);
+
+    gko::as<gko::AbsoluteComputable>(linop)->apply_absolute();
+
+    ASSERT_EQ(gko::as<dummy_type>(linop)->get_value(),
+              std::complex<double>{5.0});
+}
+
+
+TEST_F(EnableAbsoluteComputation, OutplaceAbsoluteOnAbsoluteComputable)
+{
+    auto abs_op = op->get_absolute();
+
+    ASSERT_EQ(typeid(abs_op),
+              typeid(std::unique_ptr<gko::remove_complex<dummy_type>>));
+    ASSERT_EQ(abs_op->get_value(), 5.0);
+}
+
+
+TEST_F(EnableAbsoluteComputation, ThrowWithoutAbsoluteComputableInterface)
+{
+    std::shared_ptr<gko::LinOp> linop = DummyLinOp::create(ref);
+
+    ASSERT_THROW(gko::as<gko::AbsoluteComputable>(linop), gko::NotSupported);
+}
+
+
 }  // namespace
diff --git a/cuda/test/matrix/coo_kernels.cpp b/cuda/test/matrix/coo_kernels.cpp
index 330e7d7301a..7575314ad7e 100644
--- a/cuda/test/matrix/coo_kernels.cpp
+++ b/cuda/test/matrix/coo_kernels.cpp
@@ -275,8 +275,8 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/csr_kernels.cpp b/cuda/test/matrix/csr_kernels.cpp
index b05ca46327c..d51ea16bc33 100644
--- a/cuda/test/matrix/csr_kernels.cpp
+++ b/cuda/test/matrix/csr_kernels.cpp
@@ -744,8 +744,8 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data(std::make_shared<Mtx::automatical>(cuda));
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -766,8 +766,8 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(cuda));
 
-    complex_mtx->turn_absolute();
-    complex_dmtx->turn_absolute();
+    complex_mtx->apply_absolute();
+    complex_dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/dense_kernels.cpp b/cuda/test/matrix/dense_kernels.cpp
index a2cbccfc8f3..1121b994fd6 100644
--- a/cuda/test/matrix/dense_kernels.cpp
+++ b/cuda/test/matrix/dense_kernels.cpp
@@ -591,8 +591,8 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    x->turn_absolute();
-    dx->turn_absolute();
+    x->apply_absolute();
+    dx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/diagonal_kernels.cpp b/cuda/test/matrix/diagonal_kernels.cpp
index 8da64b3b8dc..6a357769022 100644
--- a/cuda/test/matrix/diagonal_kernels.cpp
+++ b/cuda/test/matrix/diagonal_kernels.cpp
@@ -253,8 +253,8 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    diag->turn_absolute();
-    ddiag->turn_absolute();
+    diag->apply_absolute();
+    ddiag->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/ell_kernels.cpp b/cuda/test/matrix/ell_kernels.cpp
index 6a4d3b643f3..3df92e8c859 100644
--- a/cuda/test/matrix/ell_kernels.cpp
+++ b/cuda/test/matrix/ell_kernels.cpp
@@ -360,8 +360,8 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/hybrid_kernels.cpp b/cuda/test/matrix/hybrid_kernels.cpp
index 4ce0f86943c..f9adc82ff53 100644
--- a/cuda/test/matrix/hybrid_kernels.cpp
+++ b/cuda/test/matrix/hybrid_kernels.cpp
@@ -235,8 +235,8 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/sellp_kernels.cpp b/cuda/test/matrix/sellp_kernels.cpp
index 8b993e2f964..43375ffb0cf 100644
--- a/cuda/test/matrix/sellp_kernels.cpp
+++ b/cuda/test/matrix/sellp_kernels.cpp
@@ -354,8 +354,8 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_matrix(32, 2);
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/coo_kernels.hip.cpp b/hip/test/matrix/coo_kernels.hip.cpp
index a3bc99afd6a..470694c1ece 100644
--- a/hip/test/matrix/coo_kernels.hip.cpp
+++ b/hip/test/matrix/coo_kernels.hip.cpp
@@ -275,8 +275,8 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/csr_kernels.hip.cpp b/hip/test/matrix/csr_kernels.hip.cpp
index 4a55b6a6ef8..cbcb3c1b37e 100644
--- a/hip/test/matrix/csr_kernels.hip.cpp
+++ b/hip/test/matrix/csr_kernels.hip.cpp
@@ -729,8 +729,8 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data(std::make_shared<Mtx::automatical>(hip));
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -751,8 +751,8 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(hip));
 
-    complex_mtx->turn_absolute();
-    complex_dmtx->turn_absolute();
+    complex_mtx->apply_absolute();
+    complex_dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/dense_kernels.hip.cpp b/hip/test/matrix/dense_kernels.hip.cpp
index 0abb142e1e9..86e907d27ab 100644
--- a/hip/test/matrix/dense_kernels.hip.cpp
+++ b/hip/test/matrix/dense_kernels.hip.cpp
@@ -573,8 +573,8 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    x->turn_absolute();
-    dx->turn_absolute();
+    x->apply_absolute();
+    dx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/diagonal_kernels.hip.cpp b/hip/test/matrix/diagonal_kernels.hip.cpp
index 1d3c118a271..dd89c7945e5 100644
--- a/hip/test/matrix/diagonal_kernels.hip.cpp
+++ b/hip/test/matrix/diagonal_kernels.hip.cpp
@@ -253,8 +253,8 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    diag->turn_absolute();
-    ddiag->turn_absolute();
+    diag->apply_absolute();
+    ddiag->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
 }
diff --git a/hip/test/matrix/ell_kernels.hip.cpp b/hip/test/matrix/ell_kernels.hip.cpp
index 0646691b88d..502035ba9c5 100644
--- a/hip/test/matrix/ell_kernels.hip.cpp
+++ b/hip/test/matrix/ell_kernels.hip.cpp
@@ -360,8 +360,8 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/hybrid_kernels.hip.cpp b/hip/test/matrix/hybrid_kernels.hip.cpp
index 04fcae927bf..be1cd12ae6c 100644
--- a/hip/test/matrix/hybrid_kernels.hip.cpp
+++ b/hip/test/matrix/hybrid_kernels.hip.cpp
@@ -235,8 +235,8 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/sellp_kernels.hip.cpp b/hip/test/matrix/sellp_kernels.hip.cpp
index 9a1d12fe3c7..59d5efda437 100644
--- a/hip/test/matrix/sellp_kernels.hip.cpp
+++ b/hip/test/matrix/sellp_kernels.hip.cpp
@@ -353,8 +353,8 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_matrix(32, 2);
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/include/ginkgo/core/base/lin_op.hpp b/include/ginkgo/core/base/lin_op.hpp
index 2a38b84d31a..8c6819d0db5 100644
--- a/include/ginkgo/core/base/lin_op.hpp
+++ b/include/ginkgo/core/base/lin_op.hpp
@@ -625,10 +625,31 @@ class DiagonalExtractable {
 
 
 /**
- * The EnableAbsoluteComputation mixin implementing this interface can be
- * computed. get_absolute gets a new LinOp which contains absolute values from a
- * LinOp and the valuetype will be removed complex. turn_absolute applies
- * absolute inplace, so it still keeps the valuetype of the class.
+ * The AbsoluteComputable is an interface to allow get absolute from a LinOp.
+ * Use EnableAbsoluteComputation<ConcreteLinOp> to implement this interface.
+ */
+class AbsoluteComputable {
+public:
+    /**
+     * Gets the absolute LinOp
+     *
+     * @return a pointer to the new absolute LinOp
+     */
+    virtual std::unique_ptr<LinOp> get_absolute_linop() const = 0;
+
+    /**
+     * Apply absolute on each element.
+     */
+    virtual void apply_absolute() = 0;
+};
+
+
+/**
+ * The EnableAbsoluteComputation mixin provides the default implementations of
+ * `get_absolute_linop` and the absolute interface. `get_absolute` gets a new
+ * remove_complex<ConcreteLinOp> which removes the complex value_type by
+ * applying outplace absolute. `apply_absolute` applies absolute inplace, so it
+ * still keeps the value_type of the class.
  *
  * @tparam ConcreteLinOp  the concrete LinOp which is being implemented
  *                        [CRTP parameter]
@@ -636,25 +657,23 @@ class DiagonalExtractable {
  * @ingroup LinOp
  */
 template <typename ConcreteLinOp>
-class EnableAbsoluteComputation {
+class EnableAbsoluteComputation : public AbsoluteComputable {
 public:
     using outplace_type = remove_complex<ConcreteLinOp>;
 
     virtual ~EnableAbsoluteComputation() = default;
 
+    std::unique_ptr<LinOp> get_absolute_linop() const override
+    {
+        return this->get_absolute();
+    }
+
     /**
      * Gets the absolute LinOp
      *
      * @return a pointer to the new absolute object
      */
     virtual std::unique_ptr<outplace_type> get_absolute() const = 0;
-
-    /**
-     * Turns the value
-     *
-     * @return a pointer to the new absolute object
-     */
-    virtual void turn_absolute() = 0;
 };
 
 
diff --git a/include/ginkgo/core/base/math.hpp b/include/ginkgo/core/base/math.hpp
index ce62ed82e7f..85abf81a08e 100644
--- a/include/ginkgo/core/base/math.hpp
+++ b/include/ginkgo/core/base/math.hpp
@@ -752,33 +752,6 @@ GKO_INLINE GKO_ATTRIBUTES constexpr T one(const T &)
 #undef GKO_BIND_ZERO_ONE
 
 
-/**
- * Returns the absolute value of the object.
- *
- * @tparam T  the type of the object
- *
- * @param x  the object
- *
- * @return x >= zero<T>() ? x : -x;
- */
-template <typename T>
-GKO_INLINE
-    GKO_ATTRIBUTES constexpr xstd::enable_if_t<!is_complex_s<T>::value, T>
-    abs(const T &x)
-{
-    return x >= zero<T>() ? x : -x;
-}
-
-
-template <typename T>
-GKO_INLINE GKO_ATTRIBUTES constexpr xstd::enable_if_t<is_complex_s<T>::value,
-                                                      remove_complex<T>>
-abs(const T &x)
-{
-    return sqrt(squared_norm(x));
-}
-
-
 /**
  * Returns the larger of the arguments.
  *
@@ -902,6 +875,33 @@ GKO_INLINE GKO_ATTRIBUTES constexpr auto squared_norm(const T &x)
 }
 
 
+/**
+ * Returns the absolute value of the object.
+ *
+ * @tparam T  the type of the object
+ *
+ * @param x  the object
+ *
+ * @return x >= zero<T>() ? x : -x;
+ */
+template <typename T>
+GKO_INLINE
+    GKO_ATTRIBUTES constexpr xstd::enable_if_t<!is_complex_s<T>::value, T>
+    abs(const T &x)
+{
+    return x >= zero<T>() ? x : -x;
+}
+
+
+template <typename T>
+GKO_INLINE GKO_ATTRIBUTES constexpr xstd::enable_if_t<is_complex_s<T>::value,
+                                                      remove_complex<T>>
+abs(const T &x)
+{
+    return sqrt(squared_norm(x));
+}
+
+
 /**
  * Returns the position of the most significant bit of the number.
  *
diff --git a/include/ginkgo/core/matrix/coo.hpp b/include/ginkgo/core/matrix/coo.hpp
index 7508d312fdc..bde9046aef4 100644
--- a/include/ginkgo/core/matrix/coo.hpp
+++ b/include/ginkgo/core/matrix/coo.hpp
@@ -123,7 +123,7 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
 
     std::unique_ptr<outplace_absolute_type> get_absolute() const override;
 
-    void turn_absolute() override;
+    void apply_absolute() override;
 
     /**
      * Returns the values of the matrix.
diff --git a/include/ginkgo/core/matrix/csr.hpp b/include/ginkgo/core/matrix/csr.hpp
index ad9d77ee907..60b32cc2196 100644
--- a/include/ginkgo/core/matrix/csr.hpp
+++ b/include/ginkgo/core/matrix/csr.hpp
@@ -714,7 +714,7 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
 
     std::unique_ptr<outplace_absolute_type> get_absolute() const override;
 
-    void turn_absolute() override;
+    void apply_absolute() override;
 
     /**
      * Sorts all (value, col_idx) pairs in each row by column index
diff --git a/include/ginkgo/core/matrix/dense.hpp b/include/ginkgo/core/matrix/dense.hpp
index 912040345cd..ddc7b4d9519 100644
--- a/include/ginkgo/core/matrix/dense.hpp
+++ b/include/ginkgo/core/matrix/dense.hpp
@@ -251,7 +251,7 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
 
     std::unique_ptr<outplace_absolute_type> get_absolute() const override;
 
-    void turn_absolute() override;
+    void apply_absolute() override;
 
     /**
      * Returns a pointer to the array of values of the matrix.
diff --git a/include/ginkgo/core/matrix/diagonal.hpp b/include/ginkgo/core/matrix/diagonal.hpp
index 38526439d95..ceb97e363ca 100644
--- a/include/ginkgo/core/matrix/diagonal.hpp
+++ b/include/ginkgo/core/matrix/diagonal.hpp
@@ -105,7 +105,7 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
 
     std::unique_ptr<outplace_absolute_type> get_absolute() const override;
 
-    void turn_absolute() override;
+    void apply_absolute() override;
 
     /**
      * Returns a pointer to the array of values of the matrix.
diff --git a/include/ginkgo/core/matrix/ell.hpp b/include/ginkgo/core/matrix/ell.hpp
index f9c68fb0171..02b3a3613c8 100644
--- a/include/ginkgo/core/matrix/ell.hpp
+++ b/include/ginkgo/core/matrix/ell.hpp
@@ -116,7 +116,7 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
 
     std::unique_ptr<outplace_absolute_type> get_absolute() const override;
 
-    void turn_absolute() override;
+    void apply_absolute() override;
 
     /**
      * Returns the values of the matrix.
diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index 7f544da8b10..6dcee07bbe2 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -365,7 +365,7 @@ class Hybrid
 
     std::unique_ptr<outplace_absolute_type> get_absolute() const override;
 
-    void turn_absolute() override;
+    void apply_absolute() override;
 
     /**
      * Returns the values of the ell part.
diff --git a/include/ginkgo/core/matrix/sellp.hpp b/include/ginkgo/core/matrix/sellp.hpp
index 3c6cb087be5..6f4b879a0d9 100644
--- a/include/ginkgo/core/matrix/sellp.hpp
+++ b/include/ginkgo/core/matrix/sellp.hpp
@@ -113,7 +113,7 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
 
     std::unique_ptr<outplace_absolute_type> get_absolute() const override;
 
-    void turn_absolute() override;
+    void apply_absolute() override;
 
     /**
      * Returns the values of the matrix.
diff --git a/omp/test/matrix/coo_kernels.cpp b/omp/test/matrix/coo_kernels.cpp
index cc1da48c5ea..03090fd2f54 100644
--- a/omp/test/matrix/coo_kernels.cpp
+++ b/omp/test/matrix/coo_kernels.cpp
@@ -238,8 +238,8 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/csr_kernels.cpp b/omp/test/matrix/csr_kernels.cpp
index 9674b2da1e3..8b6a54cdf37 100644
--- a/omp/test/matrix/csr_kernels.cpp
+++ b/omp/test/matrix/csr_kernels.cpp
@@ -553,8 +553,8 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -575,8 +575,8 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    complex_mtx->turn_absolute();
-    complex_dmtx->turn_absolute();
+    complex_mtx->apply_absolute();
+    complex_dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/dense_kernels.cpp b/omp/test/matrix/dense_kernels.cpp
index 42b91f5bdcd..65afcbf8502 100644
--- a/omp/test/matrix/dense_kernels.cpp
+++ b/omp/test/matrix/dense_kernels.cpp
@@ -706,8 +706,8 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    x->turn_absolute();
-    dx->turn_absolute();
+    x->apply_absolute();
+    dx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/diagonal_kernels.cpp b/omp/test/matrix/diagonal_kernels.cpp
index d9075a450d2..571ca6fe7e6 100644
--- a/omp/test/matrix/diagonal_kernels.cpp
+++ b/omp/test/matrix/diagonal_kernels.cpp
@@ -252,8 +252,8 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    diag->turn_absolute();
-    ddiag->turn_absolute();
+    diag->apply_absolute();
+    ddiag->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
 }
diff --git a/omp/test/matrix/ell_kernels.cpp b/omp/test/matrix/ell_kernels.cpp
index f37c313591b..584e88488c2 100644
--- a/omp/test/matrix/ell_kernels.cpp
+++ b/omp/test/matrix/ell_kernels.cpp
@@ -236,8 +236,8 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/hybrid_kernels.cpp b/omp/test/matrix/hybrid_kernels.cpp
index c0b3a329d93..046d4c254a5 100644
--- a/omp/test/matrix/hybrid_kernels.cpp
+++ b/omp/test/matrix/hybrid_kernels.cpp
@@ -234,8 +234,8 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/sellp_kernels.cpp b/omp/test/matrix/sellp_kernels.cpp
index 1c758de6113..9d861d2db69 100644
--- a/omp/test/matrix/sellp_kernels.cpp
+++ b/omp/test/matrix/sellp_kernels.cpp
@@ -270,8 +270,8 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->turn_absolute();
-    dmtx->turn_absolute();
+    mtx->apply_absolute();
+    dmtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
diff --git a/reference/test/matrix/coo_kernels.cpp b/reference/test/matrix/coo_kernels.cpp
index e0666b7ccda..0f75f7a1eea 100644
--- a/reference/test/matrix/coo_kernels.cpp
+++ b/reference/test/matrix/coo_kernels.cpp
@@ -540,7 +540,7 @@ TYPED_TEST(Coo, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -606,7 +606,7 @@ TYPED_TEST(CooComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/csr_kernels.cpp b/reference/test/matrix/csr_kernels.cpp
index 3ab5fbe3269..e2fc18432aa 100644
--- a/reference/test/matrix/csr_kernels.cpp
+++ b/reference/test/matrix/csr_kernels.cpp
@@ -1313,7 +1313,7 @@ TYPED_TEST(Csr, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -1386,7 +1386,7 @@ TYPED_TEST(CsrComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/dense_kernels.cpp b/reference/test/matrix/dense_kernels.cpp
index c41a748d6d5..94cb1c42542 100644
--- a/reference/test/matrix/dense_kernels.cpp
+++ b/reference/test/matrix/dense_kernels.cpp
@@ -2017,7 +2017,7 @@ TYPED_TEST(Dense, InplaceAbsolute)
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
-    this->mtx5->turn_absolute();
+    this->mtx5->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(this->mtx5,
                         l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}),
@@ -2035,7 +2035,7 @@ TYPED_TEST(Dense, InplaceAbsoluteSubMatrix)
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(this->mtx5,
                         l({{1.0, 1.0, -0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}),
@@ -2119,7 +2119,7 @@ TYPED_TEST(DenseComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/diagonal_kernels.cpp b/reference/test/matrix/diagonal_kernels.cpp
index d2ab3f3453c..69502cca362 100644
--- a/reference/test/matrix/diagonal_kernels.cpp
+++ b/reference/test/matrix/diagonal_kernels.cpp
@@ -360,7 +360,7 @@ TYPED_TEST(Diagonal, InplaceAbsolute)
 {
     using value_type = typename TestFixture::value_type;
 
-    this->diag1->turn_absolute();
+    this->diag1->apply_absolute();
     auto values = this->diag1->get_values();
 
     EXPECT_EQ(values[0], value_type(2.0));
@@ -425,7 +425,7 @@ TYPED_TEST(DiagonalComplex, InplaceAbsolute)
     diag_values[1] = value_type{-3.0, 0.0};
     diag_values[2] = value_type{0.0, -1.5};
 
-    diag->turn_absolute();
+    diag->apply_absolute();
 
     EXPECT_EQ(diag_values[0], (value_type{5.0, 0.0}));
     EXPECT_EQ(diag_values[1], (value_type{3.0, 0.0}));
diff --git a/reference/test/matrix/ell_kernels.cpp b/reference/test/matrix/ell_kernels.cpp
index 47221ecfeb2..13b7decd1f1 100644
--- a/reference/test/matrix/ell_kernels.cpp
+++ b/reference/test/matrix/ell_kernels.cpp
@@ -618,7 +618,7 @@ TYPED_TEST(Ell, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -664,7 +664,7 @@ TYPED_TEST(EllComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/hybrid_kernels.cpp b/reference/test/matrix/hybrid_kernels.cpp
index e5bd30fa00e..17f0aae4c50 100644
--- a/reference/test/matrix/hybrid_kernels.cpp
+++ b/reference/test/matrix/hybrid_kernels.cpp
@@ -662,7 +662,7 @@ TYPED_TEST(Hybrid, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -728,7 +728,7 @@ TYPED_TEST(HybridComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/sellp_kernels.cpp b/reference/test/matrix/sellp_kernels.cpp
index 6ab86e8ce1a..7eef159ddeb 100644
--- a/reference/test/matrix/sellp_kernels.cpp
+++ b/reference/test/matrix/sellp_kernels.cpp
@@ -621,7 +621,7 @@ TYPED_TEST(Sellp, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -687,7 +687,7 @@ TYPED_TEST(SellpComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->turn_absolute();
+    mtx->apply_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);

From b595be9dabb1320262aa250af6e9c111271a511a Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 9 Sep 2020 15:49:01 +0200
Subject: [PATCH 08/15] get/apply_absolute -> compute_absolute(_inplace)

Co-authored-by: Tobias Ribizel <ribizel@kit.edu>
---
 core/matrix/coo.cpp                        |  4 ++--
 core/matrix/csr.cpp                        |  4 ++--
 core/matrix/dense.cpp                      |  4 ++--
 core/matrix/diagonal.cpp                   |  4 ++--
 core/matrix/ell.cpp                        |  4 ++--
 core/matrix/hybrid.cpp                     |  8 ++++----
 core/matrix/sellp.cpp                      |  4 ++--
 core/test/base/lin_op.cpp                  | 12 ++++++------
 cuda/test/matrix/coo_kernels.cpp           |  8 ++++----
 cuda/test/matrix/csr_kernels.cpp           | 16 ++++++++--------
 cuda/test/matrix/dense_kernels.cpp         |  8 ++++----
 cuda/test/matrix/diagonal_kernels.cpp      |  8 ++++----
 cuda/test/matrix/ell_kernels.cpp           |  8 ++++----
 cuda/test/matrix/hybrid_kernels.cpp        |  8 ++++----
 cuda/test/matrix/sellp_kernels.cpp         |  8 ++++----
 hip/test/matrix/coo_kernels.hip.cpp        |  8 ++++----
 hip/test/matrix/csr_kernels.hip.cpp        | 16 ++++++++--------
 hip/test/matrix/dense_kernels.hip.cpp      |  8 ++++----
 hip/test/matrix/diagonal_kernels.hip.cpp   |  8 ++++----
 hip/test/matrix/ell_kernels.hip.cpp        |  8 ++++----
 hip/test/matrix/hybrid_kernels.hip.cpp     |  8 ++++----
 hip/test/matrix/sellp_kernels.hip.cpp      |  8 ++++----
 include/ginkgo/core/base/lin_op.hpp        | 22 +++++++++++-----------
 include/ginkgo/core/matrix/coo.hpp         |  4 ++--
 include/ginkgo/core/matrix/csr.hpp         |  4 ++--
 include/ginkgo/core/matrix/dense.hpp       |  4 ++--
 include/ginkgo/core/matrix/diagonal.hpp    |  4 ++--
 include/ginkgo/core/matrix/ell.hpp         |  4 ++--
 include/ginkgo/core/matrix/hybrid.hpp      |  4 ++--
 include/ginkgo/core/matrix/sellp.hpp       |  4 ++--
 omp/test/matrix/coo_kernels.cpp            |  8 ++++----
 omp/test/matrix/csr_kernels.cpp            | 16 ++++++++--------
 omp/test/matrix/dense_kernels.cpp          |  8 ++++----
 omp/test/matrix/diagonal_kernels.cpp       |  8 ++++----
 omp/test/matrix/ell_kernels.cpp            |  8 ++++----
 omp/test/matrix/hybrid_kernels.cpp         |  8 ++++----
 omp/test/matrix/sellp_kernels.cpp          |  8 ++++----
 reference/test/matrix/coo_kernels.cpp      |  8 ++++----
 reference/test/matrix/csr_kernels.cpp      |  8 ++++----
 reference/test/matrix/dense_kernels.cpp    | 12 ++++++------
 reference/test/matrix/diagonal_kernels.cpp |  8 ++++----
 reference/test/matrix/ell_kernels.cpp      |  8 ++++----
 reference/test/matrix/hybrid_kernels.cpp   |  8 ++++----
 reference/test/matrix/sellp_kernels.cpp    |  8 ++++----
 44 files changed, 173 insertions(+), 173 deletions(-)

diff --git a/core/matrix/coo.cpp b/core/matrix/coo.cpp
index b9648d1dc70..50b42d04ab4 100644
--- a/core/matrix/coo.cpp
+++ b/core/matrix/coo.cpp
@@ -239,7 +239,7 @@ Coo<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Coo<ValueType, IndexType>::apply_absolute()
+void Coo<ValueType, IndexType>::compute_absolute_inplace()
 {
     auto exec = this->get_executor();
 
@@ -250,7 +250,7 @@ void Coo<ValueType, IndexType>::apply_absolute()
 
 template <typename ValueType, typename IndexType>
 std::unique_ptr<typename Coo<ValueType, IndexType>::outplace_absolute_type>
-Coo<ValueType, IndexType>::get_absolute() const
+Coo<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/csr.cpp b/core/matrix/csr.cpp
index 8a6ad620885..605f7b09fed 100644
--- a/core/matrix/csr.cpp
+++ b/core/matrix/csr.cpp
@@ -487,7 +487,7 @@ Csr<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Csr<ValueType, IndexType>::apply_absolute()
+void Csr<ValueType, IndexType>::compute_absolute_inplace()
 {
     auto exec = this->get_executor();
 
@@ -498,7 +498,7 @@ void Csr<ValueType, IndexType>::apply_absolute()
 
 template <typename ValueType, typename IndexType>
 std::unique_ptr<typename Csr<ValueType, IndexType>::outplace_absolute_type>
-Csr<ValueType, IndexType>::get_absolute() const
+Csr<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/dense.cpp b/core/matrix/dense.cpp
index 19152c62d9a..e51ad7bcff1 100644
--- a/core/matrix/dense.cpp
+++ b/core/matrix/dense.cpp
@@ -755,7 +755,7 @@ std::unique_ptr<Diagonal<ValueType>> Dense<ValueType>::extract_diagonal() const
 
 
 template <typename ValueType>
-void Dense<ValueType>::apply_absolute()
+void Dense<ValueType>::compute_absolute_inplace()
 {
     auto exec = this->get_executor();
 
@@ -765,7 +765,7 @@ void Dense<ValueType>::apply_absolute()
 
 template <typename ValueType>
 std::unique_ptr<typename Dense<ValueType>::outplace_absolute_type>
-Dense<ValueType>::get_absolute() const
+Dense<ValueType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/diagonal.cpp b/core/matrix/diagonal.cpp
index e136e90a919..e1cb767efbf 100644
--- a/core/matrix/diagonal.cpp
+++ b/core/matrix/diagonal.cpp
@@ -267,7 +267,7 @@ void Diagonal<ValueType>::write(mat_data32 &data) const
 
 
 template <typename ValueType>
-void Diagonal<ValueType>::apply_absolute()
+void Diagonal<ValueType>::compute_absolute_inplace()
 {
     auto exec = this->get_executor();
 
@@ -278,7 +278,7 @@ void Diagonal<ValueType>::apply_absolute()
 
 template <typename ValueType>
 std::unique_ptr<typename Diagonal<ValueType>::outplace_absolute_type>
-Diagonal<ValueType>::get_absolute() const
+Diagonal<ValueType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/ell.cpp b/core/matrix/ell.cpp
index 28acf7a3a39..26f518d2cbc 100644
--- a/core/matrix/ell.cpp
+++ b/core/matrix/ell.cpp
@@ -257,7 +257,7 @@ Ell<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Ell<ValueType, IndexType>::apply_absolute()
+void Ell<ValueType, IndexType>::compute_absolute_inplace()
 {
     auto exec = this->get_executor();
 
@@ -268,7 +268,7 @@ void Ell<ValueType, IndexType>::apply_absolute()
 
 template <typename ValueType, typename IndexType>
 std::unique_ptr<typename Ell<ValueType, IndexType>::outplace_absolute_type>
-Ell<ValueType, IndexType>::get_absolute() const
+Ell<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
diff --git a/core/matrix/hybrid.cpp b/core/matrix/hybrid.cpp
index cd5adcfbdcd..9487bd99a4e 100644
--- a/core/matrix/hybrid.cpp
+++ b/core/matrix/hybrid.cpp
@@ -291,7 +291,7 @@ Hybrid<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Hybrid<ValueType, IndexType>::apply_absolute()
+void Hybrid<ValueType, IndexType>::compute_absolute_inplace()
 {
     auto exec = this->get_executor();
 
@@ -304,15 +304,15 @@ void Hybrid<ValueType, IndexType>::apply_absolute()
 
 template <typename ValueType, typename IndexType>
 std::unique_ptr<typename Hybrid<ValueType, IndexType>::outplace_absolute_type>
-Hybrid<ValueType, IndexType>::get_absolute() const
+Hybrid<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
     // use default strategy
     auto abs_hybrid = outplace_absolute_type::create(exec, this->get_size());
 
-    abs_hybrid->ell_->copy_from(ell_->get_absolute());
-    abs_hybrid->coo_->copy_from(coo_->get_absolute());
+    abs_hybrid->ell_->copy_from(ell_->compute_absolute());
+    abs_hybrid->coo_->copy_from(coo_->compute_absolute());
 
     return abs_hybrid;
 }
diff --git a/core/matrix/sellp.cpp b/core/matrix/sellp.cpp
index e57555c067b..81af57b5dd6 100644
--- a/core/matrix/sellp.cpp
+++ b/core/matrix/sellp.cpp
@@ -310,7 +310,7 @@ Sellp<ValueType, IndexType>::extract_diagonal() const
 
 
 template <typename ValueType, typename IndexType>
-void Sellp<ValueType, IndexType>::apply_absolute()
+void Sellp<ValueType, IndexType>::compute_absolute_inplace()
 {
     auto exec = this->get_executor();
 
@@ -321,7 +321,7 @@ void Sellp<ValueType, IndexType>::apply_absolute()
 
 template <typename ValueType, typename IndexType>
 std::unique_ptr<typename Sellp<ValueType, IndexType>::outplace_absolute_type>
-Sellp<ValueType, IndexType>::get_absolute() const
+Sellp<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
diff --git a/core/test/base/lin_op.cpp b/core/test/base/lin_op.cpp
index e5eea7d7c70..497396efaeb 100644
--- a/core/test/base/lin_op.cpp
+++ b/core/test/base/lin_op.cpp
@@ -331,9 +331,9 @@ class DummyLinOpWithType
         : gko::EnableLinOp<DummyLinOpWithType>(exec, size), value_(value)
     {}
 
-    void apply_absolute() override { value_ = gko::abs(value_); }
+    void compute_absolute_inplace() override { value_ = gko::abs(value_); }
 
-    std::unique_ptr<outplace_absolute_type> get_absolute() const override
+    std::unique_ptr<outplace_absolute_type> compute_absolute() const override
     {
         return std::make_unique<outplace_absolute_type>(
             this->get_executor(), this->get_size(), gko::abs(value_));
@@ -369,7 +369,7 @@ class EnableAbsoluteComputation : public ::testing::Test {
 
 TEST_F(EnableAbsoluteComputation, InplaceAbsoluteOnConcreteType)
 {
-    op->apply_absolute();
+    op->compute_absolute_inplace();
 
     ASSERT_EQ(op->get_value(), std::complex<double>{5.0});
 }
@@ -377,7 +377,7 @@ TEST_F(EnableAbsoluteComputation, InplaceAbsoluteOnConcreteType)
 
 TEST_F(EnableAbsoluteComputation, OutplaceAbsoluteOnConcreteType)
 {
-    auto abs_op = op->get_absolute();
+    auto abs_op = op->compute_absolute();
 
     ASSERT_EQ(typeid(abs_op),
               typeid(std::unique_ptr<gko::remove_complex<dummy_type>>));
@@ -389,7 +389,7 @@ TEST_F(EnableAbsoluteComputation, InplaceAbsoluteOnAbsoluteComputable)
 {
     auto linop = gko::as<gko::LinOp>(op);
 
-    gko::as<gko::AbsoluteComputable>(linop)->apply_absolute();
+    gko::as<gko::AbsoluteComputable>(linop)->compute_absolute_inplace();
 
     ASSERT_EQ(gko::as<dummy_type>(linop)->get_value(),
               std::complex<double>{5.0});
@@ -398,7 +398,7 @@ TEST_F(EnableAbsoluteComputation, InplaceAbsoluteOnAbsoluteComputable)
 
 TEST_F(EnableAbsoluteComputation, OutplaceAbsoluteOnAbsoluteComputable)
 {
-    auto abs_op = op->get_absolute();
+    auto abs_op = op->compute_absolute();
 
     ASSERT_EQ(typeid(abs_op),
               typeid(std::unique_ptr<gko::remove_complex<dummy_type>>));
diff --git a/cuda/test/matrix/coo_kernels.cpp b/cuda/test/matrix/coo_kernels.cpp
index 7575314ad7e..cc52e895097 100644
--- a/cuda/test/matrix/coo_kernels.cpp
+++ b/cuda/test/matrix/coo_kernels.cpp
@@ -275,8 +275,8 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -286,8 +286,8 @@ TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/csr_kernels.cpp b/cuda/test/matrix/csr_kernels.cpp
index d51ea16bc33..f8a171719a1 100644
--- a/cuda/test/matrix/csr_kernels.cpp
+++ b/cuda/test/matrix/csr_kernels.cpp
@@ -744,8 +744,8 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data(std::make_shared<Mtx::automatical>(cuda));
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -755,8 +755,8 @@ TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data(std::make_shared<Mtx::automatical>(cuda));
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
@@ -766,8 +766,8 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(cuda));
 
-    complex_mtx->apply_absolute();
-    complex_dmtx->apply_absolute();
+    complex_mtx->compute_absolute_inplace();
+    complex_dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
 }
@@ -777,8 +777,8 @@ TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(cuda));
 
-    auto abs_mtx = complex_mtx->get_absolute();
-    auto dabs_mtx = complex_dmtx->get_absolute();
+    auto abs_mtx = complex_mtx->compute_absolute();
+    auto dabs_mtx = complex_dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/dense_kernels.cpp b/cuda/test/matrix/dense_kernels.cpp
index 1121b994fd6..38273b107e1 100644
--- a/cuda/test/matrix/dense_kernels.cpp
+++ b/cuda/test/matrix/dense_kernels.cpp
@@ -591,8 +591,8 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    x->apply_absolute();
-    dx->apply_absolute();
+    x->compute_absolute_inplace();
+    dx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
 }
@@ -602,8 +602,8 @@ TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_x = x->get_absolute();
-    auto dabs_x = dx->get_absolute();
+    auto abs_x = x->compute_absolute();
+    auto dabs_x = dx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/diagonal_kernels.cpp b/cuda/test/matrix/diagonal_kernels.cpp
index 6a357769022..a3471be6929 100644
--- a/cuda/test/matrix/diagonal_kernels.cpp
+++ b/cuda/test/matrix/diagonal_kernels.cpp
@@ -253,8 +253,8 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    diag->apply_absolute();
-    ddiag->apply_absolute();
+    diag->compute_absolute_inplace();
+    ddiag->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
 }
@@ -264,8 +264,8 @@ TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_diag = diag->get_absolute();
-    auto dabs_diag = ddiag->get_absolute();
+    auto abs_diag = diag->compute_absolute();
+    auto dabs_diag = ddiag->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/ell_kernels.cpp b/cuda/test/matrix/ell_kernels.cpp
index 3df92e8c859..86a2ed1d099 100644
--- a/cuda/test/matrix/ell_kernels.cpp
+++ b/cuda/test/matrix/ell_kernels.cpp
@@ -360,8 +360,8 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -371,8 +371,8 @@ TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/hybrid_kernels.cpp b/cuda/test/matrix/hybrid_kernels.cpp
index f9adc82ff53..eb8b5ba7669 100644
--- a/cuda/test/matrix/hybrid_kernels.cpp
+++ b/cuda/test/matrix/hybrid_kernels.cpp
@@ -235,8 +235,8 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -246,8 +246,8 @@ TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/cuda/test/matrix/sellp_kernels.cpp b/cuda/test/matrix/sellp_kernels.cpp
index 43375ffb0cf..91f063de36a 100644
--- a/cuda/test/matrix/sellp_kernels.cpp
+++ b/cuda/test/matrix/sellp_kernels.cpp
@@ -354,8 +354,8 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_matrix(32, 2);
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -365,8 +365,8 @@ TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_matrix(32, 2);
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/coo_kernels.hip.cpp b/hip/test/matrix/coo_kernels.hip.cpp
index 470694c1ece..b235da23077 100644
--- a/hip/test/matrix/coo_kernels.hip.cpp
+++ b/hip/test/matrix/coo_kernels.hip.cpp
@@ -275,8 +275,8 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -286,8 +286,8 @@ TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/csr_kernels.hip.cpp b/hip/test/matrix/csr_kernels.hip.cpp
index cbcb3c1b37e..2a2a8260cbf 100644
--- a/hip/test/matrix/csr_kernels.hip.cpp
+++ b/hip/test/matrix/csr_kernels.hip.cpp
@@ -729,8 +729,8 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data(std::make_shared<Mtx::automatical>(hip));
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -740,8 +740,8 @@ TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data(std::make_shared<Mtx::automatical>(hip));
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
@@ -751,8 +751,8 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(hip));
 
-    complex_mtx->apply_absolute();
-    complex_dmtx->apply_absolute();
+    complex_mtx->compute_absolute_inplace();
+    complex_dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
 }
@@ -762,8 +762,8 @@ TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_complex_data(std::make_shared<ComplexMtx::automatical>(hip));
 
-    auto abs_mtx = complex_mtx->get_absolute();
-    auto dabs_mtx = complex_dmtx->get_absolute();
+    auto abs_mtx = complex_mtx->compute_absolute();
+    auto dabs_mtx = complex_dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/dense_kernels.hip.cpp b/hip/test/matrix/dense_kernels.hip.cpp
index 86e907d27ab..a1dd4f34ec8 100644
--- a/hip/test/matrix/dense_kernels.hip.cpp
+++ b/hip/test/matrix/dense_kernels.hip.cpp
@@ -573,8 +573,8 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    x->apply_absolute();
-    dx->apply_absolute();
+    x->compute_absolute_inplace();
+    dx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
 }
@@ -584,8 +584,8 @@ TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_x = x->get_absolute();
-    auto dabs_x = dx->get_absolute();
+    auto abs_x = x->compute_absolute();
+    auto dabs_x = dx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
 }
diff --git a/hip/test/matrix/diagonal_kernels.hip.cpp b/hip/test/matrix/diagonal_kernels.hip.cpp
index dd89c7945e5..d86e878dd66 100644
--- a/hip/test/matrix/diagonal_kernels.hip.cpp
+++ b/hip/test/matrix/diagonal_kernels.hip.cpp
@@ -253,8 +253,8 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    diag->apply_absolute();
-    ddiag->apply_absolute();
+    diag->compute_absolute_inplace();
+    ddiag->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
 }
@@ -264,8 +264,8 @@ TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_diag = diag->get_absolute();
-    auto dabs_diag = ddiag->get_absolute();
+    auto abs_diag = diag->compute_absolute();
+    auto dabs_diag = ddiag->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
 }
diff --git a/hip/test/matrix/ell_kernels.hip.cpp b/hip/test/matrix/ell_kernels.hip.cpp
index 502035ba9c5..4ae03c3d00e 100644
--- a/hip/test/matrix/ell_kernels.hip.cpp
+++ b/hip/test/matrix/ell_kernels.hip.cpp
@@ -360,8 +360,8 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -371,8 +371,8 @@ TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/hybrid_kernels.hip.cpp b/hip/test/matrix/hybrid_kernels.hip.cpp
index be1cd12ae6c..dd79f63c0f8 100644
--- a/hip/test/matrix/hybrid_kernels.hip.cpp
+++ b/hip/test/matrix/hybrid_kernels.hip.cpp
@@ -235,8 +235,8 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -246,8 +246,8 @@ TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/hip/test/matrix/sellp_kernels.hip.cpp b/hip/test/matrix/sellp_kernels.hip.cpp
index 59d5efda437..8b39aedb189 100644
--- a/hip/test/matrix/sellp_kernels.hip.cpp
+++ b/hip/test/matrix/sellp_kernels.hip.cpp
@@ -353,8 +353,8 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_matrix(32, 2);
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -364,8 +364,8 @@ TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_matrix(32, 2);
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/include/ginkgo/core/base/lin_op.hpp b/include/ginkgo/core/base/lin_op.hpp
index 8c6819d0db5..a72f3685848 100644
--- a/include/ginkgo/core/base/lin_op.hpp
+++ b/include/ginkgo/core/base/lin_op.hpp
@@ -635,21 +635,21 @@ class AbsoluteComputable {
      *
      * @return a pointer to the new absolute LinOp
      */
-    virtual std::unique_ptr<LinOp> get_absolute_linop() const = 0;
+    virtual std::unique_ptr<LinOp> compute_absolute_linop() const = 0;
 
     /**
-     * Apply absolute on each element.
+     * Compute absolute inplace on each element.
      */
-    virtual void apply_absolute() = 0;
+    virtual void compute_absolute_inplace() = 0;
 };
 
 
 /**
  * The EnableAbsoluteComputation mixin provides the default implementations of
- * `get_absolute_linop` and the absolute interface. `get_absolute` gets a new
- * remove_complex<ConcreteLinOp> which removes the complex value_type by
- * applying outplace absolute. `apply_absolute` applies absolute inplace, so it
- * still keeps the value_type of the class.
+ * `compute_absolute_linop` and the absolute interface. `compute_absolute` gets
+ * a new remove_complex<ConcreteLinOp> which removes the complex value_type by
+ * applying outplace absolute. `compute_absolute_inplace` applies absolute
+ * inplace, so it still keeps the value_type of the class.
  *
  * @tparam ConcreteLinOp  the concrete LinOp which is being implemented
  *                        [CRTP parameter]
@@ -663,17 +663,17 @@ class EnableAbsoluteComputation : public AbsoluteComputable {
 
     virtual ~EnableAbsoluteComputation() = default;
 
-    std::unique_ptr<LinOp> get_absolute_linop() const override
+    std::unique_ptr<LinOp> compute_absolute_linop() const override
     {
-        return this->get_absolute();
+        return this->compute_absolute();
     }
 
     /**
-     * Gets the absolute LinOp
+     * Gets the absolute ConcreteLinOp
      *
      * @return a pointer to the new absolute object
      */
-    virtual std::unique_ptr<outplace_type> get_absolute() const = 0;
+    virtual std::unique_ptr<outplace_type> compute_absolute() const = 0;
 };
 
 
diff --git a/include/ginkgo/core/matrix/coo.hpp b/include/ginkgo/core/matrix/coo.hpp
index bde9046aef4..45b1c257c96 100644
--- a/include/ginkgo/core/matrix/coo.hpp
+++ b/include/ginkgo/core/matrix/coo.hpp
@@ -121,9 +121,9 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
 
-    void apply_absolute() override;
+    void compute_absolute_inplace() override;
 
     /**
      * Returns the values of the matrix.
diff --git a/include/ginkgo/core/matrix/csr.hpp b/include/ginkgo/core/matrix/csr.hpp
index 60b32cc2196..bc41f528e23 100644
--- a/include/ginkgo/core/matrix/csr.hpp
+++ b/include/ginkgo/core/matrix/csr.hpp
@@ -712,9 +712,9 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
 
-    void apply_absolute() override;
+    void compute_absolute_inplace() override;
 
     /**
      * Sorts all (value, col_idx) pairs in each row by column index
diff --git a/include/ginkgo/core/matrix/dense.hpp b/include/ginkgo/core/matrix/dense.hpp
index ddc7b4d9519..6f7c2b16c99 100644
--- a/include/ginkgo/core/matrix/dense.hpp
+++ b/include/ginkgo/core/matrix/dense.hpp
@@ -249,9 +249,9 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
 
-    void apply_absolute() override;
+    void compute_absolute_inplace() override;
 
     /**
      * Returns a pointer to the array of values of the matrix.
diff --git a/include/ginkgo/core/matrix/diagonal.hpp b/include/ginkgo/core/matrix/diagonal.hpp
index ceb97e363ca..aec604de9cc 100644
--- a/include/ginkgo/core/matrix/diagonal.hpp
+++ b/include/ginkgo/core/matrix/diagonal.hpp
@@ -103,9 +103,9 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
 
     void move_to(Csr<ValueType, int64> *result) override;
 
-    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
 
-    void apply_absolute() override;
+    void compute_absolute_inplace() override;
 
     /**
      * Returns a pointer to the array of values of the matrix.
diff --git a/include/ginkgo/core/matrix/ell.hpp b/include/ginkgo/core/matrix/ell.hpp
index 02b3a3613c8..6fa705f4ab9 100644
--- a/include/ginkgo/core/matrix/ell.hpp
+++ b/include/ginkgo/core/matrix/ell.hpp
@@ -114,9 +114,9 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
 
-    void apply_absolute() override;
+    void compute_absolute_inplace() override;
 
     /**
      * Returns the values of the matrix.
diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index 6dcee07bbe2..8b19de70766 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -363,9 +363,9 @@ class Hybrid
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
 
-    void apply_absolute() override;
+    void compute_absolute_inplace() override;
 
     /**
      * Returns the values of the ell part.
diff --git a/include/ginkgo/core/matrix/sellp.hpp b/include/ginkgo/core/matrix/sellp.hpp
index 6f4b879a0d9..fb5acd36526 100644
--- a/include/ginkgo/core/matrix/sellp.hpp
+++ b/include/ginkgo/core/matrix/sellp.hpp
@@ -111,9 +111,9 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> get_absolute() const override;
+    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
 
-    void apply_absolute() override;
+    void compute_absolute_inplace() override;
 
     /**
      * Returns the values of the matrix.
diff --git a/omp/test/matrix/coo_kernels.cpp b/omp/test/matrix/coo_kernels.cpp
index 03090fd2f54..b2af927543a 100644
--- a/omp/test/matrix/coo_kernels.cpp
+++ b/omp/test/matrix/coo_kernels.cpp
@@ -238,8 +238,8 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -249,8 +249,8 @@ TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/csr_kernels.cpp b/omp/test/matrix/csr_kernels.cpp
index 8b6a54cdf37..25cb647d98d 100644
--- a/omp/test/matrix/csr_kernels.cpp
+++ b/omp/test/matrix/csr_kernels.cpp
@@ -553,8 +553,8 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -564,8 +564,8 @@ TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
@@ -575,8 +575,8 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    complex_mtx->apply_absolute();
-    complex_dmtx->apply_absolute();
+    complex_mtx->compute_absolute_inplace();
+    complex_dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
 }
@@ -586,8 +586,8 @@ TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = complex_mtx->get_absolute();
-    auto dabs_mtx = complex_dmtx->get_absolute();
+    auto abs_mtx = complex_mtx->compute_absolute();
+    auto dabs_mtx = complex_dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/dense_kernels.cpp b/omp/test/matrix/dense_kernels.cpp
index 65afcbf8502..77781b71aab 100644
--- a/omp/test/matrix/dense_kernels.cpp
+++ b/omp/test/matrix/dense_kernels.cpp
@@ -706,8 +706,8 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    x->apply_absolute();
-    dx->apply_absolute();
+    x->compute_absolute_inplace();
+    dx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
 }
@@ -717,8 +717,8 @@ TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_x = x->get_absolute();
-    auto dabs_x = dx->get_absolute();
+    auto abs_x = x->compute_absolute();
+    auto dabs_x = dx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
 }
diff --git a/omp/test/matrix/diagonal_kernels.cpp b/omp/test/matrix/diagonal_kernels.cpp
index 571ca6fe7e6..2d03fb74f8f 100644
--- a/omp/test/matrix/diagonal_kernels.cpp
+++ b/omp/test/matrix/diagonal_kernels.cpp
@@ -252,8 +252,8 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    diag->apply_absolute();
-    ddiag->apply_absolute();
+    diag->compute_absolute_inplace();
+    ddiag->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
 }
@@ -263,8 +263,8 @@ TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_diag = diag->get_absolute();
-    auto dabs_diag = ddiag->get_absolute();
+    auto abs_diag = diag->compute_absolute();
+    auto dabs_diag = ddiag->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
 }
diff --git a/omp/test/matrix/ell_kernels.cpp b/omp/test/matrix/ell_kernels.cpp
index 584e88488c2..06195abe138 100644
--- a/omp/test/matrix/ell_kernels.cpp
+++ b/omp/test/matrix/ell_kernels.cpp
@@ -236,8 +236,8 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -247,8 +247,8 @@ TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/hybrid_kernels.cpp b/omp/test/matrix/hybrid_kernels.cpp
index 046d4c254a5..df85f18455f 100644
--- a/omp/test/matrix/hybrid_kernels.cpp
+++ b/omp/test/matrix/hybrid_kernels.cpp
@@ -234,8 +234,8 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -245,8 +245,8 @@ TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/omp/test/matrix/sellp_kernels.cpp b/omp/test/matrix/sellp_kernels.cpp
index 9d861d2db69..69780f6071e 100644
--- a/omp/test/matrix/sellp_kernels.cpp
+++ b/omp/test/matrix/sellp_kernels.cpp
@@ -270,8 +270,8 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    mtx->apply_absolute();
-    dmtx->apply_absolute();
+    mtx->compute_absolute_inplace();
+    dmtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
 }
@@ -281,8 +281,8 @@ TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
     set_up_apply_data();
 
-    auto abs_mtx = mtx->get_absolute();
-    auto dabs_mtx = dmtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
+    auto dabs_mtx = dmtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
 }
diff --git a/reference/test/matrix/coo_kernels.cpp b/reference/test/matrix/coo_kernels.cpp
index 0f75f7a1eea..d08ef5f9af9 100644
--- a/reference/test/matrix/coo_kernels.cpp
+++ b/reference/test/matrix/coo_kernels.cpp
@@ -540,7 +540,7 @@ TYPED_TEST(Coo, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -553,7 +553,7 @@ TYPED_TEST(Coo, OutplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -586,7 +586,7 @@ TYPED_TEST(CooComplex, OutplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
@@ -606,7 +606,7 @@ TYPED_TEST(CooComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/csr_kernels.cpp b/reference/test/matrix/csr_kernels.cpp
index e2fc18432aa..ac9ae9f64d8 100644
--- a/reference/test/matrix/csr_kernels.cpp
+++ b/reference/test/matrix/csr_kernels.cpp
@@ -1313,7 +1313,7 @@ TYPED_TEST(Csr, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -1326,7 +1326,7 @@ TYPED_TEST(Csr, OutplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -1386,7 +1386,7 @@ TYPED_TEST(CsrComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
@@ -1406,7 +1406,7 @@ TYPED_TEST(CsrComplex, OutplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/dense_kernels.cpp b/reference/test/matrix/dense_kernels.cpp
index 94cb1c42542..cea66d04f43 100644
--- a/reference/test/matrix/dense_kernels.cpp
+++ b/reference/test/matrix/dense_kernels.cpp
@@ -2017,7 +2017,7 @@ TYPED_TEST(Dense, InplaceAbsolute)
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
-    this->mtx5->apply_absolute();
+    this->mtx5->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(this->mtx5,
                         l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}),
@@ -2035,7 +2035,7 @@ TYPED_TEST(Dense, InplaceAbsoluteSubMatrix)
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(this->mtx5,
                         l({{1.0, 1.0, -0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}),
@@ -2051,7 +2051,7 @@ TYPED_TEST(Dense, OutplaceAbsolute)
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
-    auto abs_mtx = this->mtx5->get_absolute();
+    auto abs_mtx = this->mtx5->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx,
                         l({{1.0, 1.0, 0.5}, {2.0, 2.0, 4.5}, {2.1, 3.4, 1.2}}),
@@ -2069,7 +2069,7 @@ TYPED_TEST(Dense, OutplaceAbsoluteSubMatrix)
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx, l({{1.0, 1.0}, {2.0, 2.0}}),
                         r<TypeParam>::value);
@@ -2119,7 +2119,7 @@ TYPED_TEST(DenseComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
@@ -2138,7 +2138,7 @@ TYPED_TEST(DenseComplex, OutplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/diagonal_kernels.cpp b/reference/test/matrix/diagonal_kernels.cpp
index 69502cca362..fc207889de3 100644
--- a/reference/test/matrix/diagonal_kernels.cpp
+++ b/reference/test/matrix/diagonal_kernels.cpp
@@ -360,7 +360,7 @@ TYPED_TEST(Diagonal, InplaceAbsolute)
 {
     using value_type = typename TestFixture::value_type;
 
-    this->diag1->apply_absolute();
+    this->diag1->compute_absolute_inplace();
     auto values = this->diag1->get_values();
 
     EXPECT_EQ(values[0], value_type(2.0));
@@ -373,7 +373,7 @@ TYPED_TEST(Diagonal, OutplaceAbsolute)
     using value_type = typename TestFixture::value_type;
     using abs_type = gko::remove_complex<value_type>;
 
-    auto abs_diag = this->diag1->get_absolute();
+    auto abs_diag = this->diag1->compute_absolute();
     auto values = abs_diag->get_values();
 
     EXPECT_EQ(values[0], value_type(2.0));
@@ -425,7 +425,7 @@ TYPED_TEST(DiagonalComplex, InplaceAbsolute)
     diag_values[1] = value_type{-3.0, 0.0};
     diag_values[2] = value_type{0.0, -1.5};
 
-    diag->apply_absolute();
+    diag->compute_absolute_inplace();
 
     EXPECT_EQ(diag_values[0], (value_type{5.0, 0.0}));
     EXPECT_EQ(diag_values[1], (value_type{3.0, 0.0}));
@@ -446,7 +446,7 @@ TYPED_TEST(DiagonalComplex, OutplaceAbsolute)
     diag_values[1] = value_type{-3.0, 0.0};
     diag_values[2] = value_type{0.0, -1.5};
 
-    auto abs_diag = diag->get_absolute();
+    auto abs_diag = diag->compute_absolute();
     auto abs_values = abs_diag->get_values();
 
     EXPECT_EQ(abs_values[0], (value_type{5.0}));
diff --git a/reference/test/matrix/ell_kernels.cpp b/reference/test/matrix/ell_kernels.cpp
index 13b7decd1f1..cc87f580f9e 100644
--- a/reference/test/matrix/ell_kernels.cpp
+++ b/reference/test/matrix/ell_kernels.cpp
@@ -618,7 +618,7 @@ TYPED_TEST(Ell, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -631,7 +631,7 @@ TYPED_TEST(Ell, OutplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -664,7 +664,7 @@ TYPED_TEST(EllComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
@@ -684,7 +684,7 @@ TYPED_TEST(EllComplex, OutplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/hybrid_kernels.cpp b/reference/test/matrix/hybrid_kernels.cpp
index 17f0aae4c50..46123df227b 100644
--- a/reference/test/matrix/hybrid_kernels.cpp
+++ b/reference/test/matrix/hybrid_kernels.cpp
@@ -662,7 +662,7 @@ TYPED_TEST(Hybrid, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -675,7 +675,7 @@ TYPED_TEST(Hybrid, OutplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -708,7 +708,7 @@ TYPED_TEST(HybridComplex, OutplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
@@ -728,7 +728,7 @@ TYPED_TEST(HybridComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
diff --git a/reference/test/matrix/sellp_kernels.cpp b/reference/test/matrix/sellp_kernels.cpp
index 7eef159ddeb..5c24e7afe3d 100644
--- a/reference/test/matrix/sellp_kernels.cpp
+++ b/reference/test/matrix/sellp_kernels.cpp
@@ -621,7 +621,7 @@ TYPED_TEST(Sellp, InplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -634,7 +634,7 @@ TYPED_TEST(Sellp, OutplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
@@ -667,7 +667,7 @@ TYPED_TEST(SellpComplex, OutplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    auto abs_mtx = mtx->get_absolute();
+    auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
@@ -687,7 +687,7 @@ TYPED_TEST(SellpComplex, InplaceAbsolute)
          {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
     // clang-format on
 
-    mtx->apply_absolute();
+    mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(
         mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);

From 613bb4c44d5f9c32262c286655f748e1774adfe0 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 11 Sep 2020 12:35:15 +0200
Subject: [PATCH 09/15] refine format

Co-authored-by: fritzgoebel <fritz.goebel@kit.edu>
---
 common/matrix/dense_kernels.hpp.inc          | 2 +-
 core/matrix/csr.cpp                          | 1 +
 core/test/base/lin_op.cpp                    | 9 +++++++--
 include/ginkgo/core/base/lin_op.hpp          | 5 +++--
 omp/test/matrix/diagonal_kernels.cpp         | 1 +
 reference/test/components/absolute_array.cpp | 4 ++--
 6 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/common/matrix/dense_kernels.hpp.inc b/common/matrix/dense_kernels.hpp.inc
index 49be1ba3724..c26203115fe 100644
--- a/common/matrix/dense_kernels.hpp.inc
+++ b/common/matrix/dense_kernels.hpp.inc
@@ -534,7 +534,7 @@ __global__ __launch_bounds__(default_block_size) void outplace_absolute_dense(
     auto row = tidx / num_cols;
     auto col = tidx % num_cols;
     if (row < num_rows) {
-        out[row * stride_out + col] = abs(in[row * stride_out + col]);
+        out[row * stride_out + col] = abs(in[row * stride_in + col]);
     }
 }
 
diff --git a/core/matrix/csr.cpp b/core/matrix/csr.cpp
index 605f7b09fed..eae8599a3bb 100644
--- a/core/matrix/csr.cpp
+++ b/core/matrix/csr.cpp
@@ -87,6 +87,7 @@ GKO_REGISTER_OPERATION(inplace_absolute_array,
 GKO_REGISTER_OPERATION(outplace_absolute_array,
                        components::outplace_absolute_array);
 
+
 }  // namespace csr
 
 
diff --git a/core/test/base/lin_op.cpp b/core/test/base/lin_op.cpp
index 497396efaeb..144cbd33e42 100644
--- a/core/test/base/lin_op.cpp
+++ b/core/test/base/lin_op.cpp
@@ -30,13 +30,18 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************<GINKGO LICENSE>*******************************/
 
-#include <complex>
 #include <ginkgo/core/base/lin_op.hpp>
-#include <ginkgo/core/base/math.hpp>
+
+
+#include <complex>
+
 
 #include <gtest/gtest.h>
 
 
+#include <ginkgo/core/base/math.hpp>
+
+
 namespace {
 
 
diff --git a/include/ginkgo/core/base/lin_op.hpp b/include/ginkgo/core/base/lin_op.hpp
index a72f3685848..5be7dadcded 100644
--- a/include/ginkgo/core/base/lin_op.hpp
+++ b/include/ginkgo/core/base/lin_op.hpp
@@ -625,8 +625,9 @@ class DiagonalExtractable {
 
 
 /**
- * The AbsoluteComputable is an interface to allow get absolute from a LinOp.
- * Use EnableAbsoluteComputation<ConcreteLinOp> to implement this interface.
+ * The AbsoluteComputable is an interface that allows to get the component wise
+ * absolute of a LinOp. Use EnableAbsoluteComputation<ConcreteLinOp> to
+ * implement this interface.
  */
 class AbsoluteComputable {
 public:
diff --git a/omp/test/matrix/diagonal_kernels.cpp b/omp/test/matrix/diagonal_kernels.cpp
index 2d03fb74f8f..e58380ea773 100644
--- a/omp/test/matrix/diagonal_kernels.cpp
+++ b/omp/test/matrix/diagonal_kernels.cpp
@@ -39,6 +39,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <random>
 #include <vector>
 
+
 #include <gtest/gtest.h>
 
 
diff --git a/reference/test/components/absolute_array.cpp b/reference/test/components/absolute_array.cpp
index 1c2f2952551..83cc444df20 100644
--- a/reference/test/components/absolute_array.cpp
+++ b/reference/test/components/absolute_array.cpp
@@ -78,7 +78,7 @@ class AbsoluteArray : public ::testing::Test {
 TYPED_TEST_CASE(AbsoluteArray, gko::test::ValueTypes);
 
 
-TYPED_TEST(AbsoluteArray, InplaceEqualsReference)
+TYPED_TEST(AbsoluteArray, InplaceEqualsExpected)
 {
     using T = typename TestFixture::value_type;
     gko::kernels::reference::components::inplace_absolute_array(
@@ -87,7 +87,7 @@ TYPED_TEST(AbsoluteArray, InplaceEqualsReference)
 }
 
 
-TYPED_TEST(AbsoluteArray, OutplaceEqualsReference)
+TYPED_TEST(AbsoluteArray, OutplaceEqualsExpected)
 {
     using T = typename TestFixture::value_type;
     using AbsT = typename TestFixture::abs_type;

From 69a5c5ae617010ff9d5a9f8343350421f11e18c1 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 15 Sep 2020 15:16:23 +0200
Subject: [PATCH 10/15] rename make_complex, use absolute_type only...etc

1. remove/add_complex
2. to_real/complex alias
3. using absolute_type not outplace_absolute_type
4. remove unneeded .get() in test

Co-authored-by: Tobias Ribizel <ribizel@kit.edu>
---
 core/matrix/coo.cpp                      |  6 +--
 core/matrix/csr.cpp                      |  6 +--
 core/matrix/dense.cpp                    |  4 +-
 core/matrix/diagonal.cpp                 |  5 +--
 core/matrix/ell.cpp                      |  4 +-
 core/matrix/hybrid.cpp                   |  4 +-
 core/matrix/sellp.cpp                    |  4 +-
 core/test/base/lin_op.cpp                |  6 +--
 cuda/test/matrix/coo_kernels.cpp         |  4 +-
 cuda/test/matrix/csr_kernels.cpp         |  8 ++--
 cuda/test/matrix/dense_kernels.cpp       |  4 +-
 cuda/test/matrix/diagonal_kernels.cpp    |  4 +-
 cuda/test/matrix/ell_kernels.cpp         |  4 +-
 cuda/test/matrix/hybrid_kernels.cpp      |  4 +-
 cuda/test/matrix/sellp_kernels.cpp       |  4 +-
 hip/test/matrix/coo_kernels.hip.cpp      |  4 +-
 hip/test/matrix/csr_kernels.hip.cpp      |  8 ++--
 hip/test/matrix/dense_kernels.hip.cpp    |  4 +-
 hip/test/matrix/diagonal_kernels.hip.cpp |  4 +-
 hip/test/matrix/ell_kernels.hip.cpp      |  4 +-
 hip/test/matrix/hybrid_kernels.hip.cpp   |  4 +-
 hip/test/matrix/sellp_kernels.hip.cpp    |  4 +-
 include/ginkgo/core/base/math.hpp        | 52 ++++++++++++++++++++----
 include/ginkgo/core/matrix/coo.hpp       |  6 +--
 include/ginkgo/core/matrix/csr.hpp       | 12 +++---
 include/ginkgo/core/matrix/dense.hpp     |  6 +--
 include/ginkgo/core/matrix/diagonal.hpp  |  6 +--
 include/ginkgo/core/matrix/ell.hpp       |  6 +--
 include/ginkgo/core/matrix/hybrid.hpp    |  6 +--
 include/ginkgo/core/matrix/sellp.hpp     |  6 +--
 omp/test/matrix/coo_kernels.cpp          |  4 +-
 omp/test/matrix/csr_kernels.cpp          |  8 ++--
 omp/test/matrix/dense_kernels.cpp        |  4 +-
 omp/test/matrix/diagonal_kernels.cpp     |  4 +-
 omp/test/matrix/ell_kernels.cpp          |  4 +-
 omp/test/matrix/hybrid_kernels.cpp       |  4 +-
 omp/test/matrix/sellp_kernels.cpp        |  4 +-
 37 files changed, 134 insertions(+), 101 deletions(-)

diff --git a/core/matrix/coo.cpp b/core/matrix/coo.cpp
index 50b42d04ab4..6ab488d9988 100644
--- a/core/matrix/coo.cpp
+++ b/core/matrix/coo.cpp
@@ -249,13 +249,13 @@ void Coo<ValueType, IndexType>::compute_absolute_inplace()
 
 
 template <typename ValueType, typename IndexType>
-std::unique_ptr<typename Coo<ValueType, IndexType>::outplace_absolute_type>
+std::unique_ptr<typename Coo<ValueType, IndexType>::absolute_type>
 Coo<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
-    auto abs_coo = outplace_absolute_type::create(
-        exec, this->get_size(), this->get_num_stored_elements());
+    auto abs_coo = absolute_type::create(exec, this->get_size(),
+                                         this->get_num_stored_elements());
 
     abs_coo->col_idxs_ = col_idxs_;
     abs_coo->row_idxs_ = row_idxs_;
diff --git a/core/matrix/csr.cpp b/core/matrix/csr.cpp
index eae8599a3bb..32431850132 100644
--- a/core/matrix/csr.cpp
+++ b/core/matrix/csr.cpp
@@ -498,13 +498,13 @@ void Csr<ValueType, IndexType>::compute_absolute_inplace()
 
 
 template <typename ValueType, typename IndexType>
-std::unique_ptr<typename Csr<ValueType, IndexType>::outplace_absolute_type>
+std::unique_ptr<typename Csr<ValueType, IndexType>::absolute_type>
 Csr<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
-    auto abs_csr = outplace_absolute_type::create(
-        exec, this->get_size(), this->get_num_stored_elements());
+    auto abs_csr = absolute_type::create(exec, this->get_size(),
+                                         this->get_num_stored_elements());
 
     abs_csr->col_idxs_ = col_idxs_;
     abs_csr->row_ptrs_ = row_ptrs_;
diff --git a/core/matrix/dense.cpp b/core/matrix/dense.cpp
index e51ad7bcff1..aaaaf2d01a5 100644
--- a/core/matrix/dense.cpp
+++ b/core/matrix/dense.cpp
@@ -764,13 +764,13 @@ void Dense<ValueType>::compute_absolute_inplace()
 
 
 template <typename ValueType>
-std::unique_ptr<typename Dense<ValueType>::outplace_absolute_type>
+std::unique_ptr<typename Dense<ValueType>::absolute_type>
 Dense<ValueType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
     // do not inherit the stride
-    auto abs_dense = outplace_absolute_type::create(exec, this->get_size());
+    auto abs_dense = absolute_type::create(exec, this->get_size());
 
     exec->run(dense::make_outplace_absolute_dense(this, abs_dense.get()));
 
diff --git a/core/matrix/diagonal.cpp b/core/matrix/diagonal.cpp
index e1cb767efbf..8df8af6a801 100644
--- a/core/matrix/diagonal.cpp
+++ b/core/matrix/diagonal.cpp
@@ -277,13 +277,12 @@ void Diagonal<ValueType>::compute_absolute_inplace()
 
 
 template <typename ValueType>
-std::unique_ptr<typename Diagonal<ValueType>::outplace_absolute_type>
+std::unique_ptr<typename Diagonal<ValueType>::absolute_type>
 Diagonal<ValueType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
-    auto abs_diagonal =
-        outplace_absolute_type::create(exec, this->get_size()[0]);
+    auto abs_diagonal = absolute_type::create(exec, this->get_size()[0]);
 
     exec->run(diagonal::make_outplace_absolute_array(
         this->get_const_values(), this->get_size()[0],
diff --git a/core/matrix/ell.cpp b/core/matrix/ell.cpp
index 26f518d2cbc..c802fe917e5 100644
--- a/core/matrix/ell.cpp
+++ b/core/matrix/ell.cpp
@@ -267,12 +267,12 @@ void Ell<ValueType, IndexType>::compute_absolute_inplace()
 
 
 template <typename ValueType, typename IndexType>
-std::unique_ptr<typename Ell<ValueType, IndexType>::outplace_absolute_type>
+std::unique_ptr<typename Ell<ValueType, IndexType>::absolute_type>
 Ell<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
-    auto abs_ell = outplace_absolute_type::create(
+    auto abs_ell = absolute_type::create(
         exec, this->get_size(), this->get_num_stored_elements_per_row(),
         this->get_stride());
 
diff --git a/core/matrix/hybrid.cpp b/core/matrix/hybrid.cpp
index 9487bd99a4e..b4e83f3906e 100644
--- a/core/matrix/hybrid.cpp
+++ b/core/matrix/hybrid.cpp
@@ -303,13 +303,13 @@ void Hybrid<ValueType, IndexType>::compute_absolute_inplace()
 
 
 template <typename ValueType, typename IndexType>
-std::unique_ptr<typename Hybrid<ValueType, IndexType>::outplace_absolute_type>
+std::unique_ptr<typename Hybrid<ValueType, IndexType>::absolute_type>
 Hybrid<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
     // use default strategy
-    auto abs_hybrid = outplace_absolute_type::create(exec, this->get_size());
+    auto abs_hybrid = absolute_type::create(exec, this->get_size());
 
     abs_hybrid->ell_->copy_from(ell_->compute_absolute());
     abs_hybrid->coo_->copy_from(coo_->compute_absolute());
diff --git a/core/matrix/sellp.cpp b/core/matrix/sellp.cpp
index 81af57b5dd6..94c30544832 100644
--- a/core/matrix/sellp.cpp
+++ b/core/matrix/sellp.cpp
@@ -320,12 +320,12 @@ void Sellp<ValueType, IndexType>::compute_absolute_inplace()
 
 
 template <typename ValueType, typename IndexType>
-std::unique_ptr<typename Sellp<ValueType, IndexType>::outplace_absolute_type>
+std::unique_ptr<typename Sellp<ValueType, IndexType>::absolute_type>
 Sellp<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
-    auto abs_sellp = outplace_absolute_type::create(
+    auto abs_sellp = absolute_type::create(
         exec, this->get_size(), this->get_slice_size(),
         this->get_stride_factor(), this->get_total_cols());
 
diff --git a/core/test/base/lin_op.cpp b/core/test/base/lin_op.cpp
index 144cbd33e42..7ba5c794945 100644
--- a/core/test/base/lin_op.cpp
+++ b/core/test/base/lin_op.cpp
@@ -326,7 +326,7 @@ class DummyLinOpWithType
       public gko::EnableCreateMethod<DummyLinOpWithType<Type>>,
       public gko::EnableAbsoluteComputation<DummyLinOpWithType<Type>> {
 public:
-    using outplace_absolute_type = gko::remove_complex<DummyLinOpWithType>;
+    using absolute_type = gko::remove_complex<DummyLinOpWithType>;
     DummyLinOpWithType(std::shared_ptr<const gko::Executor> exec)
         : gko::EnableLinOp<DummyLinOpWithType>(exec)
     {}
@@ -338,9 +338,9 @@ class DummyLinOpWithType
 
     void compute_absolute_inplace() override { value_ = gko::abs(value_); }
 
-    std::unique_ptr<outplace_absolute_type> compute_absolute() const override
+    std::unique_ptr<absolute_type> compute_absolute() const override
     {
-        return std::make_unique<outplace_absolute_type>(
+        return std::make_unique<absolute_type>(
             this->get_executor(), this->get_size(), gko::abs(value_));
     }
 
diff --git a/cuda/test/matrix/coo_kernels.cpp b/cuda/test/matrix/coo_kernels.cpp
index cc52e895097..6815a9d3df1 100644
--- a/cuda/test/matrix/coo_kernels.cpp
+++ b/cuda/test/matrix/coo_kernels.cpp
@@ -278,7 +278,7 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -289,7 +289,7 @@ TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/cuda/test/matrix/csr_kernels.cpp b/cuda/test/matrix/csr_kernels.cpp
index f8a171719a1..4205f5c5d97 100644
--- a/cuda/test/matrix/csr_kernels.cpp
+++ b/cuda/test/matrix/csr_kernels.cpp
@@ -747,7 +747,7 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -758,7 +758,7 @@ TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
@@ -769,7 +769,7 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
     complex_mtx->compute_absolute_inplace();
     complex_dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(complex_mtx, complex_dmtx, 1e-14);
 }
 
 
@@ -780,7 +780,7 @@ TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
     auto abs_mtx = complex_mtx->compute_absolute();
     auto dabs_mtx = complex_dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/cuda/test/matrix/dense_kernels.cpp b/cuda/test/matrix/dense_kernels.cpp
index 38273b107e1..e8732c13136 100644
--- a/cuda/test/matrix/dense_kernels.cpp
+++ b/cuda/test/matrix/dense_kernels.cpp
@@ -594,7 +594,7 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
     x->compute_absolute_inplace();
     dx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(x, dx, 1e-14);
 }
 
 
@@ -605,7 +605,7 @@ TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_x = x->compute_absolute();
     auto dabs_x = dx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_x, dabs_x, 1e-14);
 }
 
 
diff --git a/cuda/test/matrix/diagonal_kernels.cpp b/cuda/test/matrix/diagonal_kernels.cpp
index a3471be6929..695eee1a880 100644
--- a/cuda/test/matrix/diagonal_kernels.cpp
+++ b/cuda/test/matrix/diagonal_kernels.cpp
@@ -256,7 +256,7 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
     diag->compute_absolute_inplace();
     ddiag->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(diag, ddiag, 1e-14);
 }
 
 
@@ -267,7 +267,7 @@ TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_diag = diag->compute_absolute();
     auto dabs_diag = ddiag->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_diag, dabs_diag, 1e-14);
 }
 
 
diff --git a/cuda/test/matrix/ell_kernels.cpp b/cuda/test/matrix/ell_kernels.cpp
index 86a2ed1d099..ce48a80e634 100644
--- a/cuda/test/matrix/ell_kernels.cpp
+++ b/cuda/test/matrix/ell_kernels.cpp
@@ -363,7 +363,7 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -374,7 +374,7 @@ TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/cuda/test/matrix/hybrid_kernels.cpp b/cuda/test/matrix/hybrid_kernels.cpp
index eb8b5ba7669..7bcc7ad47b3 100644
--- a/cuda/test/matrix/hybrid_kernels.cpp
+++ b/cuda/test/matrix/hybrid_kernels.cpp
@@ -238,7 +238,7 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -249,7 +249,7 @@ TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/cuda/test/matrix/sellp_kernels.cpp b/cuda/test/matrix/sellp_kernels.cpp
index 91f063de36a..7a00b63d0c1 100644
--- a/cuda/test/matrix/sellp_kernels.cpp
+++ b/cuda/test/matrix/sellp_kernels.cpp
@@ -357,7 +357,7 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -368,7 +368,7 @@ TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/hip/test/matrix/coo_kernels.hip.cpp b/hip/test/matrix/coo_kernels.hip.cpp
index b235da23077..6d0a0935cd6 100644
--- a/hip/test/matrix/coo_kernels.hip.cpp
+++ b/hip/test/matrix/coo_kernels.hip.cpp
@@ -278,7 +278,7 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -289,7 +289,7 @@ TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/hip/test/matrix/csr_kernels.hip.cpp b/hip/test/matrix/csr_kernels.hip.cpp
index 2a2a8260cbf..54b0f4cda65 100644
--- a/hip/test/matrix/csr_kernels.hip.cpp
+++ b/hip/test/matrix/csr_kernels.hip.cpp
@@ -732,7 +732,7 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -743,7 +743,7 @@ TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
@@ -754,7 +754,7 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
     complex_mtx->compute_absolute_inplace();
     complex_dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(complex_mtx, complex_dmtx, 1e-14);
 }
 
 
@@ -765,7 +765,7 @@ TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
     auto abs_mtx = complex_mtx->compute_absolute();
     auto dabs_mtx = complex_dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/hip/test/matrix/dense_kernels.hip.cpp b/hip/test/matrix/dense_kernels.hip.cpp
index a1dd4f34ec8..c14809ed79e 100644
--- a/hip/test/matrix/dense_kernels.hip.cpp
+++ b/hip/test/matrix/dense_kernels.hip.cpp
@@ -576,7 +576,7 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
     x->compute_absolute_inplace();
     dx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(x, dx, 1e-14);
 }
 
 
@@ -587,7 +587,7 @@ TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_x = x->compute_absolute();
     auto dabs_x = dx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_x, dabs_x, 1e-14);
 }
 
 
diff --git a/hip/test/matrix/diagonal_kernels.hip.cpp b/hip/test/matrix/diagonal_kernels.hip.cpp
index d86e878dd66..1bd1b3f0b8a 100644
--- a/hip/test/matrix/diagonal_kernels.hip.cpp
+++ b/hip/test/matrix/diagonal_kernels.hip.cpp
@@ -256,7 +256,7 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
     diag->compute_absolute_inplace();
     ddiag->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(diag, ddiag, 1e-14);
 }
 
 
@@ -267,7 +267,7 @@ TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_diag = diag->compute_absolute();
     auto dabs_diag = ddiag->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_diag, dabs_diag, 1e-14);
 }
 
 
diff --git a/hip/test/matrix/ell_kernels.hip.cpp b/hip/test/matrix/ell_kernels.hip.cpp
index 4ae03c3d00e..74d22dbb738 100644
--- a/hip/test/matrix/ell_kernels.hip.cpp
+++ b/hip/test/matrix/ell_kernels.hip.cpp
@@ -363,7 +363,7 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -374,7 +374,7 @@ TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/hip/test/matrix/hybrid_kernels.hip.cpp b/hip/test/matrix/hybrid_kernels.hip.cpp
index dd79f63c0f8..5aa3b2d0258 100644
--- a/hip/test/matrix/hybrid_kernels.hip.cpp
+++ b/hip/test/matrix/hybrid_kernels.hip.cpp
@@ -238,7 +238,7 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -249,7 +249,7 @@ TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/hip/test/matrix/sellp_kernels.hip.cpp b/hip/test/matrix/sellp_kernels.hip.cpp
index 8b39aedb189..6c99519b71d 100644
--- a/hip/test/matrix/sellp_kernels.hip.cpp
+++ b/hip/test/matrix/sellp_kernels.hip.cpp
@@ -356,7 +356,7 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -367,7 +367,7 @@ TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/include/ginkgo/core/base/math.hpp b/include/ginkgo/core/base/math.hpp
index 85abf81a08e..dc222110fb4 100644
--- a/include/ginkgo/core/base/math.hpp
+++ b/include/ginkgo/core/base/math.hpp
@@ -139,7 +139,7 @@ struct remove_complex_impl<std::complex<T>> {
  * @tparam T  the type being made complex
  */
 template <typename T>
-struct make_complex_impl {
+struct add_complex_impl {
     using type = std::complex<T>;
 };
 
@@ -149,7 +149,7 @@ struct make_complex_impl {
  * @tparam T  the type being made complex
  */
 template <typename T>
-struct make_complex_impl<std::complex<T>> {
+struct add_complex_impl<std::complex<T>> {
     using type = std::complex<T>;
 };
 
@@ -222,16 +222,16 @@ struct remove_complex_s<
 
 
 template <typename T, typename = void>
-struct make_complex_s {};
+struct add_complex_s {};
 
 /**
  * Obtains a complex counterpart of a real type, and leaves the type
  * unchanged if it is a complex type for complex/scalar type.
  */
 template <typename T>
-struct make_complex_s<
+struct add_complex_s<
     T, xstd::void_t<std::enable_if_t<is_complex_or_scalar_impl<T>::value>>> {
-    using type = typename detail::make_complex_impl<T>::type;
+    using type = typename detail::add_complex_impl<T>::type;
 };
 
 /**
@@ -239,10 +239,10 @@ struct make_complex_s<
  * converts real parameters to complex parameters.
  */
 template <typename T>
-struct make_complex_s<
+struct add_complex_s<
     T, xstd::void_t<std::enable_if_t<!is_complex_or_scalar_impl<T>::value>>> {
     using type =
-        typename detail::template_convertor<detail::make_complex_impl, T>::type;
+        typename detail::template_convertor<detail::add_complex_impl, T>::type;
 };
 
 
@@ -345,7 +345,7 @@ using remove_complex = typename remove_complex_s<T>::type;
  *
  * @tparam T  type to remove complex
  */
-using detail::make_complex_s;
+using detail::add_complex_s;
 
 /**
  * Obtain the type which removed the complex of complex/scalar type or the
@@ -354,7 +354,41 @@ using detail::make_complex_s;
  * @tparam T  type to remove complex
  */
 template <typename T>
-using make_complex = typename make_complex_s<T>::type;
+using add_complex = typename add_complex_s<T>::type;
+
+
+/**
+ * to_real_s is alias of remove_complex_s
+ *
+ * @tparam T  type to real
+ */
+template <typename T>
+using to_real_s = remove_complex_s<T>;
+
+/**
+ * to_real is alias of remove_complex
+ *
+ * @tparam T  type to real
+ */
+template <typename T>
+using to_real = remove_complex<T>;
+
+
+/**
+ * to_complex_s is alias of add_complex_s
+ *
+ * @tparam T  type to complex
+ */
+template <typename T>
+using to_complex_s = add_complex_s<T>;
+
+/**
+ * to_complex is alias of add_complex
+ *
+ * @tparam T  type to complex
+ */
+template <typename T>
+using to_complex = add_complex<T>;
 
 
 namespace detail {
diff --git a/include/ginkgo/core/matrix/coo.hpp b/include/ginkgo/core/matrix/coo.hpp
index 45b1c257c96..6a9b972e7ef 100644
--- a/include/ginkgo/core/matrix/coo.hpp
+++ b/include/ginkgo/core/matrix/coo.hpp
@@ -88,7 +88,7 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
     friend class Csr<ValueType, IndexType>;
     friend class Dense<ValueType>;
     friend class CooBuilder<ValueType, IndexType>;
-    friend class Coo<make_complex<ValueType>, IndexType>;
+    friend class Coo<add_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Coo>::convert_to;
@@ -97,7 +97,7 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
-    using outplace_absolute_type =
+    using absolute_type =
         typename EnableAbsoluteComputation<Coo>::outplace_type;
 
     friend class Coo<next_precision<ValueType>, IndexType>;
@@ -121,7 +121,7 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
+    std::unique_ptr<absolute_type> compute_absolute() const override;
 
     void compute_absolute_inplace() override;
 
diff --git a/include/ginkgo/core/matrix/csr.hpp b/include/ginkgo/core/matrix/csr.hpp
index bc41f528e23..b71b194e6f3 100644
--- a/include/ginkgo/core/matrix/csr.hpp
+++ b/include/ginkgo/core/matrix/csr.hpp
@@ -141,12 +141,12 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
     friend class Sellp<ValueType, IndexType>;
     friend class SparsityCsr<ValueType, IndexType>;
     friend class CsrBuilder<ValueType, IndexType>;
-    friend class Csr<make_complex<ValueType>, IndexType>;
-    // friend make_complex<Csr>;
+    friend class Csr<add_complex<ValueType>, IndexType>;
+    // friend add_complex<Csr>;
     //   error: can not recognize it is class correctly.
-    // friend class make_complex<Csr>;
+    // friend class add_complex<Csr>;
     //   error: using alias template specialization
-    // friend class make_complex_s<Csr<ValueType,IndexType>>::type;
+    // friend class add_complex_s<Csr<ValueType,IndexType>>::type;
     //   error: can not recognize it is class correctly.
 
 public:
@@ -154,7 +154,7 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
     using index_type = IndexType;
     using transposed_type = Csr<ValueType, IndexType>;
     using mat_data = matrix_data<ValueType, IndexType>;
-    using outplace_absolute_type =
+    using absolute_type =
         typename EnableAbsoluteComputation<Csr>::outplace_type;
 
     class automatical;
@@ -712,7 +712,7 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
+    std::unique_ptr<absolute_type> compute_absolute() const override;
 
     void compute_absolute_inplace() override;
 
diff --git a/include/ginkgo/core/matrix/dense.hpp b/include/ginkgo/core/matrix/dense.hpp
index 6f7c2b16c99..b0b1aa9712c 100644
--- a/include/ginkgo/core/matrix/dense.hpp
+++ b/include/ginkgo/core/matrix/dense.hpp
@@ -127,7 +127,7 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
     friend class Sellp<ValueType, int64>;
     friend class SparsityCsr<ValueType, int32>;
     friend class SparsityCsr<ValueType, int64>;
-    friend class Dense<make_complex<ValueType>>;
+    friend class Dense<add_complex<ValueType>>;
 
 public:
     using EnableLinOp<Dense>::convert_to;
@@ -138,7 +138,7 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
     using transposed_type = Dense<ValueType>;
     using mat_data = gko::matrix_data<ValueType, int64>;
     using mat_data32 = gko::matrix_data<ValueType, int32>;
-    using outplace_absolute_type =
+    using absolute_type =
         typename EnableAbsoluteComputation<Dense>::outplace_type;
 
     using row_major_range = gko::range<gko::accessor::row_major<ValueType, 2>>;
@@ -249,7 +249,7 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
+    std::unique_ptr<absolute_type> compute_absolute() const override;
 
     void compute_absolute_inplace() override;
 
diff --git a/include/ginkgo/core/matrix/diagonal.hpp b/include/ginkgo/core/matrix/diagonal.hpp
index aec604de9cc..f9e42fb769f 100644
--- a/include/ginkgo/core/matrix/diagonal.hpp
+++ b/include/ginkgo/core/matrix/diagonal.hpp
@@ -78,7 +78,7 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
     friend class EnableCreateMethod<Diagonal>;
     friend class Csr<ValueType, int32>;
     friend class Csr<ValueType, int64>;
-    friend class Diagonal<make_complex<ValueType>>;
+    friend class Diagonal<add_complex<ValueType>>;
 
 public:
     using EnableLinOp<Diagonal>::convert_to;
@@ -88,7 +88,7 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
     using index_type = int64;
     using mat_data = gko::matrix_data<ValueType, int64>;
     using mat_data32 = gko::matrix_data<ValueType, int32>;
-    using outplace_absolute_type =
+    using absolute_type =
         typename EnableAbsoluteComputation<Diagonal>::outplace_type;
 
     std::unique_ptr<LinOp> transpose() const override;
@@ -103,7 +103,7 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
 
     void move_to(Csr<ValueType, int64> *result) override;
 
-    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
+    std::unique_ptr<absolute_type> compute_absolute() const override;
 
     void compute_absolute_inplace() override;
 
diff --git a/include/ginkgo/core/matrix/ell.hpp b/include/ginkgo/core/matrix/ell.hpp
index 6fa705f4ab9..5fdfeb23770 100644
--- a/include/ginkgo/core/matrix/ell.hpp
+++ b/include/ginkgo/core/matrix/ell.hpp
@@ -81,7 +81,7 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
     friend class EnablePolymorphicObject<Ell, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
-    friend class Ell<make_complex<ValueType>, IndexType>;
+    friend class Ell<add_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Ell>::convert_to;
@@ -90,7 +90,7 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
-    using outplace_absolute_type =
+    using absolute_type =
         typename EnableAbsoluteComputation<Ell>::outplace_type;
 
     friend class Ell<next_precision<ValueType>, IndexType>;
@@ -114,7 +114,7 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
+    std::unique_ptr<absolute_type> compute_absolute() const override;
 
     void compute_absolute_inplace() override;
 
diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index 8b19de70766..453be83cdea 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -82,7 +82,7 @@ class Hybrid
     friend class EnablePolymorphicObject<Hybrid, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
-    friend class Hybrid<make_complex<ValueType>, IndexType>;
+    friend class Hybrid<add_complex<ValueType>, IndexType>;
 
 
 public:
@@ -94,7 +94,7 @@ class Hybrid
     using mat_data = matrix_data<ValueType, IndexType>;
     using coo_type = Coo<ValueType, IndexType>;
     using ell_type = Ell<ValueType, IndexType>;
-    using outplace_absolute_type =
+    using absolute_type =
         typename EnableAbsoluteComputation<Hybrid>::outplace_type;
 
 
@@ -363,7 +363,7 @@ class Hybrid
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
+    std::unique_ptr<absolute_type> compute_absolute() const override;
 
     void compute_absolute_inplace() override;
 
diff --git a/include/ginkgo/core/matrix/sellp.hpp b/include/ginkgo/core/matrix/sellp.hpp
index fb5acd36526..cbf06478bc6 100644
--- a/include/ginkgo/core/matrix/sellp.hpp
+++ b/include/ginkgo/core/matrix/sellp.hpp
@@ -78,7 +78,7 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
     friend class EnablePolymorphicObject<Sellp, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
-    friend class Sellp<make_complex<ValueType>, IndexType>;
+    friend class Sellp<add_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Sellp>::convert_to;
@@ -87,7 +87,7 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
-    using outplace_absolute_type =
+    using absolute_type =
         typename EnableAbsoluteComputation<Sellp>::outplace_type;
 
     friend class Sellp<next_precision<ValueType>, IndexType>;
@@ -111,7 +111,7 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
 
     std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;
 
-    std::unique_ptr<outplace_absolute_type> compute_absolute() const override;
+    std::unique_ptr<absolute_type> compute_absolute() const override;
 
     void compute_absolute_inplace() override;
 
diff --git a/omp/test/matrix/coo_kernels.cpp b/omp/test/matrix/coo_kernels.cpp
index b2af927543a..5139e1c1334 100644
--- a/omp/test/matrix/coo_kernels.cpp
+++ b/omp/test/matrix/coo_kernels.cpp
@@ -241,7 +241,7 @@ TEST_F(Coo, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -252,7 +252,7 @@ TEST_F(Coo, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/omp/test/matrix/csr_kernels.cpp b/omp/test/matrix/csr_kernels.cpp
index 25cb647d98d..b9da8e7e81e 100644
--- a/omp/test/matrix/csr_kernels.cpp
+++ b/omp/test/matrix/csr_kernels.cpp
@@ -556,7 +556,7 @@ TEST_F(Csr, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -567,7 +567,7 @@ TEST_F(Csr, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
@@ -578,7 +578,7 @@ TEST_F(Csr, InplaceAbsoluteComplexMatrixIsEquivalentToRef)
     complex_mtx->compute_absolute_inplace();
     complex_dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(complex_mtx.get(), complex_dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(complex_mtx, complex_dmtx, 1e-14);
 }
 
 
@@ -589,7 +589,7 @@ TEST_F(Csr, OutplaceAbsoluteComplexMatrixIsEquivalentToRef)
     auto abs_mtx = complex_mtx->compute_absolute();
     auto dabs_mtx = complex_dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/omp/test/matrix/dense_kernels.cpp b/omp/test/matrix/dense_kernels.cpp
index 77781b71aab..b9af3ec1027 100644
--- a/omp/test/matrix/dense_kernels.cpp
+++ b/omp/test/matrix/dense_kernels.cpp
@@ -709,7 +709,7 @@ TEST_F(Dense, InplaceAbsoluteMatrixIsEquivalentToRef)
     x->compute_absolute_inplace();
     dx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(x.get(), dx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(x, dx, 1e-14);
 }
 
 
@@ -720,7 +720,7 @@ TEST_F(Dense, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_x = x->compute_absolute();
     auto dabs_x = dx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_x.get(), dabs_x.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_x, dabs_x, 1e-14);
 }
 
 
diff --git a/omp/test/matrix/diagonal_kernels.cpp b/omp/test/matrix/diagonal_kernels.cpp
index e58380ea773..02ddd354241 100644
--- a/omp/test/matrix/diagonal_kernels.cpp
+++ b/omp/test/matrix/diagonal_kernels.cpp
@@ -256,7 +256,7 @@ TEST_F(Diagonal, InplaceAbsoluteMatrixIsEquivalentToRef)
     diag->compute_absolute_inplace();
     ddiag->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(diag.get(), ddiag.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(diag, ddiag, 1e-14);
 }
 
 
@@ -267,7 +267,7 @@ TEST_F(Diagonal, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_diag = diag->compute_absolute();
     auto dabs_diag = ddiag->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_diag.get(), dabs_diag.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_diag, dabs_diag, 1e-14);
 }
 
 
diff --git a/omp/test/matrix/ell_kernels.cpp b/omp/test/matrix/ell_kernels.cpp
index 06195abe138..768cb87822e 100644
--- a/omp/test/matrix/ell_kernels.cpp
+++ b/omp/test/matrix/ell_kernels.cpp
@@ -239,7 +239,7 @@ TEST_F(Ell, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -250,7 +250,7 @@ TEST_F(Ell, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/omp/test/matrix/hybrid_kernels.cpp b/omp/test/matrix/hybrid_kernels.cpp
index df85f18455f..a57458b344e 100644
--- a/omp/test/matrix/hybrid_kernels.cpp
+++ b/omp/test/matrix/hybrid_kernels.cpp
@@ -237,7 +237,7 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -248,7 +248,7 @@ TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 
diff --git a/omp/test/matrix/sellp_kernels.cpp b/omp/test/matrix/sellp_kernels.cpp
index 69780f6071e..e776d9c88c1 100644
--- a/omp/test/matrix/sellp_kernels.cpp
+++ b/omp/test/matrix/sellp_kernels.cpp
@@ -273,7 +273,7 @@ TEST_F(Sellp, InplaceAbsoluteMatrixIsEquivalentToRef)
     mtx->compute_absolute_inplace();
     dmtx->compute_absolute_inplace();
 
-    GKO_ASSERT_MTX_NEAR(mtx.get(), dmtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(mtx, dmtx, 1e-14);
 }
 
 
@@ -284,7 +284,7 @@ TEST_F(Sellp, OutplaceAbsoluteMatrixIsEquivalentToRef)
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
 
-    GKO_ASSERT_MTX_NEAR(abs_mtx.get(), dabs_mtx.get(), 1e-14);
+    GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
 }
 
 

From 1ee622271d100ed949d56d9a078e5aa561e73ba9 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 16 Sep 2020 18:33:30 +0200
Subject: [PATCH 11/15] update document, add hybrid get_strategy<Hyb>, test

Co-authored-by: Terry Cojean <terry.cojean@kit.edu>
---
 core/matrix/hybrid.cpp                   |   4 +-
 core/test/base/lin_op.cpp                |   1 +
 core/test/matrix/hybrid.cpp              | 113 +++++++++++++++++++++++
 cuda/test/matrix/hybrid_kernels.cpp      |   9 +-
 hip/test/matrix/hybrid_kernels.hip.cpp   |   9 +-
 include/ginkgo/core/base/math.hpp        |  27 +++++-
 include/ginkgo/core/matrix/csr.hpp       |   6 --
 include/ginkgo/core/matrix/hybrid.hpp    |  79 ++++++++++++++++
 omp/test/matrix/hybrid_kernels.cpp       |   9 +-
 reference/test/matrix/hybrid_kernels.cpp |  13 ++-
 10 files changed, 253 insertions(+), 17 deletions(-)

diff --git a/core/matrix/hybrid.cpp b/core/matrix/hybrid.cpp
index b4e83f3906e..92768a09f89 100644
--- a/core/matrix/hybrid.cpp
+++ b/core/matrix/hybrid.cpp
@@ -308,8 +308,8 @@ Hybrid<ValueType, IndexType>::compute_absolute() const
 {
     auto exec = this->get_executor();
 
-    // use default strategy
-    auto abs_hybrid = absolute_type::create(exec, this->get_size());
+    auto abs_hybrid = absolute_type::create(
+        exec, this->get_size(), this->get_strategy<absolute_type>());
 
     abs_hybrid->ell_->copy_from(ell_->compute_absolute());
     abs_hybrid->coo_->copy_from(coo_->compute_absolute());
diff --git a/core/test/base/lin_op.cpp b/core/test/base/lin_op.cpp
index 7ba5c794945..8cb0c8855eb 100644
--- a/core/test/base/lin_op.cpp
+++ b/core/test/base/lin_op.cpp
@@ -34,6 +34,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include <complex>
+#include <memory>
 
 
 #include <gtest/gtest.h>
diff --git a/core/test/matrix/hybrid.cpp b/core/test/matrix/hybrid.cpp
index dac9da86167..9045e950a23 100644
--- a/core/test/matrix/hybrid.cpp
+++ b/core/test/matrix/hybrid.cpp
@@ -42,6 +42,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace {
 
 
+template <typename T>
+struct change_index_s {
+    using type = gko::int32;
+};
+
+template <>
+struct change_index_s<gko::int32> {
+    using type = gko::int64;
+};
+
+
+template <typename T>
+using change_index = typename change_index_s<T>::type;
+
+
 template <typename ValueIndexType>
 class Hybrid : public ::testing::Test {
 protected:
@@ -297,4 +312,102 @@ TYPED_TEST(Hybrid, GeneratesCorrectMatrixData)
 }
 
 
+TYPED_TEST(Hybrid, GetCorrectColumnLimit)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using Mtx2 = gko::remove_complex<Mtx>;
+    using strategy = typename Mtx::column_limit;
+    using strategy2 = typename Mtx2::column_limit;
+
+    auto mtx = Mtx::create(this->exec, std::make_shared<strategy>(2));
+    auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
+    auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
+
+    EXPECT_EQ(mtx_stra->get_num_columns(), 2);
+    EXPECT_EQ(mtx2_stra->get_num_columns(), 2);
+}
+
+
+TYPED_TEST(Hybrid, GetCorrectImbalanceLimit)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using Mtx2 = gko::remove_complex<Mtx>;
+    using strategy = typename Mtx::imbalance_limit;
+    using strategy2 = typename Mtx2::imbalance_limit;
+
+    auto mtx = Mtx::create(this->exec, std::make_shared<strategy>(0.4));
+    auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
+    auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
+
+    EXPECT_EQ(mtx_stra->get_percent(), 0.4f);
+    EXPECT_EQ(mtx2_stra->get_percent(), 0.4f);
+}
+
+
+TYPED_TEST(Hybrid, GetCorrectImbalanceBoundedLimit)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using Mtx2 = gko::remove_complex<Mtx>;
+    using strategy = typename Mtx::imbalance_bounded_limit;
+    using strategy2 = typename Mtx2::imbalance_bounded_limit;
+
+    auto mtx = Mtx::create(this->exec, std::make_shared<strategy>(0.4, 0.1));
+    auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
+    auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
+
+    EXPECT_EQ(mtx_stra->get_percent(), 0.4f);
+    EXPECT_EQ(mtx_stra->get_ratio(), 0.1f);
+    EXPECT_EQ(mtx2_stra->get_percent(), 0.4f);
+    EXPECT_EQ(mtx2_stra->get_ratio(), 0.1f);
+}
+
+
+TYPED_TEST(Hybrid, GetCorrectMinimalStorageLimitWithDifferentHybType)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using value_type = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    using Mtx2 = gko::matrix::Hybrid<value_type, change_index<index_type>>;
+    using strategy = typename Mtx::minimal_storage_limit;
+    using strategy2 = typename Mtx2::imbalance_limit;
+
+    auto mtx = Mtx::create(this->exec, std::make_shared<strategy>());
+    auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
+    auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
+
+    EXPECT_EQ(mtx2_stra->get_percent(), mtx_stra->get_percent());
+}
+
+
+TYPED_TEST(Hybrid, GetCorrectMinimalStorageLimitWithSameHybType)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using Mtx2 = Mtx;
+    using strategy = typename Mtx::minimal_storage_limit;
+    using strategy2 = typename Mtx2::minimal_storage_limit;
+
+    auto mtx = Mtx::create(this->exec, std::make_shared<strategy>());
+    auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
+    auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
+
+    EXPECT_EQ(mtx2_stra->get_percent(), mtx_stra->get_percent());
+}
+
+
+TYPED_TEST(Hybrid, GetCorrectAutomatic)
+{
+    using Mtx = typename TestFixture::Mtx;
+    using value_type = typename TestFixture::value_type;
+    using index_type = typename TestFixture::index_type;
+    using Mtx2 = Mtx;
+    using strategy = typename Mtx::automatic;
+    using strategy2 = typename Mtx2::automatic;
+
+    auto mtx = Mtx::create(this->exec, std::make_shared<strategy>());
+    auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
+
+    ASSERT_NO_THROW(gko::as<strategy2>(mtx->template get_strategy<Mtx2>()));
+}
+
+
 }  // namespace
diff --git a/cuda/test/matrix/hybrid_kernels.cpp b/cuda/test/matrix/hybrid_kernels.cpp
index 7bcc7ad47b3..366686f27a0 100644
--- a/cuda/test/matrix/hybrid_kernels.cpp
+++ b/cuda/test/matrix/hybrid_kernels.cpp
@@ -244,12 +244,19 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 
 TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
-    set_up_apply_data();
+    set_up_apply_data(1, std::make_shared<Mtx::column_limit>(2));
+    using AbsMtx = gko::remove_complex<Mtx>;
 
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
+    auto abs_strategy = gko::as<AbsMtx::column_limit>(abs_mtx->get_strategy());
+    auto dabs_strategy =
+        gko::as<AbsMtx::column_limit>(dabs_mtx->get_strategy());
 
     GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
+    GKO_ASSERT_EQ(abs_strategy->get_num_columns(),
+                  dabs_strategy->get_num_columns());
+    GKO_ASSERT_EQ(abs_strategy->get_num_columns(), 2);
 }
 
 
diff --git a/hip/test/matrix/hybrid_kernels.hip.cpp b/hip/test/matrix/hybrid_kernels.hip.cpp
index 5aa3b2d0258..f7c60b59b3f 100644
--- a/hip/test/matrix/hybrid_kernels.hip.cpp
+++ b/hip/test/matrix/hybrid_kernels.hip.cpp
@@ -244,12 +244,19 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 
 TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
-    set_up_apply_data();
+    set_up_apply_data(1, std::make_shared<Mtx::column_limit>(2));
+    using AbsMtx = gko::remove_complex<Mtx>;
 
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
+    auto abs_strategy = gko::as<AbsMtx::column_limit>(abs_mtx->get_strategy());
+    auto dabs_strategy =
+        gko::as<AbsMtx::column_limit>(dabs_mtx->get_strategy());
 
     GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
+    GKO_ASSERT_EQ(abs_strategy->get_num_columns(),
+                  dabs_strategy->get_num_columns());
+    GKO_ASSERT_EQ(abs_strategy->get_num_columns(), 2);
 }
 
 
diff --git a/include/ginkgo/core/base/math.hpp b/include/ginkgo/core/base/math.hpp
index dc222110fb4..467d8668bd3 100644
--- a/include/ginkgo/core/base/math.hpp
+++ b/include/ginkgo/core/base/math.hpp
@@ -201,6 +201,8 @@ struct remove_complex_s {};
 /**
  * Obtains a real counterpart of a std::complex type, and leaves the type
  * unchanged if it is not a complex type for complex/scalar type.
+ *
+ * @tparam T  complex or scalar type
  */
 template <typename T>
 struct remove_complex_s<
@@ -211,6 +213,8 @@ struct remove_complex_s<
 /**
  * Obtains a real counterpart of a class with template parameters, which
  * converts complex parameters to real parameters.
+ *
+ * @tparam T  class with template parameters
  */
 template <typename T>
 struct remove_complex_s<
@@ -227,6 +231,8 @@ struct add_complex_s {};
 /**
  * Obtains a complex counterpart of a real type, and leaves the type
  * unchanged if it is a complex type for complex/scalar type.
+ *
+ * @tparam T  complex or scalar type
  */
 template <typename T>
 struct add_complex_s<
@@ -237,6 +243,8 @@ struct add_complex_s<
 /**
  * Obtains a complex counterpart of a class with template parameters, which
  * converts real parameters to complex parameters.
+ *
+ * @tparam T  class with template parameters
  */
 template <typename T>
 struct add_complex_s<
@@ -334,24 +342,35 @@ using detail::remove_complex_s;
  * template parameter of class by accessing the `type` attribute of this struct.
  *
  * @tparam T  type to remove complex
+ *
+ * @note remove_complex<class> can not be used in friend class declaration.
  */
 template <typename T>
 using remove_complex = typename remove_complex_s<T>::type;
 
 
 /**
- * Removes the complex of complex/scalar type or the template parameter of class
+ * Add the complex of complex/scalar type or the template parameter of class
  * by accessing the `type` attribute of this struct.
  *
- * @tparam T  type to remove complex
+ * @tparam T  type to add complex
  */
 using detail::add_complex_s;
 
 /**
- * Obtain the type which removed the complex of complex/scalar type or the
+ * Obtain the type which adds the complex of complex/scalar type or the
  * template parameter of class by accessing the `type` attribute of this struct.
  *
- * @tparam T  type to remove complex
+ * @tparam T  type to add complex
+ *
+ * @note add_complex<class> can not be used in friend class declaration.
+ *       the followings are the error message from different combination.
+ *       friend add_complex<Csr>;
+ *         error: can not recognize it is class correctly.
+ *       friend class add_complex<Csr>;
+ *         error: using alias template specialization
+ *       friend class add_complex_s<Csr<ValueType,IndexType>>::type;
+ *         error: can not recognize it is class correctly.
  */
 template <typename T>
 using add_complex = typename add_complex_s<T>::type;
diff --git a/include/ginkgo/core/matrix/csr.hpp b/include/ginkgo/core/matrix/csr.hpp
index b71b194e6f3..4e44b7cd4e2 100644
--- a/include/ginkgo/core/matrix/csr.hpp
+++ b/include/ginkgo/core/matrix/csr.hpp
@@ -142,12 +142,6 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
     friend class SparsityCsr<ValueType, IndexType>;
     friend class CsrBuilder<ValueType, IndexType>;
     friend class Csr<add_complex<ValueType>, IndexType>;
-    // friend add_complex<Csr>;
-    //   error: can not recognize it is class correctly.
-    // friend class add_complex<Csr>;
-    //   error: using alias template specialization
-    // friend class add_complex_s<Csr<ValueType,IndexType>>::type;
-    //   error: can not recognize it is class correctly.
 
 public:
     using value_type = ValueType;
diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index 453be83cdea..684b3c003e9 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -218,6 +218,13 @@ class Hybrid
             return num_columns_;
         }
 
+        /**
+         * Get the number of columns limit
+         *
+         * @return the number of columns limit
+         */
+        auto get_num_columns() const { return num_columns_; }
+
     private:
         size_type num_columns_;
     };
@@ -260,6 +267,13 @@ class Hybrid
             }
         }
 
+        /**
+         * Get the percent setting
+         *
+         * @retrun percent
+         */
+        auto get_percent() const { return percent_; }
+
     private:
         float percent_;
     };
@@ -288,6 +302,20 @@ class Hybrid
                             static_cast<size_type>(num_rows * ratio_));
         }
 
+        /**
+         * Get the percent setting
+         *
+         * @retrun percent
+         */
+        auto get_percent() const { return strategy_.get_percent(); }
+
+        /**
+         * Get the ratio setting
+         *
+         * @retrun ratio
+         */
+        auto get_ratio() const { return ratio_; }
+
     private:
         imbalance_limit strategy_;
         float ratio_;
@@ -316,6 +344,13 @@ class Hybrid
             return strategy_.compute_ell_num_stored_elements_per_row(row_nnz);
         }
 
+        /**
+         * Get the percent setting
+         *
+         * @retrun percent
+         */
+        auto get_percent() { return strategy_.get_percent(); }
+
     private:
         imbalance_limit strategy_;
     };
@@ -581,6 +616,50 @@ class Hybrid
         return strategy_;
     }
 
+    /**
+     * Returns the current strategy allowed in given hybrid format
+     *
+     * @tparam HybType  hybrid type
+     *
+     * @return the strategy
+     */
+    template <typename HybType>
+    std::shared_ptr<typename HybType::strategy_type> get_strategy() const
+    {
+        std::shared_ptr<typename HybType::strategy_type> strategy;
+        if (std::dynamic_pointer_cast<automatic>(strategy_)) {
+            strategy = std::make_shared<typename HybType::automatic>();
+        } else if (auto temp = std::dynamic_pointer_cast<minimal_storage_limit>(
+                       strategy_)) {
+            // minimal_storage_limit is related to ValueType and IndexType size.
+            if (sizeof(value_type) == sizeof(typename HybType::value_type) &&
+                sizeof(index_type) == sizeof(typename HybType::index_type)) {
+                strategy =
+                    std::make_shared<typename HybType::minimal_storage_limit>();
+            } else {
+                strategy = std::make_shared<typename HybType::imbalance_limit>(
+                    temp->get_percent());
+            }
+        } else if (auto temp =
+                       std::dynamic_pointer_cast<imbalance_bounded_limit>(
+                           strategy_)) {
+            strategy =
+                std::make_shared<typename HybType::imbalance_bounded_limit>(
+                    temp->get_percent(), temp->get_ratio());
+        } else if (auto temp =
+                       std::dynamic_pointer_cast<imbalance_limit>(strategy_)) {
+            strategy = std::make_shared<typename HybType::imbalance_limit>(
+                temp->get_percent());
+        } else if (auto temp =
+                       std::dynamic_pointer_cast<column_limit>(strategy_)) {
+            strategy = std::make_shared<typename HybType::column_limit>(
+                temp->get_num_columns());
+        } else {
+            GKO_NOT_SUPPORTED(strategy_);
+        }
+        return strategy;
+    }
+
     /**
      * Copies data from another Hybrid.
      *
diff --git a/omp/test/matrix/hybrid_kernels.cpp b/omp/test/matrix/hybrid_kernels.cpp
index a57458b344e..948c78060ca 100644
--- a/omp/test/matrix/hybrid_kernels.cpp
+++ b/omp/test/matrix/hybrid_kernels.cpp
@@ -243,12 +243,19 @@ TEST_F(Hybrid, InplaceAbsoluteMatrixIsEquivalentToRef)
 
 TEST_F(Hybrid, OutplaceAbsoluteMatrixIsEquivalentToRef)
 {
-    set_up_apply_data();
+    set_up_apply_data(1, std::make_shared<Mtx::column_limit>(2));
+    using AbsMtx = gko::remove_complex<Mtx>;
 
     auto abs_mtx = mtx->compute_absolute();
     auto dabs_mtx = dmtx->compute_absolute();
+    auto abs_strategy = gko::as<AbsMtx::column_limit>(abs_mtx->get_strategy());
+    auto dabs_strategy =
+        gko::as<AbsMtx::column_limit>(dabs_mtx->get_strategy());
 
     GKO_ASSERT_MTX_NEAR(abs_mtx, dabs_mtx, 1e-14);
+    GKO_ASSERT_EQ(abs_strategy->get_num_columns(),
+                  dabs_strategy->get_num_columns());
+    GKO_ASSERT_EQ(abs_strategy->get_num_columns(), 2);
 }
 
 
diff --git a/reference/test/matrix/hybrid_kernels.cpp b/reference/test/matrix/hybrid_kernels.cpp
index 46123df227b..57125661cb9 100644
--- a/reference/test/matrix/hybrid_kernels.cpp
+++ b/reference/test/matrix/hybrid_kernels.cpp
@@ -673,12 +673,17 @@ TYPED_TEST(Hybrid, OutplaceAbsolute)
 {
     using Mtx = typename TestFixture::Mtx;
     auto mtx = gko::initialize<Mtx>(
-        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec);
+        {{1.0, 2.0, -2.0}, {3.0, -5.0, 0.0}, {0.0, 1.0, -1.5}}, this->exec,
+        std::make_shared<typename Mtx::column_limit>(2));
 
     auto abs_mtx = mtx->compute_absolute();
+    auto abs_strategy =
+        gko::as<typename gko::remove_complex<Mtx>::column_limit>(
+            abs_mtx->get_strategy());
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 2.0, 2.0}, {3.0, 5.0, 0.0}, {0.0, 1.0, 1.5}}), 0.0);
+    GKO_ASSERT_EQ(abs_strategy->get_num_columns(), 2);
 }
 
 
@@ -705,13 +710,17 @@ TYPED_TEST(HybridComplex, OutplaceAbsolute)
     auto mtx = gko::initialize<Mtx>(
         {{T{1.0, 0.0}, T{3.0, 4.0}, T{0.0, 2.0}},
          {T{-4.0, -3.0}, T{-1.0, 0}, T{0.0, 0.0}},
-         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec);
+         {T{0.0, 0.0}, T{0.0, -1.5}, T{2.0, 0.0}}}, exec, std::make_shared<typename Mtx::column_limit>(2));
     // clang-format on
 
     auto abs_mtx = mtx->compute_absolute();
+    auto abs_strategy =
+        gko::as<typename gko::remove_complex<Mtx>::column_limit>(
+            abs_mtx->get_strategy());
 
     GKO_ASSERT_MTX_NEAR(
         abs_mtx, l({{1.0, 5.0, 2.0}, {5.0, 1.0, 0.0}, {0.0, 1.5, 2.0}}), 0.0);
+    GKO_ASSERT_EQ(abs_strategy->get_num_columns(), 2);
 }
 
 

From 97a9e34dc2ac37964eea44009d73023af57e363b Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 17 Sep 2020 12:44:19 +0200
Subject: [PATCH 12/15] use absoluteLinOp template not concreteLinOp

---
 core/test/base/lin_op.cpp               |  3 +-
 include/ginkgo/core/base/lin_op.hpp     | 15 ++++---
 include/ginkgo/core/matrix/coo.hpp      |  6 +--
 include/ginkgo/core/matrix/csr.hpp      |  6 +--
 include/ginkgo/core/matrix/dense.hpp    | 52 ++++++++++++-------------
 include/ginkgo/core/matrix/diagonal.hpp | 24 ++++++------
 include/ginkgo/core/matrix/ell.hpp      |  6 +--
 include/ginkgo/core/matrix/hybrid.hpp   |  6 +--
 include/ginkgo/core/matrix/sellp.hpp    |  6 +--
 9 files changed, 62 insertions(+), 62 deletions(-)

diff --git a/core/test/base/lin_op.cpp b/core/test/base/lin_op.cpp
index 8cb0c8855eb..e73efa5e923 100644
--- a/core/test/base/lin_op.cpp
+++ b/core/test/base/lin_op.cpp
@@ -325,7 +325,8 @@ template <typename Type>
 class DummyLinOpWithType
     : public gko::EnableLinOp<DummyLinOpWithType<Type>>,
       public gko::EnableCreateMethod<DummyLinOpWithType<Type>>,
-      public gko::EnableAbsoluteComputation<DummyLinOpWithType<Type>> {
+      public gko::EnableAbsoluteComputation<
+          gko::remove_complex<DummyLinOpWithType<Type>>> {
 public:
     using absolute_type = gko::remove_complex<DummyLinOpWithType>;
     DummyLinOpWithType(std::shared_ptr<const gko::Executor> exec)
diff --git a/include/ginkgo/core/base/lin_op.hpp b/include/ginkgo/core/base/lin_op.hpp
index 5be7dadcded..6c873198b6e 100644
--- a/include/ginkgo/core/base/lin_op.hpp
+++ b/include/ginkgo/core/base/lin_op.hpp
@@ -626,7 +626,7 @@ class DiagonalExtractable {
 
 /**
  * The AbsoluteComputable is an interface that allows to get the component wise
- * absolute of a LinOp. Use EnableAbsoluteComputation<ConcreteLinOp> to
+ * absolute of a LinOp. Use EnableAbsoluteComputation<AbsoluteLinOp> to
  * implement this interface.
  */
 class AbsoluteComputable {
@@ -648,19 +648,18 @@ class AbsoluteComputable {
 /**
  * The EnableAbsoluteComputation mixin provides the default implementations of
  * `compute_absolute_linop` and the absolute interface. `compute_absolute` gets
- * a new remove_complex<ConcreteLinOp> which removes the complex value_type by
- * applying outplace absolute. `compute_absolute_inplace` applies absolute
+ * a new AbsoluteLinOp. `compute_absolute_inplace` applies absolute
  * inplace, so it still keeps the value_type of the class.
  *
- * @tparam ConcreteLinOp  the concrete LinOp which is being implemented
+ * @tparam AbsoluteLinOp  the absolute LinOp which is being returned
  *                        [CRTP parameter]
  *
  * @ingroup LinOp
  */
-template <typename ConcreteLinOp>
+template <typename AbsoluteLinOp>
 class EnableAbsoluteComputation : public AbsoluteComputable {
 public:
-    using outplace_type = remove_complex<ConcreteLinOp>;
+    using absolute_type = AbsoluteLinOp;
 
     virtual ~EnableAbsoluteComputation() = default;
 
@@ -670,11 +669,11 @@ class EnableAbsoluteComputation : public AbsoluteComputable {
     }
 
     /**
-     * Gets the absolute ConcreteLinOp
+     * Gets the AbsoluteLinOp
      *
      * @return a pointer to the new absolute object
      */
-    virtual std::unique_ptr<outplace_type> compute_absolute() const = 0;
+    virtual std::unique_ptr<absolute_type> compute_absolute() const = 0;
 };
 
 
diff --git a/include/ginkgo/core/matrix/coo.hpp b/include/ginkgo/core/matrix/coo.hpp
index 6a9b972e7ef..af7b75e1233 100644
--- a/include/ginkgo/core/matrix/coo.hpp
+++ b/include/ginkgo/core/matrix/coo.hpp
@@ -82,7 +82,8 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
             public DiagonalExtractable<ValueType>,
             public ReadableFromMatrixData<ValueType, IndexType>,
             public WritableToMatrixData<ValueType, IndexType>,
-            public EnableAbsoluteComputation<Coo<ValueType, IndexType>> {
+            public EnableAbsoluteComputation<
+                remove_complex<Coo<ValueType, IndexType>>> {
     friend class EnableCreateMethod<Coo>;
     friend class EnablePolymorphicObject<Coo, LinOp>;
     friend class Csr<ValueType, IndexType>;
@@ -97,8 +98,7 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
-    using absolute_type =
-        typename EnableAbsoluteComputation<Coo>::outplace_type;
+    using absolute_type = remove_complex<Coo>;
 
     friend class Coo<next_precision<ValueType>, IndexType>;
 
diff --git a/include/ginkgo/core/matrix/csr.hpp b/include/ginkgo/core/matrix/csr.hpp
index 4e44b7cd4e2..659a47aa05f 100644
--- a/include/ginkgo/core/matrix/csr.hpp
+++ b/include/ginkgo/core/matrix/csr.hpp
@@ -131,7 +131,8 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
             public WritableToMatrixData<ValueType, IndexType>,
             public Transposable,
             public Permutable<IndexType>,
-            public EnableAbsoluteComputation<Csr<ValueType, IndexType>> {
+            public EnableAbsoluteComputation<
+                remove_complex<Csr<ValueType, IndexType>>> {
     friend class EnableCreateMethod<Csr>;
     friend class EnablePolymorphicObject<Csr, LinOp>;
     friend class Coo<ValueType, IndexType>;
@@ -148,8 +149,7 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
     using index_type = IndexType;
     using transposed_type = Csr<ValueType, IndexType>;
     using mat_data = matrix_data<ValueType, IndexType>;
-    using absolute_type =
-        typename EnableAbsoluteComputation<Csr>::outplace_type;
+    using absolute_type = remove_complex<Csr>;
 
     class automatical;
 
diff --git a/include/ginkgo/core/matrix/dense.hpp b/include/ginkgo/core/matrix/dense.hpp
index b0b1aa9712c..f639f0799ed 100644
--- a/include/ginkgo/core/matrix/dense.hpp
+++ b/include/ginkgo/core/matrix/dense.hpp
@@ -88,30 +88,31 @@ class SparsityCsr;
  * @ingroup LinOp
  */
 template <typename ValueType = default_precision>
-class Dense : public EnableLinOp<Dense<ValueType>>,
-              public EnableCreateMethod<Dense<ValueType>>,
-              public ConvertibleTo<Dense<next_precision<ValueType>>>,
-              public ConvertibleTo<Coo<ValueType, int32>>,
-              public ConvertibleTo<Coo<ValueType, int64>>,
-              public ConvertibleTo<Csr<ValueType, int32>>,
-              public ConvertibleTo<Csr<ValueType, int64>>,
-              public ConvertibleTo<Ell<ValueType, int32>>,
-              public ConvertibleTo<Ell<ValueType, int64>>,
-              public ConvertibleTo<Hybrid<ValueType, int32>>,
-              public ConvertibleTo<Hybrid<ValueType, int64>>,
-              public ConvertibleTo<Sellp<ValueType, int32>>,
-              public ConvertibleTo<Sellp<ValueType, int64>>,
-              public ConvertibleTo<SparsityCsr<ValueType, int32>>,
-              public ConvertibleTo<SparsityCsr<ValueType, int64>>,
-              public DiagonalExtractable<ValueType>,
-              public ReadableFromMatrixData<ValueType, int32>,
-              public ReadableFromMatrixData<ValueType, int64>,
-              public WritableToMatrixData<ValueType, int32>,
-              public WritableToMatrixData<ValueType, int64>,
-              public Transposable,
-              public Permutable<int32>,
-              public Permutable<int64>,
-              public EnableAbsoluteComputation<Dense<ValueType>> {
+class Dense
+    : public EnableLinOp<Dense<ValueType>>,
+      public EnableCreateMethod<Dense<ValueType>>,
+      public ConvertibleTo<Dense<next_precision<ValueType>>>,
+      public ConvertibleTo<Coo<ValueType, int32>>,
+      public ConvertibleTo<Coo<ValueType, int64>>,
+      public ConvertibleTo<Csr<ValueType, int32>>,
+      public ConvertibleTo<Csr<ValueType, int64>>,
+      public ConvertibleTo<Ell<ValueType, int32>>,
+      public ConvertibleTo<Ell<ValueType, int64>>,
+      public ConvertibleTo<Hybrid<ValueType, int32>>,
+      public ConvertibleTo<Hybrid<ValueType, int64>>,
+      public ConvertibleTo<Sellp<ValueType, int32>>,
+      public ConvertibleTo<Sellp<ValueType, int64>>,
+      public ConvertibleTo<SparsityCsr<ValueType, int32>>,
+      public ConvertibleTo<SparsityCsr<ValueType, int64>>,
+      public DiagonalExtractable<ValueType>,
+      public ReadableFromMatrixData<ValueType, int32>,
+      public ReadableFromMatrixData<ValueType, int64>,
+      public WritableToMatrixData<ValueType, int32>,
+      public WritableToMatrixData<ValueType, int64>,
+      public Transposable,
+      public Permutable<int32>,
+      public Permutable<int64>,
+      public EnableAbsoluteComputation<remove_complex<Dense<ValueType>>> {
     friend class EnableCreateMethod<Dense>;
     friend class EnablePolymorphicObject<Dense, LinOp>;
     friend class Coo<ValueType, int32>;
@@ -138,8 +139,7 @@ class Dense : public EnableLinOp<Dense<ValueType>>,
     using transposed_type = Dense<ValueType>;
     using mat_data = gko::matrix_data<ValueType, int64>;
     using mat_data32 = gko::matrix_data<ValueType, int32>;
-    using absolute_type =
-        typename EnableAbsoluteComputation<Dense>::outplace_type;
+    using absolute_type = remove_complex<Dense>;
 
     using row_major_range = gko::range<gko::accessor::row_major<ValueType, 2>>;
 
diff --git a/include/ginkgo/core/matrix/diagonal.hpp b/include/ginkgo/core/matrix/diagonal.hpp
index f9e42fb769f..f34a6488d09 100644
--- a/include/ginkgo/core/matrix/diagonal.hpp
+++ b/include/ginkgo/core/matrix/diagonal.hpp
@@ -64,16 +64,17 @@ class Dense;
  * @ingroup LinOp
  */
 template <typename ValueType = default_precision>
-class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
-                 public EnableCreateMethod<Diagonal<ValueType>>,
-                 public ConvertibleTo<Csr<ValueType, int32>>,
-                 public ConvertibleTo<Csr<ValueType, int64>>,
-                 public Transposable,
-                 public WritableToMatrixData<ValueType, int32>,
-                 public WritableToMatrixData<ValueType, int64>,
-                 public ReadableFromMatrixData<ValueType, int32>,
-                 public ReadableFromMatrixData<ValueType, int64>,
-                 public EnableAbsoluteComputation<Diagonal<ValueType>> {
+class Diagonal
+    : public EnableLinOp<Diagonal<ValueType>>,
+      public EnableCreateMethod<Diagonal<ValueType>>,
+      public ConvertibleTo<Csr<ValueType, int32>>,
+      public ConvertibleTo<Csr<ValueType, int64>>,
+      public Transposable,
+      public WritableToMatrixData<ValueType, int32>,
+      public WritableToMatrixData<ValueType, int64>,
+      public ReadableFromMatrixData<ValueType, int32>,
+      public ReadableFromMatrixData<ValueType, int64>,
+      public EnableAbsoluteComputation<remove_complex<Diagonal<ValueType>>> {
     friend class EnablePolymorphicObject<Diagonal, LinOp>;
     friend class EnableCreateMethod<Diagonal>;
     friend class Csr<ValueType, int32>;
@@ -88,8 +89,7 @@ class Diagonal : public EnableLinOp<Diagonal<ValueType>>,
     using index_type = int64;
     using mat_data = gko::matrix_data<ValueType, int64>;
     using mat_data32 = gko::matrix_data<ValueType, int32>;
-    using absolute_type =
-        typename EnableAbsoluteComputation<Diagonal>::outplace_type;
+    using absolute_type = remove_complex<Diagonal>;
 
     std::unique_ptr<LinOp> transpose() const override;
 
diff --git a/include/ginkgo/core/matrix/ell.hpp b/include/ginkgo/core/matrix/ell.hpp
index 5fdfeb23770..d0ee6f80906 100644
--- a/include/ginkgo/core/matrix/ell.hpp
+++ b/include/ginkgo/core/matrix/ell.hpp
@@ -76,7 +76,8 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
             public DiagonalExtractable<ValueType>,
             public ReadableFromMatrixData<ValueType, IndexType>,
             public WritableToMatrixData<ValueType, IndexType>,
-            public EnableAbsoluteComputation<Ell<ValueType, IndexType>> {
+            public EnableAbsoluteComputation<
+                remove_complex<Ell<ValueType, IndexType>>> {
     friend class EnableCreateMethod<Ell>;
     friend class EnablePolymorphicObject<Ell, LinOp>;
     friend class Dense<ValueType>;
@@ -90,8 +91,7 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
-    using absolute_type =
-        typename EnableAbsoluteComputation<Ell>::outplace_type;
+    using absolute_type = remove_complex<Ell>;
 
     friend class Ell<next_precision<ValueType>, IndexType>;
 
diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index 684b3c003e9..d53089d128a 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -77,7 +77,8 @@ class Hybrid
       public DiagonalExtractable<ValueType>,
       public ReadableFromMatrixData<ValueType, IndexType>,
       public WritableToMatrixData<ValueType, IndexType>,
-      public EnableAbsoluteComputation<Hybrid<ValueType, IndexType>> {
+      public EnableAbsoluteComputation<
+          remove_complex<Hybrid<ValueType, IndexType>>> {
     friend class EnableCreateMethod<Hybrid>;
     friend class EnablePolymorphicObject<Hybrid, LinOp>;
     friend class Dense<ValueType>;
@@ -94,8 +95,7 @@ class Hybrid
     using mat_data = matrix_data<ValueType, IndexType>;
     using coo_type = Coo<ValueType, IndexType>;
     using ell_type = Ell<ValueType, IndexType>;
-    using absolute_type =
-        typename EnableAbsoluteComputation<Hybrid>::outplace_type;
+    using absolute_type = remove_complex<Hybrid>;
 
 
     /**
diff --git a/include/ginkgo/core/matrix/sellp.hpp b/include/ginkgo/core/matrix/sellp.hpp
index cbf06478bc6..2e8fe4623b9 100644
--- a/include/ginkgo/core/matrix/sellp.hpp
+++ b/include/ginkgo/core/matrix/sellp.hpp
@@ -73,7 +73,8 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
               public DiagonalExtractable<ValueType>,
               public ReadableFromMatrixData<ValueType, IndexType>,
               public WritableToMatrixData<ValueType, IndexType>,
-              public EnableAbsoluteComputation<Sellp<ValueType, IndexType>> {
+              public EnableAbsoluteComputation<
+                  remove_complex<Sellp<ValueType, IndexType>>> {
     friend class EnableCreateMethod<Sellp>;
     friend class EnablePolymorphicObject<Sellp, LinOp>;
     friend class Dense<ValueType>;
@@ -87,8 +88,7 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
     using value_type = ValueType;
     using index_type = IndexType;
     using mat_data = matrix_data<ValueType, IndexType>;
-    using absolute_type =
-        typename EnableAbsoluteComputation<Sellp>::outplace_type;
+    using absolute_type = remove_complex<Sellp>;
 
     friend class Sellp<next_precision<ValueType>, IndexType>;
 

From 81fc85a15a4835e7d000d793e00e4ad72dad6ae4 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 17 Sep 2020 14:11:53 +0200
Subject: [PATCH 13/15] to_complex/real and remove_complex only

---
 include/ginkgo/core/base/math.hpp       | 47 ++++++++-----------------
 include/ginkgo/core/matrix/coo.hpp      |  2 +-
 include/ginkgo/core/matrix/csr.hpp      |  2 +-
 include/ginkgo/core/matrix/dense.hpp    |  2 +-
 include/ginkgo/core/matrix/diagonal.hpp |  2 +-
 include/ginkgo/core/matrix/ell.hpp      |  2 +-
 include/ginkgo/core/matrix/hybrid.hpp   |  2 +-
 include/ginkgo/core/matrix/sellp.hpp    |  2 +-
 8 files changed, 22 insertions(+), 39 deletions(-)

diff --git a/include/ginkgo/core/base/math.hpp b/include/ginkgo/core/base/math.hpp
index 467d8668bd3..386f0bf737d 100644
--- a/include/ginkgo/core/base/math.hpp
+++ b/include/ginkgo/core/base/math.hpp
@@ -139,7 +139,7 @@ struct remove_complex_impl<std::complex<T>> {
  * @tparam T  the type being made complex
  */
 template <typename T>
-struct add_complex_impl {
+struct to_complex_impl {
     using type = std::complex<T>;
 };
 
@@ -149,7 +149,7 @@ struct add_complex_impl {
  * @tparam T  the type being made complex
  */
 template <typename T>
-struct add_complex_impl<std::complex<T>> {
+struct to_complex_impl<std::complex<T>> {
     using type = std::complex<T>;
 };
 
@@ -226,7 +226,7 @@ struct remove_complex_s<
 
 
 template <typename T, typename = void>
-struct add_complex_s {};
+struct to_complex_s {};
 
 /**
  * Obtains a complex counterpart of a real type, and leaves the type
@@ -235,9 +235,9 @@ struct add_complex_s {};
  * @tparam T  complex or scalar type
  */
 template <typename T>
-struct add_complex_s<
+struct to_complex_s<
     T, xstd::void_t<std::enable_if_t<is_complex_or_scalar_impl<T>::value>>> {
-    using type = typename detail::add_complex_impl<T>::type;
+    using type = typename detail::to_complex_impl<T>::type;
 };
 
 /**
@@ -247,10 +247,10 @@ struct add_complex_s<
  * @tparam T  class with template parameters
  */
 template <typename T>
-struct add_complex_s<
+struct to_complex_s<
     T, xstd::void_t<std::enable_if_t<!is_complex_or_scalar_impl<T>::value>>> {
     using type =
-        typename detail::template_convertor<detail::add_complex_impl, T>::type;
+        typename detail::template_convertor<detail::to_complex_impl, T>::type;
 };
 
 
@@ -353,27 +353,27 @@ using remove_complex = typename remove_complex_s<T>::type;
  * Add the complex of complex/scalar type or the template parameter of class
  * by accessing the `type` attribute of this struct.
  *
- * @tparam T  type to add complex
+ * @tparam T  type to complex_type
  */
-using detail::add_complex_s;
+using detail::to_complex_s;
 
 /**
  * Obtain the type which adds the complex of complex/scalar type or the
  * template parameter of class by accessing the `type` attribute of this struct.
  *
- * @tparam T  type to add complex
+ * @tparam T  type to complex_type
  *
- * @note add_complex<class> can not be used in friend class declaration.
+ * @note to_complex<class> can not be used in friend class declaration.
  *       the followings are the error message from different combination.
- *       friend add_complex<Csr>;
+ *       friend to_complex<Csr>;
  *         error: can not recognize it is class correctly.
- *       friend class add_complex<Csr>;
+ *       friend class to_complex<Csr>;
  *         error: using alias template specialization
- *       friend class add_complex_s<Csr<ValueType,IndexType>>::type;
+ *       friend class to_complex_s<Csr<ValueType,IndexType>>::type;
  *         error: can not recognize it is class correctly.
  */
 template <typename T>
-using add_complex = typename add_complex_s<T>::type;
+using to_complex = typename to_complex_s<T>::type;
 
 
 /**
@@ -393,23 +393,6 @@ template <typename T>
 using to_real = remove_complex<T>;
 
 
-/**
- * to_complex_s is alias of add_complex_s
- *
- * @tparam T  type to complex
- */
-template <typename T>
-using to_complex_s = add_complex_s<T>;
-
-/**
- * to_complex is alias of add_complex
- *
- * @tparam T  type to complex
- */
-template <typename T>
-using to_complex = add_complex<T>;
-
-
 namespace detail {
 
 
diff --git a/include/ginkgo/core/matrix/coo.hpp b/include/ginkgo/core/matrix/coo.hpp
index af7b75e1233..dd048fd5825 100644
--- a/include/ginkgo/core/matrix/coo.hpp
+++ b/include/ginkgo/core/matrix/coo.hpp
@@ -89,7 +89,7 @@ class Coo : public EnableLinOp<Coo<ValueType, IndexType>>,
     friend class Csr<ValueType, IndexType>;
     friend class Dense<ValueType>;
     friend class CooBuilder<ValueType, IndexType>;
-    friend class Coo<add_complex<ValueType>, IndexType>;
+    friend class Coo<to_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Coo>::convert_to;
diff --git a/include/ginkgo/core/matrix/csr.hpp b/include/ginkgo/core/matrix/csr.hpp
index 659a47aa05f..a30f6f856e3 100644
--- a/include/ginkgo/core/matrix/csr.hpp
+++ b/include/ginkgo/core/matrix/csr.hpp
@@ -142,7 +142,7 @@ class Csr : public EnableLinOp<Csr<ValueType, IndexType>>,
     friend class Sellp<ValueType, IndexType>;
     friend class SparsityCsr<ValueType, IndexType>;
     friend class CsrBuilder<ValueType, IndexType>;
-    friend class Csr<add_complex<ValueType>, IndexType>;
+    friend class Csr<to_complex<ValueType>, IndexType>;
 
 public:
     using value_type = ValueType;
diff --git a/include/ginkgo/core/matrix/dense.hpp b/include/ginkgo/core/matrix/dense.hpp
index f639f0799ed..b6ec2421455 100644
--- a/include/ginkgo/core/matrix/dense.hpp
+++ b/include/ginkgo/core/matrix/dense.hpp
@@ -128,7 +128,7 @@ class Dense
     friend class Sellp<ValueType, int64>;
     friend class SparsityCsr<ValueType, int32>;
     friend class SparsityCsr<ValueType, int64>;
-    friend class Dense<add_complex<ValueType>>;
+    friend class Dense<to_complex<ValueType>>;
 
 public:
     using EnableLinOp<Dense>::convert_to;
diff --git a/include/ginkgo/core/matrix/diagonal.hpp b/include/ginkgo/core/matrix/diagonal.hpp
index f34a6488d09..b268421c163 100644
--- a/include/ginkgo/core/matrix/diagonal.hpp
+++ b/include/ginkgo/core/matrix/diagonal.hpp
@@ -79,7 +79,7 @@ class Diagonal
     friend class EnableCreateMethod<Diagonal>;
     friend class Csr<ValueType, int32>;
     friend class Csr<ValueType, int64>;
-    friend class Diagonal<add_complex<ValueType>>;
+    friend class Diagonal<to_complex<ValueType>>;
 
 public:
     using EnableLinOp<Diagonal>::convert_to;
diff --git a/include/ginkgo/core/matrix/ell.hpp b/include/ginkgo/core/matrix/ell.hpp
index d0ee6f80906..cbcd3552700 100644
--- a/include/ginkgo/core/matrix/ell.hpp
+++ b/include/ginkgo/core/matrix/ell.hpp
@@ -82,7 +82,7 @@ class Ell : public EnableLinOp<Ell<ValueType, IndexType>>,
     friend class EnablePolymorphicObject<Ell, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
-    friend class Ell<add_complex<ValueType>, IndexType>;
+    friend class Ell<to_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Ell>::convert_to;
diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index d53089d128a..5e782ca8aa2 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -83,7 +83,7 @@ class Hybrid
     friend class EnablePolymorphicObject<Hybrid, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
-    friend class Hybrid<add_complex<ValueType>, IndexType>;
+    friend class Hybrid<to_complex<ValueType>, IndexType>;
 
 
 public:
diff --git a/include/ginkgo/core/matrix/sellp.hpp b/include/ginkgo/core/matrix/sellp.hpp
index 2e8fe4623b9..e28a5f3a73e 100644
--- a/include/ginkgo/core/matrix/sellp.hpp
+++ b/include/ginkgo/core/matrix/sellp.hpp
@@ -79,7 +79,7 @@ class Sellp : public EnableLinOp<Sellp<ValueType, IndexType>>,
     friend class EnablePolymorphicObject<Sellp, LinOp>;
     friend class Dense<ValueType>;
     friend class Csr<ValueType, IndexType>;
-    friend class Sellp<add_complex<ValueType>, IndexType>;
+    friend class Sellp<to_complex<ValueType>, IndexType>;
 
 public:
     using EnableLinOp<Sellp>::convert_to;

From c5157f53228919f94d4c76d528051819c9ffd1cd Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 18 Sep 2020 12:42:35 +0200
Subject: [PATCH 14/15] split get_strategy<Hyb> impl, decl; check HybType

---
 include/ginkgo/core/matrix/hybrid.hpp | 78 +++++++++++++++------------
 1 file changed, 43 insertions(+), 35 deletions(-)

diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index 5e782ca8aa2..3b8653864dc 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -624,41 +624,7 @@ class Hybrid
      * @return the strategy
      */
     template <typename HybType>
-    std::shared_ptr<typename HybType::strategy_type> get_strategy() const
-    {
-        std::shared_ptr<typename HybType::strategy_type> strategy;
-        if (std::dynamic_pointer_cast<automatic>(strategy_)) {
-            strategy = std::make_shared<typename HybType::automatic>();
-        } else if (auto temp = std::dynamic_pointer_cast<minimal_storage_limit>(
-                       strategy_)) {
-            // minimal_storage_limit is related to ValueType and IndexType size.
-            if (sizeof(value_type) == sizeof(typename HybType::value_type) &&
-                sizeof(index_type) == sizeof(typename HybType::index_type)) {
-                strategy =
-                    std::make_shared<typename HybType::minimal_storage_limit>();
-            } else {
-                strategy = std::make_shared<typename HybType::imbalance_limit>(
-                    temp->get_percent());
-            }
-        } else if (auto temp =
-                       std::dynamic_pointer_cast<imbalance_bounded_limit>(
-                           strategy_)) {
-            strategy =
-                std::make_shared<typename HybType::imbalance_bounded_limit>(
-                    temp->get_percent(), temp->get_ratio());
-        } else if (auto temp =
-                       std::dynamic_pointer_cast<imbalance_limit>(strategy_)) {
-            strategy = std::make_shared<typename HybType::imbalance_limit>(
-                temp->get_percent());
-        } else if (auto temp =
-                       std::dynamic_pointer_cast<column_limit>(strategy_)) {
-            strategy = std::make_shared<typename HybType::column_limit>(
-                temp->get_num_columns());
-        } else {
-            GKO_NOT_SUPPORTED(strategy_);
-        }
-        return strategy;
-    }
+    std::shared_ptr<typename HybType::strategy_type> get_strategy() const;
 
     /**
      * Copies data from another Hybrid.
@@ -778,6 +744,48 @@ class Hybrid
 };
 
 
+template <typename ValueType, typename IndexType>
+template <typename HybType>
+std::shared_ptr<typename HybType::strategy_type>
+Hybrid<ValueType, IndexType>::get_strategy() const
+{
+    static_assert(
+        std::is_same<HybType, Hybrid<typename HybType::value_type,
+                                     typename HybType::index_type>>::value,
+        "The given `HybType` type must be of type `matrix::Hybrid`!");
+
+    std::shared_ptr<typename HybType::strategy_type> strategy;
+    if (std::dynamic_pointer_cast<automatic>(strategy_)) {
+        strategy = std::make_shared<typename HybType::automatic>();
+    } else if (auto temp = std::dynamic_pointer_cast<minimal_storage_limit>(
+                   strategy_)) {
+        // minimal_storage_limit is related to ValueType and IndexType size.
+        if (sizeof(value_type) == sizeof(typename HybType::value_type) &&
+            sizeof(index_type) == sizeof(typename HybType::index_type)) {
+            strategy =
+                std::make_shared<typename HybType::minimal_storage_limit>();
+        } else {
+            strategy = std::make_shared<typename HybType::imbalance_limit>(
+                temp->get_percent());
+        }
+    } else if (auto temp = std::dynamic_pointer_cast<imbalance_bounded_limit>(
+                   strategy_)) {
+        strategy = std::make_shared<typename HybType::imbalance_bounded_limit>(
+            temp->get_percent(), temp->get_ratio());
+    } else if (auto temp =
+                   std::dynamic_pointer_cast<imbalance_limit>(strategy_)) {
+        strategy = std::make_shared<typename HybType::imbalance_limit>(
+            temp->get_percent());
+    } else if (auto temp = std::dynamic_pointer_cast<column_limit>(strategy_)) {
+        strategy = std::make_shared<typename HybType::column_limit>(
+            temp->get_num_columns());
+    } else {
+        GKO_NOT_SUPPORTED(strategy_);
+    }
+    return strategy;
+}
+
+
 }  // namespace matrix
 }  // namespace gko
 

From e0b703afe25b13353e09884544b2201bcedb2e6b Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 25 Sep 2020 10:34:46 +0200
Subject: [PATCH 15/15] review update (remove unneeded, refine format) - remove
 unneed void_t on enable_if_t - remove the remove_complex_s,
 to_complex_s/real_s in gko namespace - refine code style on test according to
 AAA rule
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Thomas Grützmacher <thomas.gruetzmacher@kit.edu>
---
 core/base/extended_float.hpp                 |  7 +-
 core/test/base/lin_op.cpp                    | 13 ++--
 core/test/base/math.cpp                      |  8 +++
 core/test/matrix/hybrid.cpp                  | 12 ++--
 cuda/test/components/absolute_array.cpp      |  4 ++
 hip/test/components/absolute_array.hip.cpp   |  4 ++
 include/ginkgo/core/base/math.hpp            | 68 ++++++--------------
 include/ginkgo/core/matrix/hybrid.hpp        | 12 ++--
 omp/test/components/absolute_array.cpp       |  4 ++
 reference/test/components/absolute_array.cpp |  4 ++
 reference/test/matrix/dense_kernels.cpp      | 51 ++++++++++-----
 reference/test/matrix/diagonal_kernels.cpp   |  4 +-
 12 files changed, 105 insertions(+), 86 deletions(-)

diff --git a/core/base/extended_float.hpp b/core/base/extended_float.hpp
index 8ebf836641b..c83e7b81f20 100644
--- a/core/base/extended_float.hpp
+++ b/core/base/extended_float.hpp
@@ -70,18 +70,17 @@ template <std::size_t, typename = void>
 struct uint_of_impl {};
 
 template <std::size_t Bits>
-struct uint_of_impl<Bits, xstd::void_t<std::enable_if_t<(Bits <= 16)>>> {
+struct uint_of_impl<Bits, std::enable_if_t<(Bits <= 16)>> {
     using type = uint16;
 };
 
 template <std::size_t Bits>
-struct uint_of_impl<Bits,
-                    xstd::void_t<std::enable_if_t<(16 < Bits && Bits <= 32)>>> {
+struct uint_of_impl<Bits, std::enable_if_t<(16 < Bits && Bits <= 32)>> {
     using type = uint32;
 };
 
 template <std::size_t Bits>
-struct uint_of_impl<Bits, xstd::void_t<std::enable_if_t<(32 < Bits)>>> {
+struct uint_of_impl<Bits, std::enable_if_t<(32 < Bits)>> {
     using type = uint64;
 };
 
diff --git a/core/test/base/lin_op.cpp b/core/test/base/lin_op.cpp
index e73efa5e923..303e8bd6e89 100644
--- a/core/test/base/lin_op.cpp
+++ b/core/test/base/lin_op.cpp
@@ -35,6 +35,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <complex>
 #include <memory>
+#include <type_traits>
 
 
 #include <gtest/gtest.h>
@@ -386,8 +387,10 @@ TEST_F(EnableAbsoluteComputation, OutplaceAbsoluteOnConcreteType)
 {
     auto abs_op = op->compute_absolute();
 
-    ASSERT_EQ(typeid(abs_op),
-              typeid(std::unique_ptr<gko::remove_complex<dummy_type>>));
+    static_assert(
+        std::is_same<decltype(abs_op),
+                     std::unique_ptr<gko::remove_complex<dummy_type>>>::value,
+        "Types must match.");
     ASSERT_EQ(abs_op->get_value(), 5.0);
 }
 
@@ -407,8 +410,10 @@ TEST_F(EnableAbsoluteComputation, OutplaceAbsoluteOnAbsoluteComputable)
 {
     auto abs_op = op->compute_absolute();
 
-    ASSERT_EQ(typeid(abs_op),
-              typeid(std::unique_ptr<gko::remove_complex<dummy_type>>));
+    static_assert(
+        std::is_same<decltype(abs_op),
+                     std::unique_ptr<gko::remove_complex<dummy_type>>>::value,
+        "Types must match.");
     ASSERT_EQ(abs_op->get_value(), 5.0);
 }
 
diff --git a/core/test/base/math.cpp b/core/test/base/math.cpp
index 0e54c87f788..288bea41576 100644
--- a/core/test/base/math.cpp
+++ b/core/test/base/math.cpp
@@ -143,7 +143,9 @@ TEST(RemoveComplexClass, Float)
 {
     using origin = DummyClass<float, int>;
     using expect = DummyClass<float, int>;
+
     bool check = std::is_same<expect, gko::remove_complex<origin>>::value;
+
     ASSERT_TRUE(check);
 }
 
@@ -152,7 +154,9 @@ TEST(RemoveComplexClass, Double)
 {
     using origin = DummyClass<double, int>;
     using expect = DummyClass<double, int>;
+
     bool check = std::is_same<expect, gko::remove_complex<origin>>::value;
+
     ASSERT_TRUE(check);
 }
 
@@ -161,7 +165,9 @@ TEST(RemoveComplexClass, FloatComplex)
 {
     using origin = DummyClass<std::complex<float>, int>;
     using expect = DummyClass<float, int>;
+
     bool check = std::is_same<expect, gko::remove_complex<origin>>::value;
+
     ASSERT_TRUE(check);
 }
 
@@ -170,7 +176,9 @@ TEST(RemoveComplexClass, DoubleComplex)
 {
     using origin = DummyClass<std::complex<double>, int>;
     using expect = DummyClass<double, int>;
+
     bool check = std::is_same<expect, gko::remove_complex<origin>>::value;
+
     ASSERT_TRUE(check);
 }
 
diff --git a/core/test/matrix/hybrid.cpp b/core/test/matrix/hybrid.cpp
index 9045e950a23..9a5ad45f0c7 100644
--- a/core/test/matrix/hybrid.cpp
+++ b/core/test/matrix/hybrid.cpp
@@ -339,8 +339,8 @@ TYPED_TEST(Hybrid, GetCorrectImbalanceLimit)
     auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
     auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
 
-    EXPECT_EQ(mtx_stra->get_percent(), 0.4f);
-    EXPECT_EQ(mtx2_stra->get_percent(), 0.4f);
+    EXPECT_EQ(mtx_stra->get_percentage(), 0.4f);
+    EXPECT_EQ(mtx2_stra->get_percentage(), 0.4f);
 }
 
 
@@ -355,9 +355,9 @@ TYPED_TEST(Hybrid, GetCorrectImbalanceBoundedLimit)
     auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
     auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
 
-    EXPECT_EQ(mtx_stra->get_percent(), 0.4f);
+    EXPECT_EQ(mtx_stra->get_percentage(), 0.4f);
     EXPECT_EQ(mtx_stra->get_ratio(), 0.1f);
-    EXPECT_EQ(mtx2_stra->get_percent(), 0.4f);
+    EXPECT_EQ(mtx2_stra->get_percentage(), 0.4f);
     EXPECT_EQ(mtx2_stra->get_ratio(), 0.1f);
 }
 
@@ -375,7 +375,7 @@ TYPED_TEST(Hybrid, GetCorrectMinimalStorageLimitWithDifferentHybType)
     auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
     auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
 
-    EXPECT_EQ(mtx2_stra->get_percent(), mtx_stra->get_percent());
+    EXPECT_EQ(mtx2_stra->get_percentage(), mtx_stra->get_percentage());
 }
 
 
@@ -390,7 +390,7 @@ TYPED_TEST(Hybrid, GetCorrectMinimalStorageLimitWithSameHybType)
     auto mtx_stra = gko::as<strategy>(mtx->get_strategy());
     auto mtx2_stra = gko::as<strategy2>(mtx->template get_strategy<Mtx2>());
 
-    EXPECT_EQ(mtx2_stra->get_percent(), mtx_stra->get_percent());
+    EXPECT_EQ(mtx2_stra->get_percentage(), mtx_stra->get_percentage());
 }
 
 
diff --git a/cuda/test/components/absolute_array.cpp b/cuda/test/components/absolute_array.cpp
index 6bdef3df6dd..919c042cff0 100644
--- a/cuda/test/components/absolute_array.cpp
+++ b/cuda/test/components/absolute_array.cpp
@@ -85,6 +85,7 @@ TEST_F(AbsoluteArray, InplaceEqualsReference)
         exec, dvals.get_data(), total_size);
     gko::kernels::reference::components::inplace_absolute_array(
         ref, vals.get_data(), total_size);
+
     GKO_ASSERT_ARRAY_EQ(vals, dvals);
 }
 
@@ -95,6 +96,7 @@ TEST_F(AbsoluteArray, InplaceComplexEqualsReference)
         exec, dcomplex_vals.get_data(), total_size);
     gko::kernels::reference::components::inplace_absolute_array(
         ref, complex_vals.get_data(), total_size);
+
     GKO_ASSERT_ARRAY_EQ(complex_vals, dcomplex_vals);
 }
 
@@ -108,6 +110,7 @@ TEST_F(AbsoluteArray, OutplaceEqualsReference)
         exec, dvals.get_const_data(), total_size, dabs_vals.get_data());
     gko::kernels::reference::components::outplace_absolute_array(
         ref, vals.get_const_data(), total_size, abs_vals.get_data());
+
     GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
 }
 
@@ -121,6 +124,7 @@ TEST_F(AbsoluteArray, OutplaceComplexEqualsReference)
         exec, dcomplex_vals.get_const_data(), total_size, dabs_vals.get_data());
     gko::kernels::reference::components::outplace_absolute_array(
         ref, complex_vals.get_const_data(), total_size, abs_vals.get_data());
+
     GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
 }
 
diff --git a/hip/test/components/absolute_array.hip.cpp b/hip/test/components/absolute_array.hip.cpp
index 8df8e79109d..f718805d5eb 100644
--- a/hip/test/components/absolute_array.hip.cpp
+++ b/hip/test/components/absolute_array.hip.cpp
@@ -85,6 +85,7 @@ TEST_F(AbsoluteArray, InplaceEqualsReference)
         exec, dvals.get_data(), total_size);
     gko::kernels::reference::components::inplace_absolute_array(
         ref, vals.get_data(), total_size);
+
     GKO_ASSERT_ARRAY_EQ(vals, dvals);
 }
 
@@ -95,6 +96,7 @@ TEST_F(AbsoluteArray, InplaceComplexEqualsReference)
         exec, dcomplex_vals.get_data(), total_size);
     gko::kernels::reference::components::inplace_absolute_array(
         ref, complex_vals.get_data(), total_size);
+
     GKO_ASSERT_ARRAY_EQ(complex_vals, dcomplex_vals);
 }
 
@@ -108,6 +110,7 @@ TEST_F(AbsoluteArray, OutplaceEqualsReference)
         exec, dvals.get_const_data(), total_size, dabs_vals.get_data());
     gko::kernels::reference::components::outplace_absolute_array(
         ref, vals.get_const_data(), total_size, abs_vals.get_data());
+
     GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
 }
 
@@ -121,6 +124,7 @@ TEST_F(AbsoluteArray, OutplaceComplexEqualsReference)
         exec, dcomplex_vals.get_const_data(), total_size, dabs_vals.get_data());
     gko::kernels::reference::components::outplace_absolute_array(
         ref, complex_vals.get_const_data(), total_size, abs_vals.get_data());
+
     GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
 }
 
diff --git a/include/ginkgo/core/base/math.hpp b/include/ginkgo/core/base/math.hpp
index 386f0bf737d..0bb6ac9b5a9 100644
--- a/include/ginkgo/core/base/math.hpp
+++ b/include/ginkgo/core/base/math.hpp
@@ -170,28 +170,28 @@ struct is_complex_or_scalar_impl<std::complex<T>> : std::is_scalar<T> {};
 
 
 /**
- * template_convertor is converting the template parameters of a class by
- * convertor<type>.
+ * template_converter is converting the template parameters of a class by
+ * converter<type>.
  *
- * @tparam  convertor<type> which convert one type to another type
+ * @tparam  converter<type> which convert one type to another type
  * @tparam  T  type
  */
-template <template <typename> class convertor, typename T>
-struct template_convertor {};
+template <template <typename> class converter, typename T>
+struct template_converter {};
 
 /**
- * template_convertor is converting the template parameters of a class by
- * convertor<type>. Converting class<T1, T2, ...> to class<convertor<T1>,
- * convertor<T2>, convertor<...>>.
+ * template_converter is converting the template parameters of a class by
+ * converter<type>. Converting class<T1, T2, ...> to class<converter<T1>,
+ * converter<T2>, converter<...>>.
  *
- * @tparam  convertor<type> which convert one type to another type
+ * @tparam  converter<type> which convert one type to another type
  * @tparam  template <...> T  class template base
  * @tparam  ...Rest  the template parameter of T
  */
-template <template <typename> class convertor, template <typename...> class T,
+template <template <typename> class converter, template <typename...> class T,
           typename... Rest>
-struct template_convertor<convertor, T<Rest...>> {
-    using type = T<typename convertor<Rest>::type...>;
+struct template_converter<converter, T<Rest...>> {
+    using type = T<typename converter<Rest>::type...>;
 };
 
 
@@ -205,8 +205,8 @@ struct remove_complex_s {};
  * @tparam T  complex or scalar type
  */
 template <typename T>
-struct remove_complex_s<
-    T, xstd::void_t<std::enable_if_t<is_complex_or_scalar_impl<T>::value>>> {
+struct remove_complex_s<T,
+                        std::enable_if_t<is_complex_or_scalar_impl<T>::value>> {
     using type = typename detail::remove_complex_impl<T>::type;
 };
 
@@ -218,9 +218,9 @@ struct remove_complex_s<
  */
 template <typename T>
 struct remove_complex_s<
-    T, xstd::void_t<std::enable_if_t<!is_complex_or_scalar_impl<T>::value>>> {
+    T, std::enable_if_t<!is_complex_or_scalar_impl<T>::value>> {
     using type =
-        typename detail::template_convertor<detail::remove_complex_impl,
+        typename detail::template_converter<detail::remove_complex_impl,
                                             T>::type;
 };
 
@@ -235,8 +235,7 @@ struct to_complex_s {};
  * @tparam T  complex or scalar type
  */
 template <typename T>
-struct to_complex_s<
-    T, xstd::void_t<std::enable_if_t<is_complex_or_scalar_impl<T>::value>>> {
+struct to_complex_s<T, std::enable_if_t<is_complex_or_scalar_impl<T>::value>> {
     using type = typename detail::to_complex_impl<T>::type;
 };
 
@@ -247,10 +246,9 @@ struct to_complex_s<
  * @tparam T  class with template parameters
  */
 template <typename T>
-struct to_complex_s<
-    T, xstd::void_t<std::enable_if_t<!is_complex_or_scalar_impl<T>::value>>> {
+struct to_complex_s<T, std::enable_if_t<!is_complex_or_scalar_impl<T>::value>> {
     using type =
-        typename detail::template_convertor<detail::to_complex_impl, T>::type;
+        typename detail::template_converter<detail::to_complex_impl, T>::type;
 };
 
 
@@ -329,14 +327,6 @@ GKO_INLINE GKO_ATTRIBUTES constexpr bool is_complex_or_scalar()
 }
 
 
-/**
- * Removes the complex of complex/scalar type or the template parameter of class
- * by accessing the `type` attribute of this struct.
- *
- * @tparam T  type to remove complex
- */
-using detail::remove_complex_s;
-
 /**
  * Obtain the type which removed the complex of complex/scalar type or the
  * template parameter of class by accessing the `type` attribute of this struct.
@@ -346,17 +336,9 @@ using detail::remove_complex_s;
  * @note remove_complex<class> can not be used in friend class declaration.
  */
 template <typename T>
-using remove_complex = typename remove_complex_s<T>::type;
+using remove_complex = typename detail::remove_complex_s<T>::type;
 
 
-/**
- * Add the complex of complex/scalar type or the template parameter of class
- * by accessing the `type` attribute of this struct.
- *
- * @tparam T  type to complex_type
- */
-using detail::to_complex_s;
-
 /**
  * Obtain the type which adds the complex of complex/scalar type or the
  * template parameter of class by accessing the `type` attribute of this struct.
@@ -373,17 +355,9 @@ using detail::to_complex_s;
  *         error: can not recognize it is class correctly.
  */
 template <typename T>
-using to_complex = typename to_complex_s<T>::type;
+using to_complex = typename detail::to_complex_s<T>::type;
 
 
-/**
- * to_real_s is alias of remove_complex_s
- *
- * @tparam T  type to real
- */
-template <typename T>
-using to_real_s = remove_complex_s<T>;
-
 /**
  * to_real is alias of remove_complex
  *
diff --git a/include/ginkgo/core/matrix/hybrid.hpp b/include/ginkgo/core/matrix/hybrid.hpp
index 3b8653864dc..c844907e8b2 100644
--- a/include/ginkgo/core/matrix/hybrid.hpp
+++ b/include/ginkgo/core/matrix/hybrid.hpp
@@ -272,7 +272,7 @@ class Hybrid
          *
          * @retrun percent
          */
-        auto get_percent() const { return percent_; }
+        auto get_percentage() const { return percent_; }
 
     private:
         float percent_;
@@ -307,7 +307,7 @@ class Hybrid
          *
          * @retrun percent
          */
-        auto get_percent() const { return strategy_.get_percent(); }
+        auto get_percentage() const { return strategy_.get_percentage(); }
 
         /**
          * Get the ratio setting
@@ -349,7 +349,7 @@ class Hybrid
          *
          * @retrun percent
          */
-        auto get_percent() { return strategy_.get_percent(); }
+        auto get_percentage() { return strategy_.get_percentage(); }
 
     private:
         imbalance_limit strategy_;
@@ -766,16 +766,16 @@ Hybrid<ValueType, IndexType>::get_strategy() const
                 std::make_shared<typename HybType::minimal_storage_limit>();
         } else {
             strategy = std::make_shared<typename HybType::imbalance_limit>(
-                temp->get_percent());
+                temp->get_percentage());
         }
     } else if (auto temp = std::dynamic_pointer_cast<imbalance_bounded_limit>(
                    strategy_)) {
         strategy = std::make_shared<typename HybType::imbalance_bounded_limit>(
-            temp->get_percent(), temp->get_ratio());
+            temp->get_percentage(), temp->get_ratio());
     } else if (auto temp =
                    std::dynamic_pointer_cast<imbalance_limit>(strategy_)) {
         strategy = std::make_shared<typename HybType::imbalance_limit>(
-            temp->get_percent());
+            temp->get_percentage());
     } else if (auto temp = std::dynamic_pointer_cast<column_limit>(strategy_)) {
         strategy = std::make_shared<typename HybType::column_limit>(
             temp->get_num_columns());
diff --git a/omp/test/components/absolute_array.cpp b/omp/test/components/absolute_array.cpp
index 9304def3fa9..92203777d9c 100644
--- a/omp/test/components/absolute_array.cpp
+++ b/omp/test/components/absolute_array.cpp
@@ -85,6 +85,7 @@ TEST_F(AbsoluteArray, InplaceEqualsReference)
         exec, dvals.get_data(), total_size);
     gko::kernels::reference::components::inplace_absolute_array(
         ref, vals.get_data(), total_size);
+
     GKO_ASSERT_ARRAY_EQ(vals, dvals);
 }
 
@@ -95,6 +96,7 @@ TEST_F(AbsoluteArray, InplaceComplexEqualsReference)
         exec, dcomplex_vals.get_data(), total_size);
     gko::kernels::reference::components::inplace_absolute_array(
         ref, complex_vals.get_data(), total_size);
+
     GKO_ASSERT_ARRAY_EQ(complex_vals, dcomplex_vals);
 }
 
@@ -108,6 +110,7 @@ TEST_F(AbsoluteArray, OutplaceEqualsReference)
         exec, dvals.get_const_data(), total_size, dabs_vals.get_data());
     gko::kernels::reference::components::outplace_absolute_array(
         ref, vals.get_const_data(), total_size, abs_vals.get_data());
+
     GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
 }
 
@@ -121,6 +124,7 @@ TEST_F(AbsoluteArray, OutplaceComplexEqualsReference)
         exec, dcomplex_vals.get_const_data(), total_size, dabs_vals.get_data());
     gko::kernels::reference::components::outplace_absolute_array(
         ref, complex_vals.get_const_data(), total_size, abs_vals.get_data());
+
     GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
 }
 
diff --git a/reference/test/components/absolute_array.cpp b/reference/test/components/absolute_array.cpp
index 83cc444df20..9793a6cf0ed 100644
--- a/reference/test/components/absolute_array.cpp
+++ b/reference/test/components/absolute_array.cpp
@@ -81,8 +81,10 @@ TYPED_TEST_CASE(AbsoluteArray, gko::test::ValueTypes);
 TYPED_TEST(AbsoluteArray, InplaceEqualsExpected)
 {
     using T = typename TestFixture::value_type;
+
     gko::kernels::reference::components::inplace_absolute_array(
         this->ref, this->vals.get_data(), this->total_size);
+
     GKO_ASSERT_ARRAY_EQ(this->vals, this->inplace_expected);
 }
 
@@ -92,9 +94,11 @@ TYPED_TEST(AbsoluteArray, OutplaceEqualsExpected)
     using T = typename TestFixture::value_type;
     using AbsT = typename TestFixture::abs_type;
     gko::Array<AbsT> abs_vals(this->ref, this->total_size);
+
     gko::kernels::reference::components::outplace_absolute_array(
         this->ref, this->vals.get_const_data(), this->total_size,
         abs_vals.get_data());
+
     GKO_ASSERT_ARRAY_EQ(abs_vals, this->outplace_expected);
 }
 
diff --git a/reference/test/matrix/dense_kernels.cpp b/reference/test/matrix/dense_kernels.cpp
index cea66d04f43..9ac4b9b448f 100644
--- a/reference/test/matrix/dense_kernels.cpp
+++ b/reference/test/matrix/dense_kernels.cpp
@@ -1726,9 +1726,10 @@ TYPED_TEST(Dense, SquareMatrixIsRowPermutable)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx5->get_executor();
     gko::Array<gko::int32> permute_idxs{exec, {1, 2, 0}};
-    auto row_permute = this->mtx5->row_permute(&permute_idxs);
 
+    auto row_permute = this->mtx5->row_permute(&permute_idxs);
     auto row_permute_dense = static_cast<Mtx *>(row_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(row_permute_dense,
                         l({{-2.0, 2.0, 4.5},
@@ -1747,9 +1748,10 @@ TYPED_TEST(Dense, NonSquareMatrixIsRowPermutable)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx4->get_executor();
     gko::Array<gko::int32> permute_idxs{exec, {1, 0}};
-    auto row_permute = this->mtx4->row_permute(&permute_idxs);
 
+    auto row_permute = this->mtx4->row_permute(&permute_idxs);
     auto row_permute_dense = static_cast<Mtx *>(row_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(row_permute_dense,
                         l({{0.0, 5.0, 0.0},
@@ -1768,9 +1770,10 @@ TYPED_TEST(Dense, SquareMatrixIsColPermutable)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx5->get_executor();
     gko::Array<gko::int32> permute_idxs{exec, {1, 2, 0}};
-    auto c_permute = this->mtx5->column_permute(&permute_idxs);
 
+    auto c_permute = this->mtx5->column_permute(&permute_idxs);
     auto c_permute_dense = static_cast<Mtx *>(c_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(c_permute_dense,
                         l({{-1.0, -0.5, 1.0}, {2.0, 4.5, -2.0}, {3.4, 1.2, 2.1}}), r<TypeParam>::value);
@@ -1787,9 +1790,10 @@ TYPED_TEST(Dense, NonSquareMatrixIsColPermutable)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx4->get_executor();
     gko::Array<gko::int32> permute_idxs{exec, {1, 2, 0}};
-    auto c_permute = this->mtx4->column_permute(&permute_idxs);
 
+    auto c_permute = this->mtx4->column_permute(&permute_idxs);
     auto c_permute_dense = static_cast<Mtx *>(c_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(c_permute_dense,
                         l({{3.0, 2.0, 1.0},
@@ -1809,11 +1813,12 @@ TYPED_TEST(Dense, SquareMatrixIsInverseRowPermutable)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx5->get_executor();
     gko::Array<gko::int32> inverse_permute_idxs{exec, {1, 2, 0}};
+
     auto inverse_row_permute =
         this->mtx5->inverse_row_permute(&inverse_permute_idxs);
-
     auto inverse_row_permute_dense =
         static_cast<Mtx *>(inverse_row_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(inverse_row_permute_dense,
                         l({{2.1, 3.4, 1.2},
@@ -1832,11 +1837,12 @@ TYPED_TEST(Dense, NonSquareMatrixIsInverseRowPermutable)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx4->get_executor();
     gko::Array<gko::int32> inverse_permute_idxs{exec, {1, 0}};
+
     auto inverse_row_permute =
         this->mtx4->inverse_row_permute(&inverse_permute_idxs);
-
     auto inverse_row_permute_dense =
         static_cast<Mtx *>(inverse_row_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(inverse_row_permute_dense,
                         l({{0.0, 5.0, 0.0},
@@ -1855,10 +1861,11 @@ TYPED_TEST(Dense, SquareMatrixIsInverseColPermutable)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx5->get_executor();
     gko::Array<gko::int32> inverse_permute_idxs{exec, {1, 2, 0}};
+
     auto inverse_c_permute =
         this->mtx5->inverse_column_permute(&inverse_permute_idxs);
-
     auto inverse_c_permute_dense = static_cast<Mtx *>(inverse_c_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(inverse_c_permute_dense,
                         l({{-0.5, 1.0, -1.0},
@@ -1877,10 +1884,11 @@ TYPED_TEST(Dense, NonSquareMatrixIsInverseColPermutable)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx4->get_executor();
     gko::Array<gko::int32> inverse_permute_idxs{exec, {1, 2, 0}};
+
     auto inverse_c_permute =
         this->mtx4->inverse_column_permute(&inverse_permute_idxs);
-
     auto inverse_c_permute_dense = static_cast<Mtx *>(inverse_c_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(inverse_c_permute_dense,
                         l({{2.0, 1.0, 3.0},
@@ -1899,9 +1907,10 @@ TYPED_TEST(Dense, NonSquareMatrixIsRowPermutable64)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx4->get_executor();
     gko::Array<gko::int64> permute_idxs{exec, {1, 0}};
-    auto row_permute = this->mtx4->row_permute(&permute_idxs);
 
+    auto row_permute = this->mtx4->row_permute(&permute_idxs);
     auto row_permute_dense = static_cast<Mtx *>(row_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(row_permute_dense,
                         l({{0.0, 5.0, 0.0},
@@ -1919,9 +1928,10 @@ TYPED_TEST(Dense, NonSquareMatrixIsColPermutable64)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx4->get_executor();
     gko::Array<gko::int64> permute_idxs{exec, {1, 2, 0}};
-    auto c_permute = this->mtx4->column_permute(&permute_idxs);
 
+    auto c_permute = this->mtx4->column_permute(&permute_idxs);
     auto c_permute_dense = static_cast<Mtx *>(c_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(c_permute_dense,
                         l({{3.0, 2.0, 1.0},
@@ -1940,11 +1950,12 @@ TYPED_TEST(Dense, NonSquareMatrixIsInverseRowPermutable64)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx4->get_executor();
     gko::Array<gko::int64> inverse_permute_idxs{exec, {1, 0}};
+
     auto inverse_row_permute =
         this->mtx4->inverse_row_permute(&inverse_permute_idxs);
-
     auto inverse_row_permute_dense =
         static_cast<Mtx *>(inverse_row_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(inverse_row_permute_dense,
                         l({{0.0, 5.0, 0.0},
@@ -1962,10 +1973,11 @@ TYPED_TEST(Dense, NonSquareMatrixIsInverseColPermutable64)
     using Mtx = typename TestFixture::Mtx;
     auto exec = this->mtx4->get_executor();
     gko::Array<gko::int64> inverse_permute_idxs{exec, {1, 2, 0}};
+
     auto inverse_c_permute =
         this->mtx4->inverse_column_permute(&inverse_permute_idxs);
-
     auto inverse_c_permute_dense = static_cast<Mtx *>(inverse_c_permute.get());
+
     // clang-format off
     GKO_ASSERT_MTX_NEAR(inverse_c_permute_dense,
                         l({{2.0, 1.0, 3.0},
@@ -1978,6 +1990,7 @@ TYPED_TEST(Dense, NonSquareMatrixIsInverseColPermutable64)
 TYPED_TEST(Dense, ExtractsDiagonalFromSquareMatrix)
 {
     using T = typename TestFixture::value_type;
+
     // clang-format off
     // {1.0, -1.0, -0.5},
     // {-2.0, 2.0, 4.5},
@@ -1996,6 +2009,7 @@ TYPED_TEST(Dense, ExtractsDiagonalFromSquareMatrix)
 TYPED_TEST(Dense, ExtractsDiagonalFromNonSquareMatrix)
 {
     using T = typename TestFixture::value_type;
+
     // clang-format off
     // {1.0, 3.0, 2.0},
     // {0.0, 5.0, 0.0}
@@ -2017,6 +2031,7 @@ TYPED_TEST(Dense, InplaceAbsolute)
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
+
     this->mtx5->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(this->mtx5,
@@ -2028,13 +2043,14 @@ TYPED_TEST(Dense, InplaceAbsolute)
 TYPED_TEST(Dense, InplaceAbsoluteSubMatrix)
 {
     using T = typename TestFixture::value_type;
-    // mtx takes the left top corner 2 x 2 matrix
-    auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2});
     // clang-format off
     // {1.0, -1.0, -0.5},
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
+    // mtx takes the left top corner 2 x 2 matrix
+    auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2});
+
     mtx->compute_absolute_inplace();
 
     GKO_ASSERT_MTX_NEAR(this->mtx5,
@@ -2051,6 +2067,7 @@ TYPED_TEST(Dense, OutplaceAbsolute)
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
+
     auto abs_mtx = this->mtx5->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx,
@@ -2062,13 +2079,14 @@ TYPED_TEST(Dense, OutplaceAbsolute)
 TYPED_TEST(Dense, OutplaceAbsoluteSubMatrix)
 {
     using T = typename TestFixture::value_type;
-    // mtx takes the left top corner 2 x 2 matrix
-    auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2});
     // clang-format off
     // {1.0, -1.0, -0.5},
     // {-2.0, 2.0, 4.5},
     // {2.1, 3.4, 1.2}
     // clang-format on
+    // mtx takes the left top corner 2 x 2 matrix
+    auto mtx = this->mtx5->create_submatrix(gko::span{0, 2}, gko::span{0, 2});
+
     auto abs_mtx = mtx->compute_absolute();
 
     GKO_ASSERT_MTX_NEAR(abs_mtx, l({{1.0, 1.0}, {2.0, 2.0}}),
@@ -2097,6 +2115,7 @@ TYPED_TEST(DenseComplex, NonSquareMatrixIsConjugateTransposable)
                                        {T{-2.0, 1.5}, T{4.5, 0.0}},
                                        {T{1.0, 0.0}, T{0.0, 1.0}}},
                                       exec);
+
     auto trans = mtx->conj_transpose();
     auto trans_as_dense = static_cast<Dense *>(trans.get());
 
diff --git a/reference/test/matrix/diagonal_kernels.cpp b/reference/test/matrix/diagonal_kernels.cpp
index fc207889de3..1d39ee9367d 100644
--- a/reference/test/matrix/diagonal_kernels.cpp
+++ b/reference/test/matrix/diagonal_kernels.cpp
@@ -395,7 +395,6 @@ TYPED_TEST(DiagonalComplex, MtxIsConjugateTransposable)
 {
     using Diag = typename TestFixture::Diag;
     using value_type = typename TestFixture::value_type;
-
     auto exec = gko::ReferenceExecutor::create();
     auto diag = Diag::create(exec, 3);
     auto diag_values = diag->get_values();
@@ -406,6 +405,7 @@ TYPED_TEST(DiagonalComplex, MtxIsConjugateTransposable)
     auto trans = diag->conj_transpose();
     auto trans_as_diagonal = static_cast<Diag *>(trans.get());
     auto trans_values = trans_as_diagonal->get_values();
+
     EXPECT_EQ(trans->get_size(), gko::dim<2>(3));
     EXPECT_EQ(trans_values[0], (value_type{1.0, -2.0}));
     EXPECT_EQ(trans_values[1], (value_type{3.0, 0.0}));
@@ -417,7 +417,6 @@ TYPED_TEST(DiagonalComplex, InplaceAbsolute)
 {
     using Diag = typename TestFixture::Diag;
     using value_type = typename TestFixture::value_type;
-
     auto exec = gko::ReferenceExecutor::create();
     auto diag = Diag::create(exec, 3);
     auto diag_values = diag->get_values();
@@ -438,7 +437,6 @@ TYPED_TEST(DiagonalComplex, OutplaceAbsolute)
     using Diag = typename TestFixture::Diag;
     using value_type = typename TestFixture::value_type;
     using abs_type = gko::remove_complex<value_type>;
-
     auto exec = gko::ReferenceExecutor::create();
     auto diag = Diag::create(exec, 3);
     auto diag_values = diag->get_values();