> "The vanilla ice cream of technical analysis. Boring, ubiquitous, and the only thing your grandfather and your high-frequency trading bot agree on."
The Simple Moving Average (SMA) is the unweighted arithmetic mean of the last $N$ data points. It acts as a low-pass filter, smoothing out high-frequency noise to reveal the underlying trend. While conceptually simple, efficient implementation on modern hardware requires careful attention to memory access patterns and vectorization.
## Historical Context
The concept of a moving average dates back to 1901 (R.H. Hooker) for smoothing weather data, but it became a staple of financial analysis in the mid-20th century. It is the baseline against which all other averages are compared.
## Architecture & Physics
The naive implementation of SMA sums $N$ numbers at every step, resulting in $O(N)$ complexity. QuanTAlib uses an optimized $O(1)$ approach.
### O(1) Running Sum
A running `Sum` and a `RingBuffer` of history are maintained.
This ensures that calculating an SMA(200) takes the exact same time as an SMA(10).
### Drift Correction
Floating-point addition is not associative. Repeatedly adding and subtracting values from a running sum introduces cumulative error (drift) over millions of ticks. QuanTAlib implements a periodic **Resync** mechanism (every 1000 ticks) that recalculates the sum from scratch to ensure precision remains within `1e-9` of the true mean.
### SIMD Optimization
For batch processing of large datasets, `Sma.Batch` utilizes `System.Runtime.Intrinsics` (AVX2/AVX-512) to process multiple data points in parallel, significantly outperforming scalar loops.
The implementation maintains a `RingBuffer` of the most recent $N$ values alongside a running `Sum`. On each update, the oldest value is subtracted and the newest added—eliminating the need to iterate over the entire window:
```csharp
Sum=Math.FusedMultiplyAdd(-_buffer[^1],1,Sum+p);
_buffer.Add(p,isNew);
```
Using `FusedMultiplyAdd` for the combined subtraction/addition improves numerical stability compared to separate operations.
### State Record Struct
Minimal state is captured in a `record struct` for efficient bar correction:
When `isNew=false`, the implementation restores `_p_state` to revert any partial calculation—enabling accurate bar correction when the same timestamp updates multiple times.
### Periodic Resync for Drift Correction
Floating-point drift accumulates over millions of additions/subtractions. The implementation resyncs every 1000 ticks:
- **AVX-512**: Processes 8 doubles simultaneously with 512-bit vectors
- **AVX2**: Processes 4 doubles with 256-bit vectors
- **NEON (ARM64)**: Processes 2 doubles with 128-bit vectors
- **Scalar fallback**: Portable loop for unsupported architectures
### Prefix-Sum Vectorization
For batch processing, the SIMD paths use a prefix-sum technique that enables parallel computation of running sums. The initial window sum is computed with vectorized horizontal addition, then subsequent values use the optimized running-sum pattern.
### ArrayPool for Memory Efficiency
Large period buffers are rented from `ArrayPool<double>` rather than allocated, reducing GC pressure during batch operations. Combined with `stackalloc` for small intermediate buffers, this achieves zero-allocation in hot paths.
### NaN Handling with Last-Valid Substitution
Non-finite inputs are replaced with the last valid value stored in state:
```csharp
p=double.IsFinite(p)?p:_state.LastValidValue;
```
This prevents NaN propagation through the running sum without requiring expensive validation on every buffer access.
For SMA(200), total memory is approximately 1.7 KB per instance.
### Common Pitfalls
1.**Lag**: SMA has the most lag of all moving averages (Lag $\approx N/2$).
2.**Drop-off Effect**: An old, large outlier dropping out of the window causes the SMA to jump, even if the current price is flat. This "Barker effect" is why EMAs are often preferred.
