# valarray

***

**1. Array Initialization**

```cpp
std::valarray<int> v(10);  // Initialize with 10 zeros
```

**2. Array Arithmetic**

```cpp
std::valarray<int> v1 = {1, 2, 3}, v2 = {4, 5, 6};
std::valarray<int> result = v1 + v2;  // {5, 7, 9}
```

**3. Array Slicing**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::valarray<int> slice = v[std::slice(1, 2, 1)];  // {2}
```

**4. Array Masking**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::valarray<bool> mask = v > 2;  // {false, false, true, true, true}
std::valarray<int> masked = v[mask];  // {3, 4, 5}
```

**5. Element-wise Functions**

```cpp
std::valarray<double> v = {1.2, 2.3, 3.4};
std::valarray<double> result = std::sqrt(v);  // {1.095445, 1.516575, 1.843906}
```

**6. Array Accumulation**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
int sum = std::accumulate(v.begin(), v.end(), 0);  // 15
```

**7. Matrix Multiplication**

```cpp
std::valarray<double> a = {1, 2, 3}, b = {4, 5, 6};
std::valarray<double> result = a * b;  // {14, 32, 48}
```

**8. Array Broadcasting**

```cpp
std::valarray<int> v = {1, 2, 3};
std::valarray<int> scalar = 4;
std::valarray<int> result = v + scalar;  // {5, 6, 7}
```

**9. Complex Number Operations**

```cpp
std::valarray<std::complex<double>> v = {std::complex<double>(1, 2), std::complex<double>(3, 4)};
std::valarray<std::complex<double>> result = v * v;  // {5i, 25}
```

**10. Vector Operations**

```cpp
std::valarray<double> v1 = {1, 2, 3}, v2 = {4, 5, 6};
std::valarray<double> result = v1 * v2;  // {4, 10, 18}
```

**11. Array Division**

```cpp
std::valarray<double> v1 = {1, 2, 3}, v2 = {4, 5, 6};
std::valarray<double> result = v1 / v2;  // {0.25, 0.4, 0.5}
```

**12. Array Comparison**

```cpp
std::valarray<int> v1 = {1, 2, 3}, v2 = {4, 5, 6};
std::valarray<int> result = v1 < v2;  // {true, true, true}
```

**13. Array Maximum and Minimum**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
int max = v.max();  // 5
int min = v.min();  // 1
```

**14. Array Rounding**

```cpp
std::valarray<double> v = {1.2345, 2.3456, 3.4567};
std::valarray<double> result = std::round(v);  // {1.0, 2.0, 3.0}
```

**15. Array Sorting**

```cpp
std::valarray<int> v = {3, 1, 4, 2, 5};
std::sort(v.begin(), v.end());  // {1, 2, 3, 4, 5}
```

**16. Array Reversing**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::reverse(v.begin(), v.end());  // {5, 4, 3, 2, 1}
```

**17. Array Rotation**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::rotate(v.begin(), v.begin() + 1, v.end());  // {2, 3, 4, 5, 1}
```

**18. Array Shuffling**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::random_shuffle(v.begin(), v.end());  // Randomly shuffles the array
```

**19. Array Intersection**

```cpp
std::valarray<int> v1 = {1, 2, 3, 4, 5}, v2 = {2, 4, 6, 8, 10};
std::valarray<int> result = std::set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end());  // {2, 4}
```

**20. Array Union**

```cpp
std::valarray<int> v1 = {1, 2, 3, 4, 5}, v2 = {2, 4, 6, 8, 10};
std::valarray<int> result = std::set_union(v1.begin(), v1.end(), v2.begin(), v2.end());  // {1, 2, 3, 4, 5, 6, 8, 10}
```

**21. Array Difference**

```cpp
std::valarray<int> v1 = {1, 2, 3, 4, 5}, v2 = {2, 4, 6, 8, 10};
std::valarray<int> result = std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end());  // {1, 3, 5}
```

**22. Array Symmetric Difference**

```cpp
std::valarray<int> v1 = {1, 2, 3, 4, 5}, v2 = {2, 4, 6, 8, 10};
std::valarray<int> result = std::set_symmetric_difference(v1.begin(), v1.end(), v2.begin(), v2.end());  // {1, 3, 5, 6, 8, 10}
```

**23. Array Copy**

```cpp
std::valarray<int> v1 = {1, 2, 3}, v2 = v1;  // Copies v1 to v2
```

**24. Array Assignment**

```cpp
std::valarray<int> v1 = {1, 2, 3}, v2 = {4, 5, 6};
v1 = v2;  // Assigns v2 to v1
```

**25. Array Concatenation**

```cpp
std::valarray<int> v1 = {1, 2, 3}, v2 = {4, 5, 6};
std::valarray<int> result = std::concatenate(v1, v2);  // {1, 2, 3, 4, 5, 6}
```

**26. Array Reshaping**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5, 6};
std::valarray<int> result = v.reshape(2, 3);  // Reshapes v into a 2x3 matrix
```

**27. Array Transposing**

```cpp
std::valarray<double> v = {1.1, 2.2, 3.3, 4.4};
std::valarray<double> result = v.transpose();  // Transposes v
```

**28. Array Flattening**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5, 6};
std::valarray<int> result = v.flatten();  // Flattens v
```

**29. Array Filling**

```cpp
std::valarray<int> v(10);
v.fill(5);  // Fills v with 5s
```

**30. Array Swapping**

```cpp
std::valarray<int> v1 = {1, 2, 3}, v2 = {4, 5, 6};
std::swap(v1, v2);  // Swaps v1 and v2
```

**31. Array Searching**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
int index = v.find(3);  // Returns the index of the first occurrence of 3
```

**32. Array Counting**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
int count = v.count(3);  // Returns the number of occurrences of 3
```

**33. Array Reducing**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
int sum = v.reduce([](int x, int y) { return x + y; });  // Returns the sum of all elements
```

**34. Array Filtering**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::valarray<int> result = v.filter([](int x) { return x > 2; });  // Returns an array of elements greater than 2
```

**35. Array Mapping**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::valarray<int> result = v.map([](int x) { return x * x; });  // Returns an array of squared elements
```

**36. Array Fold Left**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
int result = v.fold_left([](int x, int y) { return x + y; });  // Returns the sum of all elements
```

**37. Array Fold Right**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
int result = v.fold_right([](int x, int y) { return x + y; });  // Returns the sum of all elements
```

**38. Array Generate**

```cpp
std::valarray<int> v = std::generate(10, []() { return rand() % 10; });  // Generates an array of 10 random numbers
```

**39. Array Filter Index**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::valarray<int> result = v.filter_index([](int x, int i) { return x % 2 == 0; });  // Returns an array of indices of even elements
```

**40. Array Unique**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5, 1, 2, 3};
std::valarray<int> result = v.unique();  // Returns an array of unique elements
```

**41. Array Intersection Indexed**

```cpp
std::valarray<int> v1 = {1, 2, 3, 4, 5}, v2 = {2, 4, 6, 8, 10};
std::valarray<int> result = std::intersection_indexed(v1.begin(), v1.end(), v2.begin(), v2.end());  // Returns an array of indices of intersecting elements
```

**42. Array Union Indexed**

```cpp
std::valarray<int> v1 = {1, 2, 3, 4, 5}, v2 = {2, 4, 6, 8, 10};
std::valarray<int> result = std::union_indexed(v1.begin(), v1.end(), v2.begin(), v2.end());  // Returns an array of indices of union of elements
```

**43. Array Difference Indexed**

```cpp
std::valarray<int> v1 = {1, 2, 3, 4, 5}, v2 = {2, 4, 6, 8, 10};
std::valarray<int> result = std::difference_indexed(v1.begin(), v1.end(), v2.begin(), v2.end());  // Returns an array of indices of difference of elements
```

**44. Array Symmetric Difference Indexed**

```cpp
std::valarray<int> v1 = {1, 2, 3, 4, 5}, v2 = {2, 4, 6, 8, 10};
std::valarray<int> result = std::symmetric_difference_indexed(v1.begin(), v1.end(), v2.begin(), v2.end());  // Returns an array of indices of symmetric difference of elements
```

**45. Array Reverse Indexed**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::valarray<int> result = std::reverse_indexed(v.begin(), v.end());  // Returns an array of reversed indices
```

**46. Array Rotate Indexed**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::valarray<int> result = std::rotate_indexed(v.begin(), v.begin() + 1, v.end());  // Returns an array of rotated indices
```

**47. Array Shuffle Indexed**

```cpp
std::valarray<int> v = {1, 2, 3, 4, 5};
std::valarray<int> result = std::shuffle_indexed(v.begin(), v.end());  // Returns an array of shuffled indices
```

**48. Array Sorted Indexed**

```cpp
std::valarray<int> v = {3, 1, 4, 2, 5};
std::valarray<int> result = std::sorted_indexed(v.begin(), v.end());  // Returns an array of sorted indices
```

**49. Array Stable Sort Indexed**

```cpp
std::valarray<int> v = {3, 1, 4, 2, 5};
std::valarray<int> result = std::stable_sort_indexed(v.begin(), v.end());  // Returns an array of stably sorted indices
```

**50. Array Partial Sort Indexed**

```cpp
std::valarray<int> v = {3, 1, 4, 2, 5};
std::valarray<int> result = std::partial_sort_indexed(v.begin(), v.begin() + 3, v.end());  // Returns an array of partially sorted indices
```