declarations.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 "./accessors.hpp"
#include "./concepts.hpp"
#include "./layout/idx_map.hpp"
#include "./layout/permutation.hpp"
#include "./layout/policies.hpp"
#include "./mem/address_space.hpp"
#include "./mem/policies.hpp"
#include "./traits.hpp"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <stdexcept>
#include <type_traits>
 
namespace nda {

  // Forward declarations.
  template <int Rank, uint64_t StaticExtents, uint64_t StrideOrder, layout_prop_e LayoutProp>
  class idx_map;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra, typename ContainerPolicy>
  class basic_array;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra = 'A',
            typename AccessorPolicy = nda::default_accessor, //, nda::no_alias_accessor, //,
            typename OwningPolicy   = nda::borrowed<>>
  class basic_array_view;
 
  template <char OP, Array A>
  struct expr_unary;
 
  template <char OP, ArrayOrScalar L, ArrayOrScalar R>
  struct expr;


  template <typename ValueType, int Rank, typename Layout = C_layout, typename ContainerPolicy = heap<>>
  using array = basic_array<ValueType, Rank, Layout, 'A', ContainerPolicy>;

  template <typename ValueType, int Rank, typename Layout = C_stride_layout>
  using array_view = basic_array_view<ValueType, Rank, Layout, 'A', default_accessor, borrowed<>>;

  template <typename ValueType, int Rank, typename Layout = C_stride_layout>
  using array_const_view = basic_array_view<ValueType const, Rank, Layout, 'A', default_accessor, borrowed<>>;

  template <typename ValueType, int Rank, typename Layout = C_layout>
    requires(has_contiguous(Layout::template mapping<Rank>::layout_prop))
  using array_contiguous_view = basic_array_view<ValueType, Rank, Layout, 'A', default_accessor, borrowed<>>;

  template <typename ValueType, int Rank, typename Layout = C_layout>
    requires(has_contiguous(Layout::template mapping<Rank>::layout_prop))
  using array_contiguous_const_view = basic_array_view<ValueType const, Rank, Layout, 'A', default_accessor, borrowed<>>;

  template <typename ValueType, typename Layout = C_layout, typename ContainerPolicy = heap<>>
  using matrix = basic_array<ValueType, 2, Layout, 'M', ContainerPolicy>;

  template <typename ValueType, typename Layout = C_stride_layout>
  using matrix_view = basic_array_view<ValueType, 2, Layout, 'M', default_accessor, borrowed<>>;

  template <typename ValueType, typename Layout = C_stride_layout>
  using matrix_const_view = basic_array_view<ValueType const, 2, Layout, 'M', default_accessor, borrowed<>>;

  template <typename ValueType, typename ContainerPolicy = heap<>>
  using vector = basic_array<ValueType, 1, C_layout, 'V', ContainerPolicy>;

  template <typename ValueType, typename Layout = C_stride_layout>
  using vector_view = basic_array_view<ValueType, 1, Layout, 'V', default_accessor, borrowed<>>;

  template <typename ValueType, typename Layout = C_stride_layout>
  using vector_const_view = basic_array_view<ValueType const, 1, Layout, 'V', default_accessor, borrowed<>>;

  template <typename... Is>
  constexpr uint64_t static_extents(int i0, Is... is) {
    if (i0 > 15) throw std::runtime_error("Error in nda::static_extents: Only 16 dimensions are supported!");
    return encode(std::array<int, sizeof...(Is) + 1>{i0, static_cast<int>(is)...});
  }

  template <typename ValueType, int N0, int... Ns>
  using stack_array =
     nda::basic_array<ValueType, 1 + sizeof...(Ns),
                      nda::basic_layout<nda::static_extents(N0, Ns...), nda::C_stride_order<1 + sizeof...(Ns)>, nda::layout_prop_e::contiguous>, 'A',
                      nda::stack<N0 *(Ns *... * 1)>>;

  template <typename ValueType, int N, int M>
  using stack_matrix =
     nda::basic_array<ValueType, 2, nda::basic_layout<nda::static_extents(N, M), nda::C_stride_order<2>, nda::layout_prop_e::contiguous>, 'M',
                      nda::stack<static_cast<size_t>(N *M)>>;

  template <typename ValueType, int N>
  using stack_vector =
     nda::basic_array<ValueType, 1, nda::basic_layout<nda::static_extents(N), nda::C_stride_order<1>, nda::layout_prop_e::contiguous>, 'V',
                      nda::stack<N>>;

  template <typename ValueType, int Rank, typename Layout = C_layout>
  using cuarray = basic_array<ValueType, Rank, Layout, 'A', heap<mem::Device>>;

  template <typename ValueType, int Rank, typename Layout = C_stride_layout>
  using cuarray_view = basic_array_view<ValueType, Rank, Layout, 'A', default_accessor, borrowed<mem::Device>>;

  template <typename ValueType, int Rank, typename Layout = C_stride_layout>
  using cuarray_const_view = basic_array_view<ValueType const, Rank, Layout, 'A', default_accessor, borrowed<mem::Device>>;

  template <typename ValueType, typename Layout = C_layout, typename ContainerPolicy = heap<mem::Device>>
  using cumatrix = basic_array<ValueType, 2, Layout, 'M', ContainerPolicy>;

  template <typename ValueType, typename Layout = C_stride_layout>
  using cumatrix_view = basic_array_view<ValueType, 2, Layout, 'M', default_accessor, borrowed<mem::Device>>;

  template <typename ValueType, typename Layout = C_stride_layout>
  using cumatrix_const_view = basic_array_view<ValueType const, 2, Layout, 'M', default_accessor, borrowed<mem::Device>>;

  template <typename ValueType>
  using cuvector = basic_array<ValueType, 1, C_layout, 'V', heap<mem::Device>>;

  template <typename ValueType, typename Layout = C_stride_layout>
  using cuvector_view = basic_array_view<ValueType, 1, Layout, 'V', default_accessor, borrowed<mem::Device>>;

  template <typename ValueType, typename Layout = C_stride_layout>
  using cuvector_const_view = basic_array_view<ValueType const, 1, Layout, 'V', default_accessor, borrowed<mem::Device>>;



  template <typename ValueType, int Rank, typename Layout, char Algebra, typename ContainerPolicy>
  inline constexpr bool is_regular_v<basic_array<ValueType, Rank, Layout, Algebra, ContainerPolicy>> = true;

  template <typename ValueType, int Rank, typename Layout, char Algebra, typename AccessorPolicy, typename OwningPolicy>
  inline constexpr bool is_view_v<basic_array_view<ValueType, Rank, Layout, Algebra, AccessorPolicy, OwningPolicy>> = true;

  template <typename ValueType, int Rank, typename Layout, char Algebra, typename ContainerPolicy>
  inline constexpr char get_algebra<basic_array<ValueType, Rank, Layout, Algebra, ContainerPolicy>> = Algebra;

  template <typename ValueType, int Rank, typename Layout, char Algebra, typename AccessorPolicy, typename OwningPolicy>
  inline constexpr char get_algebra<basic_array_view<ValueType, Rank, Layout, Algebra, AccessorPolicy, OwningPolicy>> = Algebra;

  template <typename ValueType, int Rank, typename Layout, char Algebra, typename ContainerPolicy>
  inline constexpr layout_info_t get_layout_info<basic_array<ValueType, Rank, Layout, Algebra, ContainerPolicy>> =
     basic_array<ValueType, Rank, Layout, Algebra, ContainerPolicy>::layout_t::layout_info;

  template <typename ValueType, int Rank, typename Layout, char Algebra, typename AccessorPolicy, typename OwningPolicy>
  inline constexpr layout_info_t get_layout_info<basic_array_view<ValueType, Rank, Layout, Algebra, AccessorPolicy, OwningPolicy>> =
     basic_array_view<ValueType, Rank, Layout, Algebra, AccessorPolicy, OwningPolicy>::layout_t::layout_info;

  template <typename T, typename T2 = std::remove_reference_t<T> /* Keep this: Fix for gcc11 bug */>
  using get_view_t = std::remove_reference_t<decltype(basic_array_view{std::declval<T>()})>;

  template <typename T, typename T2 = std::remove_reference_t<T> /* Keep this: Fix for gcc11 bug */>
  using get_regular_t = decltype(basic_array{std::declval<T>()});

  template <typename T, typename RT = get_regular_t<T>>
  using get_regular_host_t =
     std::conditional_t<mem::on_host<RT>, RT,
                        basic_array<get_value_t<RT>, get_rank<RT>, get_contiguous_layout_policy<get_rank<RT>, get_layout_info<RT>.stride_order>,
                                    get_algebra<RT>, heap<mem::Host>>>;

  template <typename T, typename RT = get_regular_t<T>>
  using get_regular_device_t =
     std::conditional_t<mem::on_device<RT>, RT,
                        basic_array<get_value_t<RT>, get_rank<RT>, get_contiguous_layout_policy<get_rank<RT>, get_layout_info<RT>.stride_order>,
                                    get_algebra<RT>, heap<mem::Device>>>;

  template <typename T, typename RT = get_regular_t<T>>
  using get_regular_unified_t =
     std::conditional_t<mem::on_unified<RT>, RT,
                        basic_array<get_value_t<RT>, get_rank<RT>, get_contiguous_layout_policy<get_rank<RT>, get_layout_info<RT>.stride_order>,
                                    get_algebra<RT>, heap<mem::Unified>>>;

  template <char OP, Array A>
  inline constexpr char get_algebra<expr_unary<OP, A>> = get_algebra<A>;

  template <char OP, Array A>
  inline constexpr layout_info_t get_layout_info<expr_unary<OP, A>> = get_layout_info<A>;

  template <char OP, typename L, typename R>
  inline constexpr char get_algebra<expr<OP, L, R>> = expr<OP, L, R>::algebra;

  template <char OP, typename L, typename R>
  inline constexpr layout_info_t get_layout_info<expr<OP, L, R>> = expr<OP, L, R>::compute_layout_info();

 
} // namespace nda