mdspan constructors & deduction guides

mdspan-test.cpp

#include <cassert>
#include <array>
#include <span>
#include <type_traits>
#if 0
#include <mdspan>
#else
#include <https://raw.githubusercontent.com/kokkos/mdspan/single-header/mdspan.hpp>
#endif
using namespace std;

template <int N>
constexpr auto c_ = integral_constant<int, N>{};

int main()
{
  int* ptr = new int[6];
  using dimNx3 = mdspan<int, extents<size_t, dynamic_extent, 3>>;
  using dimNx2x3 = mdspan<int, extents<size_t, dynamic_extent, 2, 3>>;
// Constructor
// http://eel.is/c++draft/mdspan.mdspan.cons
  {// mdspan()
    dimNx3 m{};
    static_assert(m.rank()==2 && m.rank_dynamic()==1);
    assert(m.extent(0)==0 && m.extent(1)==3);
  }
  {// mdspan(data_handle_type, OtherIndexTypes...)
    dimNx2x3 ma{ptr, 1, 2, 3};  // N==rank()
    static_assert(ma.rank()==3 && ma.rank_dynamic()==1);
    assert(ma.extent(0)==1 && ma.extent(1)==2 && ma.extent(2)==3);
    dimNx2x3 mb{ptr, 1};  // N==rank_­dynamic()
    static_assert(mb.rank()==3 && mb.rank_dynamic()==1);
    assert(mb.extent(0)==1 && mb.extent(1)==2 && mb.extent(2)==3);
  }
  {// mdspan(data_handle_type, span<OtherIndexType, N>);
    int exts[] = {1, 2, 3};
    dimNx2x3 ma{ptr, std::span{exts}};  // N==rank()
    static_assert(ma.rank()==3 && ma.rank_dynamic()==1);
    assert(ma.extent(0)==1 && ma.extent(1)==2 && ma.extent(2)==3);
    int ext = 1;
    dimNx2x3 mb{ptr, std::span<int, 1>{&ext, 1}};  // N==rank_­dynamic()
    static_assert(mb.rank()==3 && mb.rank_dynamic()==1);
    assert(mb.extent(0)==1 && mb.extent(1)==2 && mb.extent(2)==3);
  }
  {// mdspan(data_handle_type, const array<OtherIndexType, N>&);
    dimNx2x3 ma{ptr, std::array{1, 2, 3}};  // N==rank()
    static_assert(ma.rank()==3 && ma.rank_dynamic()==1);
    assert(ma.extent(0)==1 && ma.extent(1)==2 && ma.extent(2)==3);
    dimNx2x3 mb{ptr, std::array{1}};  // N==rank_­dynamic()
    static_assert(mb.rank()==3 && mb.rank_dynamic()==1);
    assert(mb.extent(0)==1 && mb.extent(1)==2 && mb.extent(2)==3);
  }
  {// mdspan(data_handle_type, const extents_type&);
    dimNx3 m{ptr, dimNx3::extents_type{2}};
    static_assert(m.rank()==2 && m.rank_dynamic()==1);
    assert(m.extent(0)==2 && m.extent(1)==3);
  }
  {// mdspan(data_handle_type, const mapping_type&);
    dimNx3 m{ptr, dimNx3::mapping_type{}};
    static_assert(m.rank()==2 && m.rank_dynamic()==1);
    assert(m.extent(0)==0 && m.extent(1)==3);
  }
  {// mdspan(data_handle_type, const mapping_type&, const accessor_type&);
    dimNx3 m{ptr, dimNx3::mapping_type{}, dimNx3::accessor_type{}};
    static_assert(m.rank()==2 && m.rank_dynamic()==1);
    assert(m.extent(0)==0 && m.extent(1)==3);
  }
  {// mdspan(const mdspan<...>&);
    using src_t = mdspan<int, extents<size_t, 2, 3>, layout_right>;
    using dst_t = mdspan<int, dextents<size_t, 2>, layout_stride>;
    src_t src{ptr};
    dst_t m{src};
    static_assert(m.rank()==2 && m.rank_dynamic()==2);
    assert(m.extent(0)==2 && m.extent(1)==3);
  }
// Deduction Guides
// http://eel.is/c++draft/mdspan.mdspan.overview
  {// mdspan(CArray&)
    int array[6] = {};
    mdspan m{array};
    static_assert(m.rank()==1 && m.rank_dynamic()==0);
    static_assert(m.extent(0)==6);
  }
  {// mdspan(Pointer&&)
    mdspan m{ptr};
    static_assert(m.rank()==0);
  }
  {// mdspan(ElementType*, Integrals...)
    mdspan m{ptr, 2, 3};
    static_assert(m.rank()==2 && m.rank_dynamic()==2);
    assert(m.extent(0)==2 && m.extent(1)==3);
  }
#if 0
  {// mdspan(ElementType*, Integrals...) [C++26; P3029R1]
    mdspan m{ptr, c_<2>, c_<3>};
    static_assert(m.rank()==2 && m.rank_dynamic()==0);
    assert(m.extent(0)==2 && m.extent(1)==3);
  }
#endif
  {// mdspan(ElementType*, span<OtherIndexType, N>)
    int exts[] = {2, 3};
    mdspan m{ptr, std::span{exts}};
    static_assert(m.rank()==2 && m.rank_dynamic()==2);
    assert(m.extent(0)==2 && m.extent(1)==3);
  }
  {// mdspan(ElementType*, const array<OtherIndexType, N>&)
    mdspan m{ptr, std::array{2, 3}};
    static_assert(m.rank()==2 && m.rank_dynamic()==2);
    assert(m.extent(0)==2 && m.extent(1)==3);
  }
  {// mdspan(ElementType*, const extents<IndexType, ExtentsPack...>&)
    mdspan m{ptr, extents<size_t, 2, 3>{}};
    static_assert(m.rank()==2 && m.rank_dynamic()==0);
    static_assert(m.extent(0)==2 && m.extent(1)==3);
  }
  {// mdspan(ElementType*, const MappingType&)
    using mapping = layout_left::mapping<extents<size_t, 2, 3>>;
    mdspan m{ptr, mapping{}};
    static_assert(m.rank()==2 && m.rank_dynamic()==0);
    static_assert(m.extent(0)==2 && m.extent(1)==3);
  }
  {// mdspan(const typename AccessorType::data_handle_type&, const MappingType&, const AccessorType&)
    using mapping = layout_left::mapping<extents<size_t, 2, 3>>;
    mdspan m{ptr, mapping{}, default_accessor<int>{}};
    static_assert(m.rank()==2 && m.rank_dynamic()==0);
    static_assert(m.extent(0)==2 && m.extent(1)==3);
  }
}