# mdspan

***

**1. Dynamic Multidimensional Array Allocation**

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

**2. Accessing Elements**

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

**3. Iterating over Elements**

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

**4. Slicing**

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

**5. Concatenation**

```cpp
// 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**

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

**7. Index Translation (Reverse)**

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

**8. Converting to and from Eigen::Tensor**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

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

**12. Reshaping**

```cpp
// 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**

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

**14. Transposing**

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

**15. Element-wise Operations**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

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

**21. Index Selection**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

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

**28. Reductions with Masks**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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**

```cpp
// 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);
```