Kaufman Adaptive Moving Average (KAMA): Formula, Code, and Interactive Lab

A fixed moving average always responds at the same rate. Kaufman's Adaptive Moving Average (KAMA) changes its response from the path that price just took. A clean directional move makes it accelerate. A long zigzag that ends near its starting point makes it slow down.

That idea sounds simple, but implementations can disagree because of four details: the seed, the first valid output, the zero-denominator rule, and the meaning of the fast and slow settings. This tutorial resolves all four. By the end, you can calculate KAMA by hand, implement it in Python or TypeScript, compare vendor output, and inspect every update in a guided lab.

All numerical paths in this article are synthetic teaching data. They test the mechanism; they are not evidence of prediction or investment performance.

The practical question KAMA answers

Suppose two ten-bar paths start at 100 and finish at 110:

• one moves upward almost directly;
• the other rises, falls, and rises again before reaching 110.

Their endpoint change is identical. Their paths are not. KAMA measures how much of the total travel became net displacement.

The numerator is the straight endpoint displacement. The denominator is the sum of every absolute one-bar move. This ratio is near one for a direct path and near zero for a path that expends movement without making net progress.

Perry Kaufman's 1995 Smarter Trading is the original bibliographic anchor for the Adaptive Moving Average and Efficiency Ratio (Google Books). The current official TradingView explanation documents the same displacement, path-length, endpoint-factor, and squared smoothing structure.

First fix the exact KAMA convention

This tutorial uses three configurable integer parameters:

• efficiency period E=10;
• fast period F=2;
• slow period S=30.

These are tutorial defaults, not universal defaults. TA-Lib fixes the fast/slow endpoints at 2/30 and defaults its exposed efficiency period to 30. QuantConnect exposes all three and defaults only fast/slow to 2/30. Tulip fixes 2/30 and emits one extra leading raw seed value.

Our exact contract is:

• require E ≥ 2 and 1 ≤ F < S;
• use x_(E-1) as an internal seed;
• publish no seed value;
• publish the first calculated KAMA at index E;
• set efficiency ratio to one when path length is zero;
• reject missing and non-finite values;
• never round intermediate calculations.

This means E=10 requires 11 source observations for the first published value. Ten movements connect eleven points.

KAMA formula, one layer at a time

Let x_t be the current value and E the efficiency period.

1. Endpoint change

Absolute value makes efficiency directionless. A clean fall can be just as efficient as a clean rise.

2. Cumulative path length

KAMA descriptions often call V_t volatility. It is total absolute movement, not variance, standard deviation, or a volatility forecast.

3. Efficiency ratio

The triangle inequality keeps ER between zero and one. If price returns to where the window began but moved in between, change is zero and path is positive, so ER is zero.

The V_t=0 branch is an implementation convention. TA-Lib, QuantConnect LEAN, and Tulip all use ER=1. It can matter after a step: price may have been flat for a complete window while the recursive KAMA still lags behind the new level.

4. Fast and slow endpoint factors

Blend them with ER:

Then square the blend:

The square is not decorative. With fast 2 and slow 30:

• maximum SC = (2/3)² = 0.4444444444;
• minimum SC = (2/31)² = 0.0041623309.

If you translate a fixed EMA alpha back with N=2/alpha−1, these final constants resemble periods 3.5 and 479.5. So “KAMA moves between EMA(2) and EMA(30)” is a misleading shortcut. The labels 2 and 30 define the factors before squaring.

5. Recursive update

Seed internally:

Then update:

Because SC_t stays between zero and one, each update lies between the prior KAMA and current input. A single KAMA update cannot overshoot that segment.

The complete causal flow

Nothing later than t enters the update at t. KAMA is causal, but causal does not mean predictive.

Worked KAMA calculation

Use this compact synthetic sequence:

[100, 101, 102, 103, 104, 103, 104, 103, 104, 108, 109]
E=4, F=2, S=30

The hidden seed is KAMA_3=103.

At index 4:

So ER_4=1, SC_4=0.4444444444, and:

The complete trace is:

Index 7 is the key lesson. Price traveled four units but made no net progress over the window. KAMA nearly freezes.

Python implementation

The readable reference implementation deliberately recomputes each path:

fast_alpha = 2.0 / (fast_period + 1.0)
slow_alpha = 2.0 / (slow_period + 1.0)
previous = values[efficiency_period - 1]

for t in range(efficiency_period, len(values)):
    change = abs(values[t] - values[t - efficiency_period])
    path = sum(
        abs(values[j] - values[j - 1])
        for j in range(t - efficiency_period + 1, t + 1)
    )
    er = 1.0 if path == 0.0 else change / path
    alpha = slow_alpha + er * (fast_alpha - slow_alpha)
    sc = alpha * alpha
    previous = previous + sc * (values[t] - previous)
    kama[t] = previous

The complete validated source is implementations/python/kama.py.

TypeScript implementation

The TypeScript version uses the same control flow and nullable alignment:

const fastAlpha = 2 / (fastPeriod + 1);
const slowAlpha = 2 / (slowPeriod + 1);
let previous = values[efficiencyPeriod - 1];

for (let t = efficiencyPeriod; t < values.length; t += 1) {
  const change = Math.abs(values[t] - values[t - efficiencyPeriod]);
  let path = 0;
  for (let j = t - efficiencyPeriod + 1; j <= t; j += 1) {
    path += Math.abs(values[j] - values[j - 1]);
  }
  const er = path === 0 ? 1 : change / path;
  const alpha = slowAlpha + er * (fastAlpha - slowAlpha);
  const sc = alpha * alpha;
  previous += sc * (values[t] - previous);
  kama[t] = previous;
}

See implementations/typescript/kama.ts. Both languages share full-precision JSON fixtures and agree within 1e-12.

Why platform values can differ

Check these questions before calling either implementation wrong:

1. Is the efficiency period 10 or 30?
2. Are fast and slow periods configurable or fixed?
3. Is the previous price or an average used as the seed?
4. Is the raw seed emitted at E-1?
5. Does the first calculated result appear at E?
6. What happens when path length is zero?
7. Are pre-ready values hidden, raw, or null?
8. Is the source raw, split-adjusted, or total-return adjusted?
9. Does the calculation include an unclosed bar?

The official TA-Lib function page and its pinned implementation provide a reproducible vendor comparison point.

Data quality is part of the algorithm

A split-like discontinuity, contract roll, bad tick, unit conversion, or mixed adjustment basis can look like a highly efficient directional move. KAMA cannot know that the move is a data event.

Use one declared source field, calendar, frequency, timezone, and adjustment basis. Reject missing values by default. If an application deliberately resets at a gap, clear recursive state and require another E+1 observations.

A correction also requires replay. Changing one past input affects nearby ER windows and changes the recursive KAMA passed into every later update.

Explore 120 observations instead of a tiny demo

The default Regime Tour contains 120 observations:

• quiet alternating warm-up;
• clean directional rise;
• zero-progress chop;
• a sharp step;
• controlled decline;
• noisy range;
• clean recovery.

Use the interactive KAMA playground to change scenarios and parameters, step through the active window, and inspect change, path, ER, alpha, SC, and KAMA together. The additional scenarios cover same endpoints with different paths, a step followed by a flat window, a raw-versus-adjusted discontinuity, and a missing-observation reset.

Tests that matter

The focused suite checks:

• full-precision shared fixtures;
• exactly E leading nulls;
• ER=1 for monotone up and down paths;
• ER=0 for a return-to-origin path;
• zero path after a level shift;
• output containment between prior KAMA and current value;
• translation and nonzero scale equivariance;
• parameter and finite-number validation;
• input immutability;
• Python and TypeScript parity.

These tests answer “did we implement the definition?” They do not answer “does a trading strategy work?” That requires a separate, bias-aware design with costs and out-of-sample evaluation.

KAMA versus EMA, Hull MA, and MAMA

KAMA is not automatically “better.” It makes a different tradeoff and exposes more path state. MAMA exposes more phase state.

Use KAMA when the important diagnostic is how much recent movement became net travel. Use MAMA when the important diagnostic is how quickly the measured Hilbert phase changed. This is a choice of question, not a ranking of lines.

Common questions

What is KAMA?

KAMA is an adaptive recursive moving average. It changes its smoothing constant from recent endpoint displacement relative to cumulative absolute movement.

How do you calculate KAMA?

Calculate change and path length, divide them to obtain ER, blend the fast and slow EMA factors, square that blend, and apply it to the prior KAMA update.

What do 10, 2, and 30 mean?

Ten is this tutorial's efficiency period. Two and thirty generate the fast and slow endpoint factors before squaring. They are not the final effective EMA period range.

Why is the smoothing constant squared?

Squaring preserves the order of the endpoint factors while strongly compressing low-efficiency updates. It is an essential part of the documented KAMA formula.

When is the first KAMA value ready?

Under this contract, index E: the calculation needs E one-step movements, E+1 observations, and a hidden seed at E-1.

Why does my KAMA differ from TA-Lib or another chart?

Match efficiency period, fast/slow exposure, seed, first-ready index, zero-path rule, unstable period, source field, adjustment basis, and bar availability.

Is ER a trend-direction signal?

No. Absolute values remove direction. A clean rise and clean fall both have high efficiency.

Can KAMA predict price?

No. KAMA is a causal smoother of observed input. A strategy using it needs separate evidence.

What happens when path length is zero?

This package sets ER to one, matching the maintained TA-Lib, QuantConnect, and Tulip implementations.

What are the best KAMA settings?

There is no universal best setting. Parameter selection depends on the data, timeframe, objective, turnover, costs, and an out-of-sample validation design.

Historical example decision

A named historical security is not useful for this mechanism lesson. Controlled paths isolate the reason ER and SC change, while a market chart adds provider, adjustment, licensing, and hindsight ambiguity. No historical return or profitability claim is made.

Summary

KAMA is an EMA-shaped recursion with a path-sensitive update weight:

1. displacement divided by path length produces directionless ER;
2. ER blends slow and fast endpoint factors;
3. the blend is squared;
4. the result updates a recursively seeded average.

The hard part is not typing the formula. It is freezing the seed, warm-up, zero-path, time, adjustment, and reset contracts so every result is reproducible.

The next tutorial is MESA Adaptive Moving Average, which adapts from phase dynamics rather than path efficiency.