concepts.hpp

Go to the documentation of this file.

// Copyright (c) 2020-2023 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Olivier Parcollet, Nils Wentzell
 
#pragma once
 
#include "./stdutil/concepts.hpp"
#include "./traits.hpp"
 
#include <array>
#include <concepts>
#include <type_traits>
#include <utility>
 
namespace nda {
 
  // clang has full support for "lambdas in unevaluated context" only for versions >= 17.
#ifndef __clang__
 
  // clang-format off
  template <typename A, int R>
  concept CallableWithLongs = requires(A const &a) {
    // if decltype is not present, the concept will fail to compile for an A for which the a(Is...) is not well formed
    []<auto... Is>(std::index_sequence<Is...>, auto const &aa) -> decltype(aa(long(Is)...)) {return aa(long(Is)...);}
    (std::make_index_sequence<R>{}, a);
  };
  // clang-format on
 
#else
 
  namespace detail {
 
    // Helper function declaration to check if A can be called with R long arguments.
    template <auto... Is, typename A>
    auto call_on_R_longs(std::index_sequence<Is...>, A const &a) -> decltype(a((long{Is})...)); // no impl needed
 
  } // namespace detail
 
  template <typename A, int R>
  concept CallableWithLongs = requires(A const &a) {
    { detail::call_on_R_longs(std::make_index_sequence<R>{}, a) };
  };
 
#endif // __clang__
 
  namespace detail {
 
    // Check if T is of type std::array<long, R> for arbitrary array sizes R.
    template <typename T>
    constexpr bool is_std_array_of_long_v = false;
 
    // Specialization of nda::detail::is_std_array_of_long_v for cvref types.
    template <typename T>
      requires(!std::is_same_v<T, std::remove_cvref_t<T>>)
    constexpr bool is_std_array_of_long_v<T> = is_std_array_of_long_v<std::remove_cvref_t<T>>;
 
    // Specialization of nda::detail::is_std_array_of_long_v for std::array<long, R>.
    template <auto R>
    constexpr bool is_std_array_of_long_v<std::array<long, R>> = true;
 
  } // namespace detail
 
  template <class T>
  concept StdArrayOfLong = detail::is_std_array_of_long_v<T>;
 
  template <typename S>
  concept Scalar = nda::is_scalar_v<S>;
 
  template <typename S>
  concept DoubleOrComplex = nda::is_double_or_complex_v<S>;
 
  template <typename T, template <typename...> class TMPLT>
  concept InstantiationOf = nda::is_instantiation_of_v<TMPLT, T>;
 
  namespace mem {
 
    // Forward declarations.
    struct blk_t;
    enum class AddressSpace;
 
    template <typename A>
    concept Allocator = requires(A &a) {
      { a.allocate(size_t{}) } noexcept -> std::same_as<blk_t>;
      { a.allocate_zero(size_t{}) } noexcept -> std::same_as<blk_t>;
      { a.deallocate(std::declval<blk_t>()) } noexcept;
      { A::address_space } -> std::same_as<AddressSpace const &>;
    };
 
    template <typename H, typename T = typename std::remove_cvref_t<H>::value_type>
    concept Handle = requires(H const &h) {
      requires std::is_same_v<typename std::remove_cvref_t<H>::value_type, T>;
      { h.is_null() } noexcept -> std::same_as<bool>;
      { h.data() } noexcept -> std::same_as<T *>;
      { H::address_space } -> std::same_as<AddressSpace const &>;
    };
 
    template <typename H, typename T = typename std::remove_cvref_t<H>::value_type>
    concept OwningHandle = Handle<H, T> and requires(H const &h) {
      requires not std::is_const_v<typename std::remove_cvref_t<H>::value_type>;
      { h.size() } noexcept -> std::same_as<long>;
    };
 
  } // namespace mem
 
  template <typename A>
  concept Array = requires(A const &a) {
    { a.shape() } -> StdArrayOfLong;
    { a.size() } -> std::same_as<long>;
    requires CallableWithLongs<A, get_rank<A>>;
  };
 
  template <typename A, typename A_t = std::remove_cvref_t<A>>
  concept MemoryArray = Array<A> && requires(A &a) {
    typename A_t::storage_t;
    requires mem::Handle<typename A_t::storage_t>;
    typename A_t::value_type;
    {
      a.data()
    } -> std::same_as<std::conditional_t<std::is_const_v<std::remove_reference_t<A>> || std::is_const_v<typename A_t::value_type>,
                                         const get_value_t<A>, get_value_t<A>> *>;
    { a.indexmap().strides() } -> StdArrayOfLong;
  };
 
  template <typename A, int R>
  concept ArrayOfRank = Array<A> and (get_rank<A> == R);
 
  template <typename A, int R>
  concept MemoryArrayOfRank = MemoryArray<A> and (get_rank<A> == R);
 
  template <typename AS>
  concept ArrayOrScalar = Array<AS> or Scalar<AS>;
 
  template <typename M>
  concept Matrix = ArrayOfRank<M, 2>;
 
  template <typename V>
  concept Vector = ArrayOfRank<V, 1>;
 
  template <typename M>
  concept MemoryMatrix = MemoryArrayOfRank<M, 2>;
 
  template <typename V>
  concept MemoryVector = MemoryArrayOfRank<V, 1>;
 
  template <typename A, typename B>
  concept ArrayInitializer = requires(A const &a) {
    { a.shape() } -> StdArrayOfLong;
    typename std::remove_cvref_t<A>::value_type;
    requires MemoryArray<B> && requires(B &b) { a.invoke(b); }; // FIXME not perfect: it should accept any layout ??
  };
 
  // FIXME : We should not need this ... Only used once...
  template <typename A, typename U>
  concept HasValueTypeConstructibleFrom = Array<A> and (std::is_constructible_v<U, get_value_t<A>>);
 
} // namespace nda