mdspan

---

1. Dynamic Multidimensional Array Allocation

// Create a 3-dimensional array with 2x3x4 dimensions
mdspan<int> arr(2, 3, 4);

2. Accessing Elements

// Get the value at position (0, 1, 2)
auto value = arr(0, 1, 2);

3. Iterating over Elements

for (auto& e : arr) {
  // Process each element
}

4. Slicing

// Get a slice of the array corresponding to the second row
mdspan<int> row = arr[1];

5. Concatenation

// Concatenate two 2-dimensional arrays into a 3-dimensional array
mdspan<int> arr1 = mdspan<int>(2, 3);
mdspan<int> arr2 = mdspan<int>(2, 3);
mdspan<int> arr3 = mdspan<int>(2, 2, 3);
arr3.insert(0, arr1);
arr3.insert(1, arr2);

6. Index Translation

// Translate a linear index into a multidimensional index
auto indices = arr.get_indices(7);

7. Index Translation (Reverse)

// Translate a multidimensional index into a linear index
auto index = arr.get_index(0, 1, 2);

8. Converting to and from Eigen::Tensor

// Convert an mdspan to an Eigen::Tensor
Eigen::Tensor<int, 3> eigen_tensor = Eigen::Tensor<int, 3>::Map(arr.data(), arr.shape());

9. Converting to and from std::vector

// Convert an mdspan to a std::vector of std::vectors
std::vector<std::vector<int>> vector_of_vectors;
vector_of_vectors.resize(arr.shape()[0]);
for (int i = 0; i < arr.shape()[0]; ++i) {
  vector_of_vectors[i].resize(arr.shape()[1]);
  for (int j = 0; j < arr.shape()[1]; ++j) {
    vector_of_vectors[i][j].resize(arr.shape()[2]);
    for (int k = 0; k < arr.shape()[2]; ++k) {
      vector_of_vectors[i][j][k] = arr(i, j, k);
    }
  }
}

10. Creating an mdspan from a Buffer

// Create an mdspan from a raw buffer
int* buffer = new int[100];
mdspan<int> arr = mdspan<int>::from_buffer(buffer, {10, 10});

11. Creating an mdspan from a Pointer

// Create an mdspan from a pointer
int* pointer = &arr(0, 0, 0);
mdspan<int> arr2 = mdspan<int>::from_pointer(pointer, arr.shape());

12. Reshaping

// Reshape a 3-dimensional array to a 2-dimensional array
mdspan<int> arr(2, 3, 4);
mdspan<int> reshaped = arr.reshape({6, 4});

13. Broadcasting

// Broadcast a 1-dimensional array to a 3-dimensional array
mdspan<int> arr(4);
mdspan<int> broadcast = arr.broadcast({2, 3, 4});

14. Transposing

// Transpose a 3-dimensional array
mdspan<int> arr(2, 3, 4);
mdspan<int> transposed = arr.transpose({1, 0, 2});

15. Element-wise Operations

// Perform element-wise addition on two 3-dimensional arrays
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1 + arr2;

16. Reductions

// Reduce a 3-dimensional array to a 1-dimensional array by summing along the first dimension
mdspan<int> arr(2, 3, 4);
mdspan<int> reduced = arr.reduce(mdspan::reduce_sum, 0);

17. Filtering

// Filter a 3-dimensional array to select only elements that are greater than 5
mdspan<int> arr(2, 3, 4);
mdspan<int> filtered = arr.where([](int x) { return x > 5; });

18. Sorting

// Sort a 2-dimensional array along the first column
mdspan<int> arr(2, 3);
arr.sort(0);

19. Creating an mdspan from an STL Container

// Create an mdspan from a std::vector
std::vector<int> vec = {1, 2, 3, 4, 5, 6};
mdspan<int> arr = mdspan<int>::from_vector(vec);

20. Creating an mdspan from a Range

// Create an mdspan from a range of integers
mdspan<int> arr = mdspan<int>::from_range(1, 10);

21. Index Selection

// Select elements from an array using a boolean mask
mdspan<int> arr(2, 3, 4);
mdspan<bool> mask = arr > 5;
mdspan<int> selected = arr.select(mask);

22. Strided Access

// Access elements in an array with a specified stride
mdspan<int> arr(2, 3, 4);
mdspan<int> strided = arr.stride({1, 2, 1});

23. Element-wise Logical Operations

// Perform element-wise logical AND on two 3-dimensional arrays
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1.logical_and(arr2);

24. Element-wise Bitwise Operations

// Perform element-wise bitwise OR on two 3-dimensional arrays
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1.bitwise_or(arr2);

25. Element-wise Comparisons

// Perform element-wise comparisons on two 3-dimensional arrays
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1.compare_greater(arr2);

26. Element-wise Mathematical Functions

// Perform element-wise sine on a 3-dimensional array
mdspan<int> arr(2, 3, 4);
mdspan<int> result = arr.apply([](int x) { return std::sin(x); });

27. Element-wise Rounding

// Perform element-wise rounding on a 3-dimensional array
mdspan<int> arr(2, 3, 4);
mdspan<int> result = arr.round();

28. Reductions with Masks

// Reduce a 3-dimensional array to a 1-dimensional array by summing along the first dimension, ignoring masked elements
mdspan<int> arr(2, 3, 4);
mdspan<bool> mask = arr > 5;
mdspan<int> reduced = arr.reduce(mdspan::reduce_sum, 0, mask);

29. Transposing Irregular Arrays

// Transpose an array with irregular dimensions
mdspan<int> arr(2, {3, 4}, 2);
mdspan<int> transposed = arr.transpose({1, 0, 2});

30. Element-wise Comparisons with Masks

// Perform element-wise comparisons on two 3-dimensional arrays, ignoring masked elements
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1.compare_greater(arr2).select(arr1 > 5);

31. Striding with Masks

// Access elements in an array with a specified stride, ignoring masked elements
mdspan<int> arr(2, 3, 4);
mdspan<bool> mask = arr > 5;
mdspan<int> strided = arr.stride({1, 2, 1}).select(mask);

32. Element-wise Bitwise Shifts

// Perform element-wise bitwise left shift on a 3-dimensional array
mdspan<int> arr(2, 3, 4);
mdspan<int> result = arr.bitwise_left_shift(2);

33. Element-wise Absolute Values

// Perform element-wise absolute values on a 3-dimensional array
mdspan<int> arr(2, 3, 4);
mdspan<int> result = arr.abs();

34. Element-wise Clipping

// Perform element-wise clipping on a 3-dimensional array, limiting values to [-5, 10]
mdspan<int> arr(2, 3, 4);
mdspan<int> result = arr.clip(-5, 10);

35. Element-wise Modulus

// Perform element-wise modulus on two 3-dimensional arrays
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1.modulus(arr2);

36. Element-wise Exponents

// Perform element-wise exponentiation on two 3-dimensional arrays
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1.pow(arr2);

37. Element-wise Maximums

// Perform element-wise maximums on two 3-dimensional arrays
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1.maximum(arr2);

38. Element-wise Minimums

// Perform element-wise minimums on two 3-dimensional arrays
mdspan<int> arr1(2, 3, 4);
mdspan<int> arr2(2, 3, 4);
mdspan<int> result = arr1.minimum(arr2);

39. Element-wise Rounding to Nearest

// Perform element-wise rounding to nearest integer on a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<int> result = arr.round_to_nearest();

40. Element-wise Floating-Point Comparisons

// Perform element-wise floating-point comparisons on two 3-dimensional arrays
mdspan<float> arr1(2, 3, 4);
mdspan<float> arr2(2, 3, 4);
mdspan<bool> result = arr1.compare_equal(arr2, 0.01);

41. Element-wise Trigonometric Functions

// Perform element-wise cosine on a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<float> result = arr.apply([](float x) { return std::cos(x); });

42. Element-wise Hyperbolic Functions

// Perform element-wise hyperbolic sine on a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<float> result = arr.apply([](float x) { return std::sinh(x); });

43. Element-wise Logarithmic Functions

// Perform element-wise base-10 logarithm on a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<float> result = arr.apply([](float x) { return std::log10(x); });

44. Element-wise Power Functions

// Perform element-wise exponentiation on a 3-dimensional array, with a common exponent
mdspan<float> arr(2, 3, 4);
mdspan<float> result = arr.apply([](float x) { return std::pow(x, 2); });

45. Element-wise Square Roots

// Perform element-wise square roots on a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<float> result = arr.sqrt();

46. Element-wise Reciprocal

// Perform element-wise reciprocal on a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<float> result = arr.reciprocal();

47. Element-wise Special Functions

// Perform element-wise erf (error function) on a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<float> result = arr.apply([](float x) { return std::erf(x); });

48. Element-wise NaN and Infinity Checks

// Check for NaN and infinity in a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<bool> nan_mask = arr.isnan();
mdspan<bool> inf_mask = arr.isinf();

49. Element-wise Finite Checks

// Check for finite numbers in a 3-dimensional array
mdspan<float> arr(2, 3, 4);
mdspan<bool> finite_mask = arr.isfinite();

50. Element-wise Fused Multiply-Add

// Perform element-wise fused multiply-add on two 3-dimensional arrays
mdspan<float> arr1(2, 3, 4);
mdspan<float> arr2(2, 3, 4);
mdspan<float> result = arr1.fma(arr2, 1.5);