Wilder RMA: Build the Smoothing Engine Behind RSI and ATR

Suppose two systems both report a “14-period Wilder average,” yet their first values disagree and the difference persists. The recurrence may be correct in both systems. The mismatch can come from the seed, warm-up alignment, missing rows, or rounded state.

That is why Wilder's Moving Average—often called RMA, Wilder smoothing, a modified moving average, or sometimes SMMA—needs a complete contract rather than a one-line formula.

In this tutorial we will calculate an SMA-seeded RMA, implement it in Python and TypeScript, compare it with an equal-period EMA, and test the operational details that determine reproducibility. The method is historically associated with J. Welles Wilder's 1978 indicator systems; the institutional record for his original book establishes that source context.

What RMA gives a practitioner and a builder

For a practitioner, RMA provides a smoother causal view of an observed series. For a builder, it provides an $O(1)$-state recurrence used inside later indicators. Official TC2000 methodology identifies Wilder smoothing in both Wilder's RSI and traditional ATR.

By the end, you will be able to:

• derive alpha from the declared period;
• distinguish warm-up, seed, and recursive updates;
• explain why a period-14 RMA is not a period-14 EMA;
• preserve full-precision state across updates and restarts;
• verify two language implementations against one fixture.

The only mathematical prerequisite is the Simple Moving Average (SMA), which we use once to initialize the state.

Intuition: keep most of yesterday, accept a fraction of today

Let $R_{t-1}$ be the prior RMA and $x_t$ the current observation. With period $n$, the update is:

Read the formula from the inside out:

1. Measure the gap between the current value and the prior state.
2. Take one $n$-th of that gap.
3. Add the adjustment to the prior state.

The equivalent weighted form is:

Those coefficients are non-negative and sum to one. The new state must therefore lie between the prior state and current value. That convex-bound property is useful in tests.

See one exact update

In the canonical example, the prior state is $11.6667$, the current value is $15$, and the period is $3$. Notice that the new state moves exactly one third of the gap:

The full-precision calculation is:

Only the label is rounded. The fraction—or its full binary floating-point equivalent—continues into the next update.

Initialization is part of the algorithm

The recurrence needs a prior state. Our canonical finance-style policy waits for $n$ valid observations, then uses their SMA:

Outputs before observation $n$ are null. After the seed exists, every new observation advances the recurrence once.

This is consistent with maintained classic Wilder implementations. TA-Lib's RSI source accumulates an initial period average and describes subsequent Wilder updates as multiplying the prior value by period - 1, adding today's value, and dividing by period.

A first-value seed is also possible:

It starts immediately but produces a different early path. Neither choice should be hidden behind a library default. Period, seed, warm-up alignment, and reset policy must travel with the result.

RMA versus EMA: the period labels are not interchangeable

A common finance-style EMA converts span $m$ to:

RMA uses:

At equal labels $m=n>1$, the RMA alpha is smaller. It reacts more slowly. To give an EMA the same alpha as an $n$-period RMA:

The TC2000 ATR methodology documents this conversion. A 14-period RMA recurrence matches an EMA alpha commonly labeled span 27—but only when the seed and output alignment also match.

The following visual holds the period label and SMA seed constant. The RMA uses alpha $1/3$, while the EMA uses alpha $1/2$:

Both begin at $35/3$. By observation six, the RMA is $1198/81$, or 14.7901, while the equal-period EMA is $95/6$, or 15.8333.

The complete data contract

A numeric array is sufficient for a small function, but a reproducible financial series needs more:

Fixed-alpha RMA decays per accepted observation, not per wall-clock hour. An overnight gap and a one-minute gap both represent one update if each contributes one row. A time-aware smoother is a different algorithm.

Similarly, mixing adjusted and unadjusted prices inside one state history is invalid. The resulting jump is a data-basis break, not market movement.

Walk through the canonical fixture

Use period 3 and the synthetic values:

The first two values only contribute to the seed sum. Observation three creates the first numeric state. Each later state depends on the prior full-precision RMA.

Use the interactive causal playground to step through the same values. Change the period to alter alpha and warm-up, then switch to first-value initialization to see which differences come from the seed rather than the recurrence. The static comparison above remains the complete fallback when scripts or motion are unavailable.

A real index window: observations versus derived arithmetic

A historical example is useful here only if its evidence boundary is explicit. Nasdaq Trader's year-to-date file reports these Nasdaq Composite Index closing values. The close column is observed provider data. The RMA and EMA columns are author-derived from those six values with period 3, the same three-observation SMA seed, one update per listed session, and no intermediate rounding.

The common seed is 22,691.01. When the observed close falls to 22,387.68 on 2026-03-06, the equal-period EMA moves farther because alpha (1/2) is larger than the RMA's (1/3). Both then move back toward the 2026-03-09 observation. This visual demonstrates smoothing mechanics; it does not show causation, predictive value, indicator superiority, or a tradable strategy. The extract does not establish the file's historical publication timestamp or revision chain.

Provider context: Nasdaq Trader Daily Market Files, Nasdaq data definitions, and the 2026 year-to-date CSV, retrieved 2026-07-22T23:23:41Z.

Translate the contract into code

The reference Python core is intentionally small:

alpha = 1.0 / period
seed_sum = 0.0
rma = None

for observation, value in enumerate(numbers, start=1):
    if observation <= period:
        seed_sum += value
    if observation < period:
        output.append(None)
    elif observation == period:
        rma = seed_sum / period
        output.append(rma)
    else:
        rma += alpha * (value - rma)
        output.append(rma)

The TypeScript implementation follows the same state transitions:

const alpha = 1 / period;
let seedSum = 0;
let rma: number | null = null;

numbers.forEach((value, zeroBasedIndex) => {
  const observation = zeroBasedIndex + 1;
  if (observation <= period) seedSum += value;
  if (observation < period) output.push(null);
  else if (observation === period) {
    rma = seedSum / period;
    output.push(rma);
  } else {
    rma = rma + alpha * (value - rma);
    output.push(rma);
  }
});

The delivered source adds validation around these blocks. Booleans are rejected even though Python treats bool as an integer subtype. NaN, infinity, null, non-integer periods, and non-positive periods are also invalid.

Test behavior, not just example values

Both languages consume the same JSON fixture. The tests verify the canonical path within $10^{-12}$, but example parity alone is not enough.

Useful invariants include:

• Period one is identity: alpha equals one, so output equals input.
• Constant preservation: a constant series remains constant after seed.
• Convex bounds: every update lies between prior state and current input.
• Scale and translation equivariance: applying $a x+b$ with positive $a$ before smoothing gives $aR+b$.
• Non-mutation: calculation does not alter the source array.
• Warm-up alignment: a short series returns only null values.

These tests establish implementation correctness. They do not show that an RMA crossover predicts prices, survives transaction costs, or generalizes out-of-sample.

Operational failure modes

Rounding recursive state

If each displayed value is rounded and then reused, the error compounds. Persist and recurse with full precision.

Treating a missing row as zero

Zero is a real observation. Substituting it for missing data introduces a large artificial move. Reject or apply an explicit upstream imputation policy.

Correcting history without replay

A correction changes every dependent state. If $x_j$ changes by $\delta$, the immediate RMA changes by $\alpha\delta$. After $k$ unchanged updates, the remaining difference is:

Replay from the start or from a verified checkpoint before the correction.

Comparing vendor labels without seed details

RMA, SMMA, modified moving average, and Wilder smoothing may share the recurrence while differing in initialization or indexing. Compare alpha, seed, warm-up, and missing-data rules—not the label alone.

Reading smoothness as prediction

RMA is causal and lagging. Its visual stability is not evidence of future returns or a profitable signal.

Where to use RMA

RMA is appropriate when you need:

• Wilder-smoothed gains and losses for RSI;
• Wilder-smoothed true range for ATR;
• Wilder-smoothed directional movement for DMI and ADX;
• a simple causal baseline with constant memory;
• parity with a platform whose RMA conventions are explicit.

For each published output, include the source identity, unit, basis, period, alpha, seed, missing policy, and rounding policy.

Summary and next topic

Wilder RMA is a fixed-alpha recursive smoother with $\alpha=1/n$. Its canonical first state is an $n$-observation SMA, and its period is not a hard window. Equal-period RMA and EMA differ; an EMA recurrence matches RMA only when alpha, seed, and alignment all match.

You can now calculate, implement, and verify the smoothing engine. The natural next tutorial is RSI, where the same recurrence is applied separately to gains and losses before their relative-strength ratio is mapped to a bounded oscillator.

Asset map

Primary references

• Wilder's original 1978 book record
• TA-Lib classic RSI source
• TC2000 Wilder RSI methodology
• TC2000 ATR methodology

This tutorial is educational and does not provide investment advice.