tensor/reductions.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/common/trace.hpp>
#include <uni20/core/scalar_concepts.hpp>
#include <uni20/linalg/backend_selector.hpp>
#include <uni20/linalg/backends/cpu/reductions.hpp>
#include <uni20/linalg/dispatch.hpp>
#include <uni20/linalg/operation_tags.hpp>
#include <uni20/mdspan/concepts.hpp>
#include <uni20/storage/host_storage.hpp>
#include <uni20/tensor/concepts.hpp>
#include <uni20/tensor/tensor.hpp>
 
#if UNI20_BACKEND_CUBLAS
#include <uni20/linalg/backends/cublas/reductions.hpp>
#endif
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace uni20
{
namespace detail
{
 
template <class LhsSpan, class RhsSpan>
concept CompatibleInnerProductSpans = MdspanLike<LhsSpan> && MdspanLike<RhsSpan> &&
                                      (std::remove_cvref_t<LhsSpan>::rank() == std::remove_cvref_t<RhsSpan>::rank()) &&
                                      std::same_as<typename std::remove_cvref_t<LhsSpan>::value_type,
                                                   typename std::remove_cvref_t<RhsSpan>::value_type> &&
                                      RealOrComplex<typename std::remove_cvref_t<LhsSpan>::value_type>;
 
template <class LhsTensor, class RhsTensor>
concept CompatibleInnerProductTensors = TensorView<LhsTensor> && TensorView<RhsTensor> &&
                                        (tensor_mdspec_t<LhsTensor>::rank() == tensor_mdspec_t<RhsTensor>::rank()) &&
                                        std::same_as<tensor_element_t<LhsTensor>, tensor_element_t<RhsTensor>> &&
                                        RealOrComplex<tensor_element_t<LhsTensor>>;
 
template <class Tensor>
concept ReductionStorageTypedTensor =
    TensorView<Tensor> && requires { typename std::remove_cvref_t<Tensor>::storage_policy; };
 
template <class... Inputs> struct reduction_result_storage
{
    using selected_type = linalg::detail::first_backend_bound_storage_t<Inputs...>;
    using type = std::conditional_t<std::is_void_v<selected_type>, HostStorage, selected_type>;
};
 
template <class... Inputs> using reduction_result_storage_t = typename reduction_result_storage<Inputs...>::type;
 
template <class Element, class... Inputs>
concept ReductionResultAvailable = (ReductionStorageTypedTensor<Inputs> && ...) && requires {
  typename reduction_result_storage_t<Inputs...>::template storage_t<Element>;
};
 
template <TensorView InputTensor, std::size_t ReducedRank>
using sum_reduction_layout_t = std::conditional_t<tensor_mdspec_t<InputTensor>::rank() == ReducedRank, ColumnMajor,
                                                  materialized_layout_t<void, tensor_mdspec_t<InputTensor>>>;
 
template <TensorView InputTensor, std::size_t ReducedRank>
using sum_reduction_result_t =
    Tensor<tensor_element_t<InputTensor>, tensor_mdspec_t<InputTensor>::rank() - ReducedRank,
           reduction_result_storage_t<InputTensor>, sum_reduction_layout_t<InputTensor, ReducedRank>>;
 
template <TensorView InputTensor, std::size_t InputRank, std::size_t ReducedRank, std::size_t... OutputAxis>
[[nodiscard]] auto reduction_output_extents(InputTensor const& input,
                                            linalg::ReductionAxes<InputRank, ReducedRank> const& axes,
                                            std::index_sequence<OutputAxis...>)
{
  using extents_type = stdex::dextents<uni20::index_type, InputRank - ReducedRank>;
  return extents_type{static_cast<uni20::index_type>(input.extent(axes.surviving[OutputAxis]))...};
}
 
template <TensorView InputTensor, std::size_t InputRank, std::size_t ReducedRank>
[[nodiscard]] auto reduction_output_extents(InputTensor const& input,
                                            linalg::ReductionAxes<InputRank, ReducedRank> const& axes)
{
  return reduction_output_extents(input, axes, std::make_index_sequence<InputRank - ReducedRank>{});
}
 
template <class BackendSelector, class OutputSpan, class InputSpan, std::size_t InputRank, std::size_t ReducedRank>
void dispatch_sum(BackendSelector&& selector, OutputSpan&& output, InputSpan&& input,
                  linalg::ReductionAxes<InputRank, ReducedRank> axes)
{
  auto operation = linalg::sum_reduction_op<InputRank, ReducedRank>{.axes = std::move(axes)};
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), std::move(operation),
                          std::forward<OutputSpan>(output), std::forward<InputSpan>(input));
}
 
template <class Reference, class... Others>
void require_reduction_extents(Reference const& reference, Others const&... others)
{
  constexpr std::size_t rank = tensor_mdspec_t<Reference>::rank();
  if constexpr (rank > 0)
  {
    auto require_one = [&](auto const& other) {
      for (std::size_t axis = 0; axis < rank; ++axis)
        ERROR_IF(reference.extent(axis) != other.extent(axis), "reduction operands have different extents");
    };
    (require_one(others), ...);
  }
}
 
} // namespace detail
 
template <linalg::KernelBackendSelector BackendSelector, MutableRankedMdspanLike<0> OutputSpan, MdspanLike InputSpan>
  requires RealOrComplex<typename std::remove_cvref_t<InputSpan>::value_type> &&
           std::same_as<typename std::remove_cvref_t<OutputSpan>::value_type,
                        typename std::remove_cvref_t<InputSpan>::value_type>
void sum(BackendSelector&& selector, OutputSpan&& output, InputSpan&& input)
{
  using input_type = std::remove_cvref_t<InputSpan>;
  auto output_descriptor = std::forward<OutputSpan>(output);
  auto input_descriptor = make_const_mdspan(input);
  detail::dispatch_sum(std::forward<BackendSelector>(selector), output_descriptor, input_descriptor,
                       linalg::all_reduction_axes<input_type::rank()>());
}
 
template <linalg::KernelBackendSelector BackendSelector, MutableMdspanLike OutputSpan, MdspanLike InputSpan,
          linalg::ReductionAxis FirstAxis, linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<typename std::remove_cvref_t<InputSpan>::value_type> &&
           std::same_as<typename std::remove_cvref_t<OutputSpan>::value_type,
                        typename std::remove_cvref_t<InputSpan>::value_type> &&
           (1 + sizeof...(RestAxes) <= std::remove_cvref_t<InputSpan>::rank()) &&
           (std::remove_cvref_t<OutputSpan>::rank() + 1 + sizeof...(RestAxes) == std::remove_cvref_t<InputSpan>::rank())
void sum(BackendSelector&& selector, OutputSpan&& output, InputSpan&& input, FirstAxis first_axis,
         RestAxes... rest_axes)
{
  using input_type = std::remove_cvref_t<InputSpan>;
  auto axes = linalg::make_reduction_axes<input_type::rank()>(first_axis, rest_axes...);
  auto output_descriptor = std::forward<OutputSpan>(output);
  auto input_descriptor = make_const_mdspan(input);
  detail::dispatch_sum(std::forward<BackendSelector>(selector), output_descriptor, input_descriptor, std::move(axes));
}
 
template <linalg::KernelBackendSelector BackendSelector, MdspanLike InputSpan>
  requires RealOrComplex<typename std::remove_cvref_t<InputSpan>::value_type>
[[nodiscard]] auto sum_host(BackendSelector&& selector, InputSpan&& input) ->
    typename std::remove_cvref_t<InputSpan>::value_type
{
  using input_type = std::remove_cvref_t<InputSpan>;
  using result_type = typename input_type::value_type;
  result_type result{};
  auto input_descriptor = make_const_mdspan(input);
  detail::dispatch_sum(std::forward<BackendSelector>(selector), result, input_descriptor,
                       linalg::all_reduction_axes<input_type::rank()>());
  return result;
}
 
template <linalg::KernelBackendSelector BackendSelector, MutableScalarTensorView OutputTensor, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<InputTensor>>
void sum(BackendSelector&& selector, OutputTensor&& output, InputTensor const& input)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto output_descriptor = mdspec_of(output);
  auto input_descriptor = mdspec_of(input);
  detail::dispatch_sum(std::forward<BackendSelector>(selector), output_descriptor, input_descriptor,
                       linalg::all_reduction_axes<input_rank>());
}
 
template <MutableScalarTensorView OutputTensor, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<InputTensor>>
void sum(OutputTensor&& output, InputTensor const& input)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto operation = linalg::sum_reduction_op<input_rank, input_rank>{.axes = linalg::all_reduction_axes<input_rank>()};
  auto selector = linalg::select_backend(operation, output, input);
  auto output_descriptor = mdspec_of(output);
  auto input_descriptor = mdspec_of(input);
  detail::dispatch_sum(selector, output_descriptor, input_descriptor, operation.axes);
}
 
template <linalg::KernelBackendSelector BackendSelector, MutableTensorView OutputTensor, TensorView InputTensor,
          linalg::ReductionAxis FirstAxis, linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<InputTensor>> &&
           (1 + sizeof...(RestAxes) <= tensor_mdspec_t<InputTensor>::rank()) &&
           (tensor_mdspec_t<OutputTensor>::rank() + 1 + sizeof...(RestAxes) == tensor_mdspec_t<InputTensor>::rank())
void sum(BackendSelector&& selector, OutputTensor&& output, InputTensor const& input, FirstAxis first_axis,
         RestAxes... rest_axes)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto axes = linalg::make_reduction_axes<input_rank>(first_axis, rest_axes...);
  prepare_output(output, detail::reduction_output_extents(input, axes));
  auto output_descriptor = mdspec_of(output);
  auto input_descriptor = mdspec_of(input);
  detail::dispatch_sum(std::forward<BackendSelector>(selector), output_descriptor, input_descriptor, std::move(axes));
}
 
template <MutableTensorView OutputTensor, TensorView InputTensor, linalg::ReductionAxis FirstAxis,
          linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<InputTensor>> &&
           (1 + sizeof...(RestAxes) <= tensor_mdspec_t<InputTensor>::rank()) &&
           (tensor_mdspec_t<OutputTensor>::rank() + 1 + sizeof...(RestAxes) == tensor_mdspec_t<InputTensor>::rank())
void sum(OutputTensor&& output, InputTensor const& input, FirstAxis first_axis, RestAxes... rest_axes)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto axes = linalg::make_reduction_axes<input_rank>(first_axis, rest_axes...);
  auto operation = linalg::sum_reduction_op<input_rank, 1 + sizeof...(RestAxes)>{.axes = axes};
  auto selector = linalg::select_backend(operation, output, input);
  prepare_output(output, detail::reduction_output_extents(input, axes));
  auto output_descriptor = mdspec_of(output);
  auto input_descriptor = mdspec_of(input);
  detail::dispatch_sum(selector, output_descriptor, input_descriptor, std::move(axes));
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           detail::ReductionResultAvailable<tensor_element_t<InputTensor>, InputTensor>
[[nodiscard]] auto sum(BackendSelector&& selector, InputTensor const& input)
{
  using result_type = ScalarTensor<tensor_element_t<InputTensor>, detail::reduction_result_storage_t<InputTensor>>;
  result_type result(uninitialized);
  sum(std::forward<BackendSelector>(selector), result, input);
  return result;
}
 
template <TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           detail::ReductionResultAvailable<tensor_element_t<InputTensor>, InputTensor>
[[nodiscard]] auto sum(InputTensor const& input)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto operation = linalg::sum_reduction_op<input_rank, input_rank>{.axes = linalg::all_reduction_axes<input_rank>()};
  auto selector = linalg::select_backend(operation, input);
  return sum(selector, input);
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView InputTensor, linalg::ReductionAxis FirstAxis,
          linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           (1 + sizeof...(RestAxes) <= tensor_mdspec_t<InputTensor>::rank()) &&
           detail::ReductionResultAvailable<tensor_element_t<InputTensor>, InputTensor>
[[nodiscard]] auto sum(BackendSelector&& selector, InputTensor const& input, FirstAxis first_axis,
                       RestAxes... rest_axes)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  constexpr std::size_t reduced_rank = 1 + sizeof...(RestAxes);
  auto axes = linalg::make_reduction_axes<input_rank>(first_axis, rest_axes...);
  using result_type = detail::sum_reduction_result_t<InputTensor, reduced_rank>;
  result_type result(uninitialized, detail::reduction_output_extents(input, axes));
  auto output_descriptor = mdspec_of(result);
  auto input_descriptor = mdspec_of(input);
  detail::dispatch_sum(std::forward<BackendSelector>(selector), output_descriptor, input_descriptor, std::move(axes));
  return result;
}
 
template <TensorView InputTensor, linalg::ReductionAxis FirstAxis, linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           (1 + sizeof...(RestAxes) <= tensor_mdspec_t<InputTensor>::rank()) &&
           detail::ReductionResultAvailable<tensor_element_t<InputTensor>, InputTensor>
[[nodiscard]] auto sum(InputTensor const& input, FirstAxis first_axis, RestAxes... rest_axes)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto axes = linalg::make_reduction_axes<input_rank>(first_axis, rest_axes...);
  auto operation = linalg::sum_reduction_op<input_rank, 1 + sizeof...(RestAxes)>{.axes = axes};
  auto selector = linalg::select_backend(operation, input);
  return sum(selector, input, first_axis, rest_axes...);
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>>
[[nodiscard]] auto sum_host(BackendSelector&& selector, InputTensor const& input) -> tensor_element_t<InputTensor>
{
  using result_type = tensor_element_t<InputTensor>;
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  result_type result{};
  auto input_descriptor = mdspec_of(input);
  detail::dispatch_sum(std::forward<BackendSelector>(selector), result, input_descriptor,
                       linalg::all_reduction_axes<input_rank>());
  return result;
}
 
template <TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>>
[[nodiscard]] auto sum_host(InputTensor const& input) -> tensor_element_t<InputTensor>
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto operation = linalg::sum_reduction_op<input_rank, input_rank>{.axes = linalg::all_reduction_axes<input_rank>()};
  auto selector = linalg::select_backend(operation, input);
  return sum_host(selector, input);
}
 
template <class BackendSelector, MutableRankedMdspanLike<0> OutputSpan, class LhsSpan, class RhsSpan>
  requires detail::CompatibleInnerProductSpans<LhsSpan, RhsSpan> &&
           std::same_as<typename std::remove_cvref_t<OutputSpan>::value_type,
                        typename std::remove_cvref_t<LhsSpan>::value_type>
void inner_product(BackendSelector&& selector, OutputSpan&& output, LhsSpan&& lhs, RhsSpan&& rhs)
{
  auto output_descriptor = std::forward<OutputSpan>(output);
  auto lhs_descriptor = make_const_mdspan(lhs);
  auto rhs_descriptor = make_const_mdspan(rhs);
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), linalg::inner_product_op{}, output_descriptor,
                          lhs_descriptor, rhs_descriptor);
}
 
template <class BackendSelector, class LhsSpan, class RhsSpan>
  requires detail::CompatibleInnerProductSpans<LhsSpan, RhsSpan>
[[nodiscard]] auto inner_product_host(BackendSelector&& selector, LhsSpan&& lhs, RhsSpan&& rhs) ->
    typename std::remove_cvref_t<LhsSpan>::value_type
{
  using result_type = typename std::remove_cvref_t<LhsSpan>::value_type;
  result_type result{};
  auto lhs_descriptor = make_const_mdspan(lhs);
  auto rhs_descriptor = make_const_mdspan(rhs);
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), linalg::inner_product_op{}, result, lhs_descriptor,
                          rhs_descriptor);
  return result;
}
 
template <class BackendSelector, MutableScalarTensorView OutputTensor, class LhsTensor, class RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<LhsTensor>>
void inner_product(BackendSelector&& selector, OutputTensor&& output, LhsTensor const& lhs, RhsTensor const& rhs)
{
  detail::require_reduction_extents(lhs, rhs);
  auto output_descriptor = mdspec_of(output);
  auto lhs_descriptor = mdspec_of(lhs);
  auto rhs_descriptor = mdspec_of(rhs);
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), linalg::inner_product_op{}, output_descriptor,
                          lhs_descriptor, rhs_descriptor);
}
 
template <MutableScalarTensorView OutputTensor, class LhsTensor, class RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<LhsTensor>>
void inner_product(OutputTensor&& output, LhsTensor const& lhs, RhsTensor const& rhs)
{
  detail::require_reduction_extents(lhs, rhs);
  auto selector = linalg::select_backend(linalg::inner_product_op{}, output, lhs, rhs);
  inner_product(selector, output, lhs, rhs);
}
 
template <class BackendSelector, class LhsTensor, class RhsTensor>
  requires(!TensorView<BackendSelector>) && detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor> &&
          detail::ReductionResultAvailable<tensor_element_t<LhsTensor>, LhsTensor, RhsTensor>
[[nodiscard]] auto inner_product(BackendSelector&& selector, LhsTensor const& lhs, RhsTensor const& rhs)
{
  using result_type =
      ScalarTensor<tensor_element_t<LhsTensor>, detail::reduction_result_storage_t<LhsTensor, RhsTensor>>;
  result_type result(uninitialized);
  inner_product(std::forward<BackendSelector>(selector), result, lhs, rhs);
  return result;
}
 
template <class LhsTensor, class RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor> &&
           detail::ReductionResultAvailable<tensor_element_t<LhsTensor>, LhsTensor, RhsTensor>
[[nodiscard]] auto inner_product(LhsTensor const& lhs, RhsTensor const& rhs)
{
  detail::require_reduction_extents(lhs, rhs);
  auto selector = linalg::select_backend(linalg::inner_product_op{}, lhs, rhs);
  return inner_product(selector, lhs, rhs);
}
 
template <class BackendSelector, class LhsTensor, class RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor>
[[nodiscard]] auto inner_product_host(BackendSelector&& selector, LhsTensor const& lhs,
                                      RhsTensor const& rhs) -> tensor_element_t<LhsTensor>
{
  detail::require_reduction_extents(lhs, rhs);
  using result_type = tensor_element_t<LhsTensor>;
  result_type result{};
  auto lhs_descriptor = mdspec_of(lhs);
  auto rhs_descriptor = mdspec_of(rhs);
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), linalg::inner_product_op{}, result, lhs_descriptor,
                          rhs_descriptor);
  return result;
}
 
template <class LhsTensor, class RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor>
[[nodiscard]] auto inner_product_host(LhsTensor const& lhs, RhsTensor const& rhs) -> tensor_element_t<LhsTensor>
{
  detail::require_reduction_extents(lhs, rhs);
  auto selector = linalg::select_backend(linalg::inner_product_op{}, lhs, rhs);
  return inner_product_host(selector, lhs, rhs);
}
 
template <class BackendSelector, MutableRankedMdspanLike<0> OutputSpan, MdspanLike InputSpan>
  requires RealOrComplex<typename std::remove_cvref_t<InputSpan>::value_type> &&
           std::same_as<typename std::remove_cvref_t<OutputSpan>::value_type,
                        make_real_t<typename std::remove_cvref_t<InputSpan>::value_type>>
void norm(BackendSelector&& selector, OutputSpan&& output, InputSpan&& input)
{
  auto output_descriptor = std::forward<OutputSpan>(output);
  auto input_descriptor = make_const_mdspan(input);
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), linalg::norm_op{}, output_descriptor,
                          input_descriptor);
}
 
template <class BackendSelector, MdspanLike InputSpan>
  requires RealOrComplex<typename std::remove_cvref_t<InputSpan>::value_type>
[[nodiscard]] auto norm_host(BackendSelector&& selector,
                             InputSpan&& input) -> make_real_t<typename std::remove_cvref_t<InputSpan>::value_type>
{
  using result_type = make_real_t<typename std::remove_cvref_t<InputSpan>::value_type>;
  result_type result{};
  auto input_descriptor = make_const_mdspan(input);
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), linalg::norm_op{}, result, input_descriptor);
  return result;
}
 
template <class BackendSelector, MutableScalarTensorView OutputTensor, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, make_real_t<tensor_element_t<InputTensor>>>
void norm(BackendSelector&& selector, OutputTensor&& output, InputTensor const& input)
{
  auto output_descriptor = mdspec_of(output);
  auto input_descriptor = mdspec_of(input);
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), linalg::norm_op{}, output_descriptor,
                          input_descriptor);
}
 
template <MutableScalarTensorView OutputTensor, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, make_real_t<tensor_element_t<InputTensor>>>
void norm(OutputTensor&& output, InputTensor const& input)
{
  auto selector = linalg::select_backend(linalg::norm_op{}, output, input);
  norm(selector, output, input);
}
 
template <class BackendSelector, TensorView InputTensor>
  requires(!TensorView<BackendSelector>) && RealOrComplex<tensor_element_t<InputTensor>> &&
          detail::ReductionResultAvailable<make_real_t<tensor_element_t<InputTensor>>, InputTensor>
[[nodiscard]] auto norm(BackendSelector&& selector, InputTensor const& input)
{
  using result_type =
      ScalarTensor<make_real_t<tensor_element_t<InputTensor>>, detail::reduction_result_storage_t<InputTensor>>;
  result_type result(uninitialized);
  norm(std::forward<BackendSelector>(selector), result, input);
  return result;
}
 
template <TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           detail::ReductionResultAvailable<make_real_t<tensor_element_t<InputTensor>>, InputTensor>
[[nodiscard]] auto norm(InputTensor const& input)
{
  auto selector = linalg::select_backend(linalg::norm_op{}, input);
  return norm(selector, input);
}
 
template <class BackendSelector, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>>
[[nodiscard]] auto norm_host(BackendSelector&& selector,
                             InputTensor const& input) -> make_real_t<tensor_element_t<InputTensor>>
{
  using result_type = make_real_t<tensor_element_t<InputTensor>>;
  result_type result{};
  auto input_descriptor = mdspec_of(input);
  linalg::dispatch_kernel(std::forward<BackendSelector>(selector), linalg::norm_op{}, result, input_descriptor);
  return result;
}
 
template <TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>>
[[nodiscard]] auto norm_host(InputTensor const& input) -> make_real_t<tensor_element_t<InputTensor>>
{
  auto selector = linalg::select_backend(linalg::norm_op{}, input);
  return norm_host(selector, input);
}
 
} // namespace uni20