utils/NumArray.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* NumArray.h                                                  (C) 2000-2025 */
/*                                                                           */
/* Tableaux multi-dimensionnel pour les types numériques.                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_NUMARRAY_H
#define ARCANE_UTILS_NUMARRAY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/MDSpan.h"
#include "arcane/utils/MDDim.h"
#include "arcane/utils/NumArrayContainer.h"
#include "arcane/utils/String.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T>
concept NumArrayDataTypeConcept = std::is_trivially_copyable_v<T>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename DataType, typename Extents, typename LayoutPolicy>
class NumArray
: private impl::NumArrayBaseCommon
{
 public:
 
#if !defined(ARCANE_NO_CONCEPT_FOR_NUMARRAY)
  static_assert(NumArrayDataTypeConcept<DataType>, "concept 'NumArrayDataTypeConcept' is not fullfilled");
#endif
 
 public:
 
  using ExtentsType = Extents;
  using ThatClass = NumArray<DataType, Extents, LayoutPolicy>;
  using DynamicDimsType = typename ExtentsType::DynamicDimsType;
  using ConstMDSpanType = MDSpan<const DataType, ExtentsType, LayoutPolicy>;
  using MDSpanType = MDSpan<DataType, ExtentsType, LayoutPolicy>;
  using ArrayWrapper = impl::NumArrayContainer<DataType>;
  using ArrayBoundsIndexType = typename MDSpanType::ArrayBoundsIndexType;
  using value_type = DataType;
  using LayoutPolicyType = LayoutPolicy;
 
  using ConstSpanType ARCANE_DEPRECATED_REASON("Use 'ConstMDSpanType' instead") = ConstMDSpanType;
  using SpanType ARCANE_DEPRECATED_REASON("Use 'MDSpanType' instead") = MDSpanType;
 
 public:

  static constexpr int rank() { return Extents::rank(); }
 
 public:

  NumArray()
  {
    _resizeInit();
  }

  explicit NumArray(DynamicDimsType extents)
  {
    resize(extents);
  }

  NumArray(const DynamicDimsType& extents, eMemoryRessource r)
  : m_data(r)
  {
    resize(extents);
  }

  explicit NumArray(eMemoryRessource r)
  : m_data(r)
  {
    _resizeInit();
  }

  NumArray(Int32 dim1_size, Int32 dim2_size,
           Int32 dim3_size, Int32 dim4_size) requires(Extents::nb_dynamic == 4)
  : ThatClass(DynamicDimsType(dim1_size, dim2_size, dim3_size, dim4_size))
  {
  }

  NumArray(Int32 dim1_size, Int32 dim2_size,
           Int32 dim3_size, Int32 dim4_size, eMemoryRessource r) requires(Extents::nb_dynamic == 4)
  : ThatClass(DynamicDimsType(dim1_size, dim2_size, dim3_size, dim4_size), r)
  {
  }

  NumArray(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size) requires(Extents::nb_dynamic == 3)
  : ThatClass(DynamicDimsType(dim1_size, dim2_size, dim3_size))
  {
  }

  NumArray(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, eMemoryRessource r) requires(Extents::nb_dynamic == 3)
  : ThatClass(DynamicDimsType(dim1_size, dim2_size, dim3_size), r)
  {
  }

  NumArray(Int32 dim1_size, Int32 dim2_size) requires(Extents::nb_dynamic == 2)
  : ThatClass(DynamicDimsType(dim1_size, dim2_size))
  {
  }

  NumArray(Int32 dim1_size, Int32 dim2_size, eMemoryRessource r) requires(Extents::nb_dynamic == 2)
  : ThatClass(DynamicDimsType(dim1_size, dim2_size), r)
  {
  }

  explicit NumArray(Int32 dim1_size) requires(Extents::nb_dynamic == 1)
  : ThatClass(DynamicDimsType(dim1_size))
  {
  }

  NumArray(Int32 dim1_size, eMemoryRessource r) requires(Extents::nb_dynamic == 1)
  : ThatClass(DynamicDimsType(dim1_size), r)
  {
  }

  NumArray(Int32 dim1_size, Int32 dim2_size, std::initializer_list<DataType> alist)
  requires(Extents::is_full_dynamic() && Extents::rank() == 2)
  : NumArray(dim1_size, dim2_size)
  {
    this->m_data.copyInitializerList(alist);
  }

  NumArray(Int32 dim1_size, std::initializer_list<DataType> alist)
  requires(Extents::isDynamic1D())
  : NumArray(dim1_size)
  {
    this->m_data.copyInitializerList(alist);
  }

  NumArray(SmallSpan<const DataType> v)
  requires(Extents::isDynamic1D())
  : NumArray(v.size())
  {
    this->m_data.copy(v);
  }

  NumArray(Span<const DataType> v)
  requires(Extents::isDynamic1D())
  : NumArray(arcaneCheckArraySize(v.size()))
  {
    this->m_data.copy(v);
  }
 
  NumArray(const ThatClass& rhs)
  : m_span(rhs.m_span)
  , m_data(rhs.m_data)
  , m_total_nb_element(rhs.m_total_nb_element)
  {
    _updateSpanPointerFromData();
  }
 
  NumArray(ThatClass&& rhs)
  : m_span(rhs.m_span)
  , m_data(std::move(rhs.m_data))
  , m_total_nb_element(rhs.m_total_nb_element)
  {
  }
 
  ThatClass& operator=(ThatClass&&) = default;

  ThatClass& operator=(const ThatClass& rhs)
  {
    if (&rhs == this)
      return (*this);
    eMemoryRessource r = memoryRessource();
    eMemoryRessource rhs_r = rhs.memoryRessource();
    if (rhs_r != r)
      m_data = ArrayWrapper(rhs_r);
    this->copy(rhs);
    return (*this);
  }

  void swap(ThatClass& rhs)
  {
    m_data.swap(rhs.m_data);
    std::swap(m_span, rhs.m_span);
    std::swap(m_total_nb_element, rhs.m_total_nb_element);
  }
 
 public:

  constexpr Int64 totalNbElement() const { return m_total_nb_element; }
  static constexpr Int32 nbDimension() { return Extents::rank(); }
  ArrayExtents<Extents> extents() const { return m_span.extents(); }
  ArrayExtentsWithOffset<Extents, LayoutPolicy> extentsWithOffset() const
  {
    return m_span.extentsWithOffset();
  }
  Int64 capacity() const { return m_data.capacity(); }
  eMemoryRessource memoryRessource() const { return m_data.memoryRessource(); }
  Span<std::byte> bytes() { return asWritableBytes(to1DSpan()); }
  Span<const std::byte> bytes() const { return asBytes(to1DSpan()); }

  IMemoryAllocator* memoryAllocator() const { return m_data.allocator(); }

  void setDebugName(const String& str) { m_data.setDebugName(str); }

  String debugName() { return m_data.debugName(); }
 
 public:

  constexpr Int32 dim1Size() const requires(Extents::rank() >= 1) { return m_span.extent0(); }
  constexpr Int32 dim2Size() const requires(Extents::rank() >= 2) { return m_span.extent1(); }
  constexpr Int32 dim3Size() const requires(Extents::rank() >= 3) { return m_span.extent2(); }
  constexpr Int32 dim4Size() const requires(Extents::rank() >= 4) { return m_span.extent3(); }

  constexpr Int32 extent0() const requires(Extents::rank() >= 1) { return m_span.extent0(); }
  constexpr Int32 extent1() const requires(Extents::rank() >= 2) { return m_span.extent1(); }
  constexpr Int32 extent2() const requires(Extents::rank() >= 3) { return m_span.extent2(); }
  constexpr Int32 extent3() const requires(Extents::rank() >= 4) { return m_span.extent3(); }
 
 public:

  void resize(Int32 dim1_size) requires(Extents::nb_dynamic == 1)
  {
    m_span.m_extents = DynamicDimsType(dim1_size);
    _resize();
  }
 
  // TODO: Rendre obsolète (juin 2025)
  void resize(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, Int32 dim4_size) requires(Extents::nb_dynamic == 4)
  {
    this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size, dim3_size, dim4_size));
  }
 
  // TODO: Rendre obsolète (juin 2025)
  void resize(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size) requires(Extents::nb_dynamic == 3)
  {
    this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size, dim3_size));
  }
 
  // TODO: Rendre obsolète (juin 2025)
  void resize(Int32 dim1_size, Int32 dim2_size) requires(Extents::nb_dynamic == 2)
  {
    this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size));
  }


  void resizeDestructive(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size, Int32 dim4_size) requires(Extents::nb_dynamic == 4)
  {
    this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size, dim3_size, dim4_size));
  }

  void resizeDestructive(Int32 dim1_size, Int32 dim2_size, Int32 dim3_size) requires(Extents::nb_dynamic == 3)
  {
    this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size, dim3_size));
  }

  void resizeDestructive(Int32 dim1_size, Int32 dim2_size) requires(Extents::nb_dynamic == 2)
  {
    this->resizeDestructive(DynamicDimsType(dim1_size, dim2_size));
  }

  void resizeDestructive(Int32 dim1_size) requires(Extents::nb_dynamic == 1)
  {
    this->resizeDestructive(DynamicDimsType(dim1_size));
  }
 
  // TODO: Rendre obsolète (juin 2025)
  void resize(const DynamicDimsType& dims)
  {
    resizeDestructive(dims);
  }

  void resizeDestructive(const DynamicDimsType& dims)
  {
    m_span.m_extents = dims;
    _resize();
  }

 
 public:

  void fill(const DataType& v)
  {
    fillHost(v);
  }

  void fill(const DataType& v, SmallSpan<const Int32> indexes, const RunQueue* queue)
  {
    m_data.fill(v, indexes, queue);
  }

  void fill(const DataType& v, SmallSpan<const Int32> indexes, const RunQueue& queue)
  {
    m_data.fill(v, indexes, &queue);
  }

  void fill(const DataType& v, const RunQueue* queue)
  {
    m_data.fill(v, queue);
  }

  void fill(const DataType& v, const RunQueue& queue)
  {
    m_data.fill(v, &queue);
  }

  void fillHost(const DataType& v)
  {
    _checkHost(memoryRessource());
    m_data.fill(v);
  }
 
 public:

  void copy(SmallSpan<const DataType> rhs) requires(Extents::isDynamic1D())
  {
    copy(rhs, nullptr);
  }

  void copy(ConstMDSpanType rhs) { copy(rhs, nullptr); }

  void copy(const ThatClass& rhs) { copy(rhs, nullptr); }

  void copy(SmallSpan<const DataType> rhs, const RunQueue* queue) requires(Extents::isDynamic1D())
  {
    _resizeAndCopy(ConstMDSpanType(rhs), eMemoryRessource::Unknown, queue);
  }

  void copy(ConstMDSpanType rhs, const RunQueue* queue)
  {
    _resizeAndCopy(rhs, eMemoryRessource::Unknown, queue);
  }

  void copy(SmallSpan<const DataType> rhs, const RunQueue& queue) requires(Extents::isDynamic1D())
  {
    _resizeAndCopy(ConstMDSpanType(rhs), eMemoryRessource::Unknown, &queue);
  }

  void copy(ConstMDSpanType rhs, const RunQueue& queue)
  {
    _resizeAndCopy(rhs, eMemoryRessource::Unknown, &queue);
  }

  void copy(const ThatClass& rhs, const RunQueue* queue)
  {
    _resizeAndCopy(rhs.constMDSpan(), rhs.memoryRessource(), queue);
  }

  void copy(const ThatClass& rhs, const RunQueue& queue)
  {
    _resizeAndCopy(rhs.constMDSpan(), rhs.memoryRessource(), &queue);
  }
 
 public:

  DataType& operator[](Int32 i) requires(Extents::rank() == 1) { return m_span(i); }
  DataType operator[](Int32 i) const requires(Extents::rank() == 1) { return m_span(i); }
 
 public:

  DataType operator()(Int32 i, Int32 j, Int32 k, Int32 l) const requires(Extents::rank() == 4)
  {
    return m_span(i, j, k, l);
  }

  DataType& operator()(Int32 i, Int32 j, Int32 k, Int32 l) requires(Extents::rank() == 4)
  {
    return m_span(i, j, k, l);
  }

  DataType operator()(Int32 i, Int32 j, Int32 k) const requires(Extents::rank() == 3)
  {
    return m_span(i, j, k);
  }

  DataType& operator()(Int32 i, Int32 j, Int32 k) requires(Extents::rank() == 3)
  {
    return m_span(i, j, k);
  }

  DataType operator()(Int32 i, Int32 j) const requires(Extents::rank() == 2)
  {
    return m_span(i, j);
  }

  DataType& operator()(Int32 i, Int32 j) requires(Extents::rank() == 2)
  {
    return m_span(i, j);
  }

  DataType operator()(Int32 i) const requires(Extents::rank() == 1) { return m_span(i); }
  DataType& operator()(Int32 i) requires(Extents::rank() == 1) { return m_span(i); }
 
 public:

  const DataType& operator()(ArrayBoundsIndexType idx) const
  {
    return m_span(idx);
  }

  DataType& operator()(ArrayBoundsIndexType idx)
  {
    return m_span(idx);
  }
 
 public:
 
  // TODO: rendre obsolète
  ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
  DataType& s(Int32 i, Int32 j, Int32 k, Int32 l) requires(Extents::rank() == 4)
  {
    return m_span(i, j, k, l);
  }

  ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
  DataType& s(Int32 i, Int32 j, Int32 k) requires(Extents::rank() == 3)
  {
    return m_span(i, j, k);
  }

  ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
  DataType& s(Int32 i, Int32 j) requires(Extents::rank() == 2)
  {
    return m_span(i, j);
  }

  ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
  DataType& s(Int32 i) requires(Extents::rank() == 1) { return m_span(i); }

  ARCANE_DEPRECATED_REASON("Y2023: Use operator() instead")
  DataType& s(ArrayBoundsIndexType idx)
  {
    return m_span(idx);
  }
 
 public:

  ARCANE_DEPRECATED_REASON("Y2024: Use mdspan() instead")
  MDSpanType span() { return m_span; }

  ARCANE_DEPRECATED_REASON("Y2024: Use mdspan() instead")
  ConstMDSpanType span() const { return m_span.constMDSpan(); }

  ARCANE_DEPRECATED_REASON("Y2024: Use constMDSpan() instead")
  ConstMDSpanType constSpan() const { return m_span.constMDSpan(); }

  MDSpanType mdspan() { return m_span; }

  ConstMDSpanType mdspan() const { return m_span.constMDSpan(); }

  ConstMDSpanType constMDSpan() const { return m_span.constMDSpan(); }

  Span<const DataType> to1DSpan() const { return m_span.to1DSpan(); }

  Span<DataType> to1DSpan() { return m_span.to1DSpan(); }

  constexpr operator MDSpanType() { return this->mdspan(); }
  constexpr operator ConstMDSpanType() const { return this->constMDSpan(); }

  constexpr operator SmallSpan<DataType>() requires(Extents::rank() == 1) { return this->to1DSpan().smallView(); }
  constexpr operator SmallSpan<const DataType>() const requires(Extents::rank() == 1) { return this->to1DSpan().constSmallView(); }

  constexpr SmallSpan<DataType> to1DSmallSpan() requires(Extents::rank() == 1) { return m_span.to1DSmallSpan(); }
  constexpr SmallSpan<const DataType> to1DSmallSpan() const requires(Extents::rank() == 1) { return m_span.to1DSmallSpan(); }
  constexpr SmallSpan<const DataType> to1DConstSmallSpan() const requires(Extents::rank() == 1) { return m_span.to1DConstSmallSpan(); }
 
 public:

  DataType* _internalData() { return m_span._internalData(); }
 
 private:
 
  MDSpanType m_span;
  ArrayWrapper m_data;
  Int64 m_total_nb_element = 0;
 
 private:
 
  void _updateSpanPointerFromData()
  {
    m_span.m_ptr = m_data.to1DSpan().data();
  }
 
  void _resizeAndCopy(ConstMDSpanType rhs, eMemoryRessource input_ressource, const RunQueue* queue)
  {
    this->resize(rhs.extents().dynamicExtents());
    m_data.copyOnly(rhs.to1DSpan(), input_ressource, queue);
    _updateSpanPointerFromData();
  }

  void _resize()
  {
    m_total_nb_element = m_span.extents().totalNbElement();
    m_data.resize(m_total_nb_element);
    _updateSpanPointerFromData();
  }

  void _resizeInit()
  {
    if constexpr (ExtentsType::nb_dynamic == 0) {
      resize(DynamicDimsType());
    }
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif