Add btas::zb::RangeNd for slimmer zero-based ranges

[evaleev]

Summary

• Adds btas::zb::RangeNd<MaxRank=6, Ext=int16_t, Ord=int32_t> — a zero-based, packed RangeNd for Tensor-of-Tensor inner tiles where lobound ≡ 0, upbound ≡ extent, strides are derivable, offset is 0, and the rank is small (≤ 6).
• State is just std::array<Ext, MaxRank> extent_ + uint8_t rank_. sizeof = 14 B, align = 2, vs. ~304 B for the general-purpose btas::Range.
• Strides are synthesized on demand via an ordinal_view value returned from RangeNd::ordinal(); lobound() materializes zeros from a static buffer.
• Models TWG.BoxRange (range_traits, is_index, boxrange_iteration_order specializations) and provides MADNESS ArchiveLoadImpl / ArchiveStoreImpl that serialize rank + extents only (ordinal is derivable).
• Motivated by TiledArray ToT (TA::Tensor<btas::Tensor<T, btas::zb::RangeNd<>, …>>) where per-inner-tile range overhead dominates.

Test plan

• New unittest/zb_range_test.cc — 6 test cases / 60 assertions covering sizeof/alignof contracts, concept membership, construction (default → rank-0 + area()==0, variadic, initializer-list, from container), lobound/upbound/extent accessors, row-major ordinal formula and ordinal_view strides, index iteration order, equality, swap, and non-default template parameters.
• btas_test builds clean on macOS (arm64, clang + C++20).
• All zb test cases pass locally: All tests passed (60 assertions in 6 test cases).

[Copilot]

Pull request overview

This PR introduces a compact, zero-based range type (btas::zb::RangeNd) intended to dramatically reduce per-tile range overhead for small-rank inner tiles (e.g., Tensor-of-Tensor use cases), and adds a new btas::Tensor constructor that can populate values via a generator called on each multi-index.

Changes:

• Added btas::zb::RangeNd (and supporting btas::zb::index / ordinal_view) plus BTAS/MADNESS trait & archive support.
• Added unit tests for zb::RangeNd, and extended existing tensor tests to cover a generator-based constructor.
• Wired the new unit test into the unittest CMake target and added a generator-based Tensor(range, gen) constructor.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
btas/zb/range.h	Adds packed zero-based RangeNd, iteration/ordinal synthesis, traits, and MADNESS archive load/store.
btas/tensor.h	Adds Tensor(const Range&, F&& gen) constructor to populate storage from a per-index generator.
unittest/zb_range_test.cc	New unit test suite validating size/alignment, concept membership, accessors, ordinal mapping, iteration, and swap/equality.
unittest/tensor_test.cc	Adds coverage for the new generator-based tensor constructor.
unittest/CMakeLists.txt	Adds zb_range_test.cc to the unit test build.

Comments suppressed due to low confidence (4)

btas/zb/range.h:38

• btas::zb::index stores size_ in a std::uint8_t, but there is no constraint preventing MaxRank > 255. Instantiating index<MaxRank,...> with MaxRank >= 256 will truncate sizes and can lead to out-of-bounds access. Add a static_assert(MaxRank < 256) (or use a wider size_ type) to enforce the invariant.

template <std::size_t MaxRank, typename Int>
class index {

btas/zb/range.h:403

• ArchiveLoadImpl reads rank from the archive and then constructs extent_type ext(rank). If asserts are compiled out, a malformed archive with rank > MaxRank can lead to size truncation and out-of-bounds writes/reads. Please validate rank <= MaxRank and fail deterministically (e.g., throw via BTAS_EXCEPTION) before allocating/filling ext.

    std::uint8_t rank{};
    ar& rank;
    typename btas::zb::RangeNd<MaxRank, Ext, Ord>::extent_type ext(
        static_cast<std::size_t>(rank));
    for (std::uint8_t i = 0; i < rank; ++i) ar& ext[i];
    r = btas::zb::RangeNd<MaxRank, Ext, Ord>(ext);
  }

btas/zb/range.h:216

• The comment says this constructor accepts an "extent container", but the SFINAE requires btas::is_index::value, which excludes common containers like std::vector. Either widen the constraint to accept general containers (consistent with btas::zb::index's container ctor) or update the comment/API docs to reflect the actual requirement.

  /// Construct from an extent container (rank inferred from size).
  template <typename C,
            typename = std::enable_if_t<is_index<std::decay_t<C>>::value &&
                                        !std::is_same_v<std::decay_t<C>, RangeNd>>>
  RangeNd(const C& ext) : extent_(ext) {}

btas/tensor.h:163

• The enable_if checks that gen is invocable with the input Range's iterator value type, but the implementation actually calls gen(idx) where idx comes from iterating over range_ (i.e., Tensor::range_type). If Range != range_type, this can pass the constraint but still fail to compile inside the body. Consider constraining gen against Tensor::index_type / range_type's iterator value type (or adjusting the loop to invoke gen with the same index type used in the constraint).

    template <typename Range, typename F,
              typename = std::enable_if_t<
                  btas::is_boxrange<Range>::value &&
                  std::is_invocable_r_v<
                      value_type, F,
                      decltype(*std::begin(std::declval<const Range&>()))>>>
    Tensor(const Range& range, F&& gen)
        : range_(range.lobound(), range.upbound()) {
      array_adaptor<storage_type>::resize(storage_, range_.area());
      auto out_it = begin();
      for (auto&& idx : range_) {
        *out_it++ = gen(idx);
      }

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 4 comments.