# Array Stride Access

# Array Stride Access

Array stride access visits elements with a fixed step between consecutive indices. A stride of $1$ scans every element. Larger strides skip elements and may reduce cache locality.

You use it when data is sampled, stored in interleaved form, or traversed by columns in row-major storage.

## Problem

Given an array $A$ of length $n$ and a stride $s$, process indices:

$$
0, s, 2s, 3s, \dots
$$

while the index remains less than $n$.

## Algorithm

Scan with a fixed stride:

```id="array-stride-access"
stride_scan(A, s):
    if s <= 0:
        error "stride must be positive"

    i = 0
    while i < length(A):
        process A[i]
        i += s
```

## Example

Let

$$
A = [8, 3, 5, 1, 9, 4, 2]
$$

and

$$
s = 2
$$

The scan visits:

| step | index | value |
| ---- | ----: | ----: |
| 1    |     0 |     8 |
| 2    |     2 |     5 |
| 3    |     4 |     9 |
| 4    |     6 |     2 |

Visited sequence:

$$
[8, 5, 9, 2]
$$

## Correctness

The algorithm starts at index $0$ and adds $s$ after each access. Since $s > 0$, the index increases monotonically. The loop condition ensures that every accessed index satisfies $0 \le i < n$.

Thus the algorithm processes exactly the positions of the form $ks$ that lie inside the array.

## Complexity

The number of visited elements is:

$$
\left\lceil \frac{n}{s} \right\rceil
$$

| operation           |       time |
| ------------------- | ---------: |
| stride scan         | $O(n / s)$ |
| worst case, $s = 1$ |     $O(n)$ |

Space usage:

$$
O(1)
$$

## When to Use

Stride access is appropriate when:

* processing every kth element
* reading interleaved data
* sampling an array
* traversing columns in flat matrix storage

It is less suitable when sequential locality matters and all elements must be processed. In that case, prefer contiguous traversal.

## Implementation

```python id="array-stride-python"
def stride_scan(a, stride, process):
    if stride <= 0:
        raise ValueError("stride must be positive")

    i = 0
    while i < len(a):
        process(a[i])
        i += stride
```

```go id="array-stride-go"
func StrideScan[T any](a []T, stride int, process func(T)) bool {
    if stride <= 0 {
        return false
    }

    for i := 0; i < len(a); i += stride {
        process(a[i])
    }

    return true
}
```