Using mdspan with Algorithms

Yes, you can use std::mdspan with standard library algorithms that operate on contiguous ranges of elements. std::mdspan provides a contiguous view of the underlying memory, which makes it compatible with many standard library algorithms.

To use std::mdspan with algorithms, you can obtain a pointer to the underlying data using the data() member function and pass it along with the size of the mdspan to the algorithm.

Here's an example that demonstrates using std::mdspan with the std::sort algorithm:

1#include <algorithm>
2#include <iostream>
3#include <mdspan>
4
5int main() {
6  std::array<int, 6> arr{4, 2, 6, 1, 5, 3};
7  std::mdspan<int, std::extents<
8    size_t, 2, 3>> span{arr.data()};
9
10  // Sort the elements in the mdspan
11  std::sort(span.data(),
12    span.data() + span.size());  
13
14  std::cout << "Sorted elements:\n";
15  for (size_t i = 0; i < span.extent(0); ++i) {
16    for (size_t j = 0; j < span.extent(1); ++j) {
17      std::cout << span[i, j] << " ";
18    }
19    std::cout << "\n";
20  }
21}

1Sorted elements:
21 2 3
34 5 6

In this example, we create an mdspan object span that provides a 2D view of the underlying array arr.

To sort the elements in the mdspan, we pass span.data() as the beginning of the range and span.data() + span.size() as the end of the range to the std::sort algorithm. This effectively sorts the elements in the underlying array.

After sorting, we can access the sorted elements through the mdspan using the [i, j] syntax, and they will reflect the sorted order.

It's important to note that when using std::mdspan with algorithms, the algorithms operate on the underlying contiguous memory, not on the multidimensional view itself. The mdspan acts as a wrapper that provides a multidimensional interface to the underlying data.

However, you can still benefit from the convenience and expressiveness of std::mdspan when working with algorithms. You can use mdspan to provide a more intuitive and structured view of the data, while leveraging the performance and flexibility of standard library algorithms.

Keep in mind that if you need to perform operations that are specific to the multidimensional nature of the data, such as matrix multiplication or convolution, you may need to implement those operations separately or use specialized libraries that handle multidimensional data efficiently.