tree 87f0969d11d4a74146cbbb024bb2a85faa46f15c
parent 8f68ecd32c8e18d3b064dbf0ea5fc31a6cb37e9a
author Daniel Simon <dansimon09@gmail.com> 1770591886 -0800
committer GitHub <noreply@github.com> 1770591886 -0800
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJpiRaOCRC1aQ7uu5UhlAAA+DYQABFyfrKQifc8KVi9yrl0c68z
 x8fRaIx+r68i0e6dDaW2K+R3AiKMGjEJs4mc3cjB403Iug6P/yYrK9yfodL4Q8hU
 EJyeuHTZoT4Vuh8HVStF+81hU6xggPUldlxyxyo52Hz7xKQ0FPpOM8DCnPEjzeXs
 0I1Xj5y7i9S1RNWSsuGFVQHTTKYgRMiIElyyBBCoNiCJUAsWoE6fY32EOkO8vL3E
 oXAy+F1F4mOFaEUVoDbWQ+7kl/0aKD4V8qkXfCbGmMzlzlEckm6l2TkBoVcQ4pBy
 suIhCUzOs8Z0X+nK3lWwDZN0+LhCwkKyPORXAbebut+Qr91gLpB7cWAQb1pclzwr
 UiK2lNVoUQXM6cO3TEPFoWX5dclNItF+0L1NQe5X2QGGH8LO92I0GMYACSjWyRJa
 DKW0i3isLHBGSSvc69sXOWosLvrk/MPrErn+Ut1cIK2+/9zeqXrx/duSVnxdHAzf
 EPslqysqdy9n422zZ7AJu3ROkQ/t9wd2bg7e0Vuf4EW6FETw6+1Qp1qpvKXTgqoy
 HsE1r9xclhrN/eq4HL6Y/+yydoTdYDboZD9+pv7qjcTGHSgR2LlwoFutsfWXhDiA
 C1+sX5RFf2mLFhofPYdBKXedd62BkBDMtnZDv9Ak3qgpeiAMPrj2hcDZheBjnqxR
 AQkvX+kgOP8s2kFFznHf
 =Iwm9
 -----END PGP SIGNATURE-----
 

Add helpers to array that return the size and strides as a std::span (#5974)

* Add helper functions to pybind11::array to return the shape and strides as a std::span. These functions are hidden with macros unless PYBIND11_CPP20 is defined and the <span> include has been found.

* style: pre-commit fixes

* tests: Add unit tests for shape_span() and strides_span()

Add comprehensive unit tests for the new std::span helper functions:
- Test 0D, 1D, 2D, and 3D arrays
- Verify spans match regular shape()/strides() methods
- Test that spans can be used to construct new arrays
- Tests are conditionally compiled only when PYBIND11_HAS_SPAN is defined

* Use __cpp_lib_span feature test macro instead of __has_include

Replace __has_include(<span>) check with __cpp_lib_span feature test macro
to resolve ambiguity where some pre-C++20 systems might have a global
header called <span> that isn't the C++20 std::span.

The check is moved after <version> is included, consistent with how
__cpp_lib_char8_t is handled.

Co-authored-by: Cursor <cursoragent@cursor.com>

* Fix: Use py::ssize_t instead of ssize_t in span tests

On Windows/MSVC, ssize_t is not available in the standard namespace
without proper includes. Use py::ssize_t (the pybind11 typedef) instead
to ensure cross-platform compatibility.

Fixes compilation errors on:
- Windows/MSVC 2022 (C++20)
- GCC 10 (C++20)

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Ralf W. Grosse-Kunstleve <rgrossekunst@nvidia.com>
Co-authored-by: Cursor <cursoragent@cursor.com>