traits.hpp

Go to the documentation of this file.

// Copyright (c) 2019--present, The Simons Foundation
// This file is part of TRIQS/nda and is licensed under the Apache License, Version 2.0.
// SPDX-License-Identifier: Apache-2.0
// See LICENSE in the root of this distribution for details.

 
#pragma once
 
#include <complex>
#include <cstdint>
#include <ranges>
#include <type_traits>
#include <utility>
#include <tuple>
 
namespace nda {


  template <template <typename...> class TMPLT, typename T>
  struct is_instantiation_of : std::false_type {};
 
  // Specialization of nda::is_instantiation_of for when it evaluates to true.
  template <template <typename...> class TMPLT, typename... U>
  struct is_instantiation_of<TMPLT, TMPLT<U...>> : std::true_type {};

  template <template <typename...> class TMPLT, typename T>
  inline constexpr bool is_instantiation_of_v = is_instantiation_of<TMPLT, std::remove_cvref_t<T>>::value;

  template <typename T, typename... Ts>
  static constexpr bool is_any_of = (std::is_same_v<Ts, T> or ... or false);

  template <typename... Ts>
  static constexpr bool always_true = true;

  template <typename... Ts>
  static constexpr bool always_false = false;

  template <typename T>
  inline constexpr bool is_complex_v = is_instantiation_of_v<std::complex, T>;

  template <typename S>
  inline constexpr bool is_scalar_v = std::is_arithmetic_v<std::remove_cvref_t<S>> or is_complex_v<S>;

  template <typename S>
  inline constexpr bool is_scalar_or_convertible_v = is_scalar_v<S> or std::is_constructible_v<std::complex<double>, S>;

  template <typename S, typename A>
  inline constexpr bool is_scalar_for_v =
     (is_scalar_v<typename A::value_type> ? is_scalar_or_convertible_v<S> : std::is_same_v<S, typename A::value_type>);

  template <typename T>
  inline constexpr bool is_double_or_complex_v = is_complex_v<T> or std::is_same_v<double, std::remove_cvref_t<T>>;

  template <typename T>
  inline constexpr bool is_blas_lapack_v =
     std::is_same_v<double, std::remove_cvref_t<T>> or std::is_same_v<std::complex<double>, std::remove_cvref_t<T>>
     or std::is_same_v<float, std::remove_cvref_t<T>> or std::is_same_v<std::complex<float>, std::remove_cvref_t<T>>;

  template <typename T>
  struct remove_complex {
    using type = T;
  };
 
  // Specialization of nda::remove_complex for std::complex types.
  template <typename T>
  struct remove_complex<std::complex<T>> {
    using type = T;
  };
 
  // Specialization of nda::remove_complex for cvref types.
  template <typename T>
    requires(!std::is_same_v<T, std::remove_cvref_t<T>>)
  struct remove_complex<T> : remove_complex<std::remove_cvref_t<T>> {};

  template <typename T>
  using remove_complex_t = typename remove_complex<T>::type;



  template <typename A>
  inline constexpr char get_algebra = 'N';
 
  // Specialization of nda::get_algebra for cvref types.
  template <typename A>
    requires(!std::is_same_v<A, std::remove_cvref_t<A>>)
  inline constexpr char get_algebra<A> = get_algebra<std::remove_cvref_t<A>>;

  template <typename A>
    requires(std::ranges::contiguous_range<A> or requires { std::declval<A const>().shape(); })
  constexpr int get_rank = []() {
    if constexpr (std::ranges::contiguous_range<A>)
      return 1;
    else
      return std::tuple_size_v<std::remove_cvref_t<decltype(std::declval<A const>().shape())>>;
  }();

  template <typename A>
  inline constexpr bool is_expression = false;
 
  // Specialization of nda::is_expression for cvref types.
  template <typename A>
    requires(!std::is_same_v<A, std::remove_cvref_t<A>>)
  inline constexpr bool is_expression<A> = is_expression<std::remove_cvref_t<A>>;

  template <typename A>
  inline constexpr bool is_regular_v = false;
 
  // Specialization of nda::is_regular_v for cvref types.
  template <typename A>
    requires(!std::is_same_v<A, std::remove_cvref_t<A>>)
  inline constexpr bool is_regular_v<A> = is_regular_v<std::remove_cvref_t<A>>;

  template <typename A>
  inline constexpr bool is_view_v = false;
 
  // Specialization of nda::is_view_v for cvref types.
  template <typename A>
    requires(!std::is_same_v<A, std::remove_cvref_t<A>>)
  inline constexpr bool is_view_v<A> = is_view_v<std::remove_cvref_t<A>>;

  template <typename A>
  inline constexpr bool is_regular_or_view_v = is_regular_v<A> or is_view_v<A>;

  template <typename A>
  inline constexpr bool is_matrix_or_view_v = is_regular_or_view_v<A> and (get_algebra<A> == 'M') and (get_rank<A> == 2);

  template <typename A>
    requires(is_scalar_v<A> or requires { std::declval<A const>().shape(); })
  decltype(auto) get_first_element(A &&a) {
    if constexpr (is_scalar_v<A>) {
      return std::forward<A>(a);
    } else {
      return [&a]<auto... Is>(std::index_sequence<Is...>) -> decltype(auto) {
        return std::forward<A>(a)((0 * Is)...); // repeat 0 sizeof...(Is) times
      }(std::make_index_sequence<get_rank<A>>{});
    }
  }

  template <typename A>
  using get_value_t = std::decay_t<decltype(get_first_element(std::declval<A const>()))>;

  template <typename A>
    requires(is_complex_v<get_value_t<A>> or std::is_floating_point_v<get_value_t<A>>)
  using get_fp_t = typename remove_complex<get_value_t<A>>::type;

  template <typename A0, typename... As>
  inline constexpr bool have_same_value_type_v = (std::is_same_v<get_value_t<A0>, get_value_t<As>> and ... and true);

  template <typename A0, typename... As>
  inline constexpr bool have_same_rank_v = ((get_rank<A0> == get_rank<As>) and ... and true);



  enum class layout_prop_e : uint64_t {
    none                   = 0x0,
    strided_1d             = 0x1,
    smallest_stride_is_one = 0x2,
    contiguous             = strided_1d | smallest_stride_is_one
  };

  inline constexpr bool layout_property_compatible(layout_prop_e from, layout_prop_e to) {
    if (from == layout_prop_e::contiguous) return true;
    return ((to == layout_prop_e::none) or (to == from));
  }

  constexpr layout_prop_e operator|(layout_prop_e lhs, layout_prop_e rhs) { return layout_prop_e(uint64_t(lhs) | uint64_t(rhs)); }

  constexpr layout_prop_e operator&(layout_prop_e lhs, layout_prop_e rhs) { return layout_prop_e{uint64_t(lhs) & uint64_t(rhs)}; }

  inline constexpr bool has_strided_1d(layout_prop_e lp) { return uint64_t(lp) & uint64_t(layout_prop_e::strided_1d); }

  inline constexpr bool has_smallest_stride_is_one(layout_prop_e lp) { return uint64_t(lp) & uint64_t(layout_prop_e::smallest_stride_is_one); }

  inline constexpr bool has_contiguous(layout_prop_e lp) { return has_strided_1d(lp) and has_smallest_stride_is_one(lp); }
 
  // FIXME : I need a NONE for stride_order. For the scalars ...
  struct layout_info_t {
    uint64_t stride_order = 0;

    layout_prop_e prop = layout_prop_e::none;
  };

  constexpr layout_info_t operator&(layout_info_t lhs, layout_info_t rhs) {
    if (lhs.stride_order == rhs.stride_order)
      return layout_info_t{lhs.stride_order, layout_prop_e(uint64_t(lhs.prop) & uint64_t(rhs.prop))};
    else
      return layout_info_t{uint64_t(-1), layout_prop_e::none};
  }

  template <typename A>
  inline constexpr layout_info_t get_layout_info = layout_info_t{};
 
  // Specialization of nda::get_layout_info for cvref types.
  template <typename A>
    requires(!std::is_same_v<A, std::remove_cvref_t<A>>)
  inline constexpr layout_info_t get_layout_info<A> = get_layout_info<std::remove_cvref_t<A>>;

  template <typename A>
  constexpr bool has_contiguous_layout = (has_contiguous(get_layout_info<A>.prop));

  template <typename A>
  constexpr bool has_layout_strided_1d = (has_strided_1d(get_layout_info<A>.prop));

  template <typename A>
  constexpr bool has_layout_smallest_stride_is_one = (has_smallest_stride_is_one(get_layout_info<A>.prop));

  struct _linear_index_t {
    long value;
  };

 
} // namespace nda