Why Do Traders Use EMA? Exponential Moving Average Explained with Pine Script v6

When price moves sharply, a Simple Moving Average (SMA) reacts slowly because it weights every bar in its window equally. The Exponential Moving Average (EMA) solves this by applying a geometrically decaying multiplier, giving the most recent bars a heavier influence and allowing the line to track price changes more responsively. This article dissects the EMA formula mathematically, compares it to SMA behavior, and implements both from scratch in Pine Script v6.

1. The Mathematics Behind EMA

The EMA is defined by a recursive formula. Given a smoothing factor k and a source series P:

$$k = \frac{2}{n + 1}$$ $$\text{EMA}_t = P_t \cdot k + \text{EMA}_{t-1} \cdot (1 - k)$$

Where n is the period length. The multiplier k determines how aggressively the EMA responds to new data. A smaller n produces a larger k, meaning the EMA reacts faster. A larger n produces a smaller k, smoothing out noise more aggressively.

Weight Distribution Comparison

The table below shows how much weight each bar receives in a 5-period SMA versus a 5-period EMA (k = 2/6 ≈ 0.333):

Bar (most recent = 0)	SMA Weight	EMA Weight (n=5)
t (current)	20.00%	33.33%
t-1	20.00%	22.22%
t-2	20.00%	14.81%
t-3	20.00%	9.88%
t-4	20.00%	6.58%
t-5 and older	0.00% (excluded)	~13.18% (decaying tail)

The EMA assigns 33.33% of its weight to the current bar versus only 20% for SMA. This asymmetry is the core reason EMA reacts faster to price changes.

2. EMA Calculation Flow

flowchart TD A[Source Price at bar t] --> B{bar_index == 0?} B -- Yes --> C[EMA = src Seed with first price] B -- No --> D[Retrieve EMA from previous bar EMA_prev = EMA at t-1] D --> E[Compute smoothing factor k = 2 divided by n plus 1] E --> F[Apply recursive formula EMA_t = src times k plus EMA_prev times 1 minus k] C --> G[Store EMA_t] F --> G G --> H[Plot EMA_t on chart] H --> I[Advance to next bar t plus 1] I --> A

3. Key Behavioral Differences: EMA vs SMA

Property	SMA	EMA
Weight distribution	Equal across all n bars	Exponentially decaying (recent bars heavier)
Lag	Higher lag (≈ n/2 bars)	Lower lag
Noise sensitivity	Lower (more smoothing)	Higher (reacts to spikes)
Memory	Finite (only n bars)	Infinite (all past bars, decaying)
Initialization	Requires n bars before first value	Starts from bar_index 0 (recursive)
Pine Script function	`ta.sma()`	`ta.ema()`

Important Pine Script v6 fact: ta.ema() returns values starting from bar_index = 0 because it is recursive — it does not require a full window of bars to produce its first output. In contrast, ta.sma() returns na until bar_index == n - 1 because it needs exactly n bars to compute its first average.

4. Pine Script v6 Implementation

The script below plots both the built-in ta.ema() and a manually computed EMA side-by-side to verify mathematical equivalence, then overlays the SMA for visual lag comparison.

🔽 [Click to expand] View Full Pine Script Code

//@version=6
indicator(
     title      = "EMA vs SMA — Lag Comparison",
     shorttitle = "EMA/SMA",
     overlay    = true
 )

// ─── Inputs ───────────────────────────────────────────────────────────────────
int    emaLength = input.int(20,    "EMA Length",  minval = 1)
int    smaLength = input.int(20,    "SMA Length",  minval = 1)
float  src       = input.source(close, "Source")

// ─── Built-in EMA & SMA ───────────────────────────────────────────────────────
// ta.ema() requires simple int for its length parameter.
// emaLength is declared as input int, which satisfies simple int. ✓
// ta.sma() accepts series int for its length parameter. ✓
float builtinEma = ta.ema(src, emaLength)
float builtinSma = ta.sma(src, smaLength)

// ─── Manual EMA (from scratch) ────────────────────────────────────────────────
// Smoothing factor: k = 2 / (n + 1)
// Using input int in arithmetic: result is input float (not series float).
// This is fine — we only use it as a multiplier, not as a ta.*() length.
float k = 2.0 / (emaLength + 1)

// var persists the manual EMA value across bars.
// Initialized to na so we can seed it on the first bar.
var float manualEma = na

// Seed on bar 0 with the first source value.
// On subsequent bars, apply the recursive EMA formula.
if bar_index == 0
    manualEma := src
else
    // EMA_t = src_t * k + EMA_(t-1) * (1 - k)
    manualEma := src * k + manualEma[1] * (1.0 - k)

// ─── Plots ────────────────────────────────────────────────────────────────────
// Built-in EMA — blue, primary reference line
plot(
     builtinEma,
     title     = "Built-in EMA",
     color     = color.new(color.blue, 0),
     linewidth = 2
 )

// Manual EMA — orange dashed, should overlap built-in EMA exactly
plot(
     manualEma,
     title     = "Manual EMA",
     color     = color.new(color.orange, 0),
     linewidth = 1,
     style     = plot.style_linebr   // breaks at na (bar 0 seed edge)
 )

// SMA — red, shows higher lag vs EMA
plot(
     builtinSma,
     title     = "SMA",
     color     = color.new(color.red, 0),
     linewidth = 2
 )

// ─── Difference Label (last bar only) ─────────────────────────────────────────
// Display the numeric difference between EMA and SMA on the last confirmed bar.
// This quantifies how far apart the two averages are at any given moment.
if barstate.islast
    float diff = builtinEma - builtinSma
    string diffText =
         "EMA: "    + str.tostring(builtinEma, "#.##") +
         "\nSMA: "  + str.tostring(builtinSma, "#.##") +
         "\nΔ: "    + str.tostring(diff,       "#.##")
    label.new(
         x        = bar_index,
         y        = builtinEma,
         text     = diffText,
         style    = label.style_label_left,
         color    = color.new(color.gray, 80),
         textcolor = color.white,
         size     = size.small
     )

5. Understanding the Smoothing Factor k

The smoothing factor k is the single parameter that controls EMA responsiveness. Its relationship to period length is:

$$k = \frac{2}{n + 1} \quad \Rightarrow \quad n = \frac{2}{k} - 1$$

Period (n)	Smoothing Factor (k)	Weight on Current Bar	Behavior
5	0.3333	33.33%	Very fast, noisy
10	0.1818	18.18%	Fast, moderate noise
20	0.0952	9.52%	Balanced
50	0.0392	3.92%	Slow, smooth trend line
200	0.00995	0.995%	Very slow, long-term baseline

6. EMA Crossover Logic — Pine Script v6

A common application of EMA is the dual-EMA crossover: when a fast EMA crosses above a slow EMA, it signals upward momentum; when it crosses below, downward momentum. The following snippet demonstrates this using ta.crossover() and ta.crossunder().

🔽 [Click to expand] View EMA Crossover Signal Code

//@version=6
indicator(
     title      = "Dual EMA Crossover Signals",
     shorttitle = "EMA Cross",
     overlay    = true
 )

// ─── Inputs ───────────────────────────────────────────────────────────────────
// Both lengths are input int, which satisfies ta.ema()'s simple int requirement.
int   fastLen = input.int(9,  "Fast EMA Length", minval = 1)
int   slowLen = input.int(21, "Slow EMA Length", minval = 1)
float src     = input.source(close, "Source")

// ─── EMA Calculations ─────────────────────────────────────────────────────────
// ta.ema() starts from bar_index 0 — no na warm-up window equal to length.
float fastEma = ta.ema(src, fastLen)
float slowEma = ta.ema(src, slowLen)

// ─── Crossover Detection ──────────────────────────────────────────────────────
// ta.crossover(a, b)  → true when a crosses above b (a[1] < b[1] and a > b)
// ta.crossunder(a, b) → true when a crosses below b (a[1] > b[1] and a < b)
bool bullCross = ta.crossover(fastEma,  slowEma)
bool bearCross = ta.crossunder(fastEma, slowEma)

// ─── Plots ────────────────────────────────────────────────────────────────────
plot(fastEma, title = "Fast EMA", color = color.new(color.teal,   0), linewidth = 2)
plot(slowEma, title = "Slow EMA", color = color.new(color.purple, 0), linewidth = 2)

// ─── Signal Shapes ────────────────────────────────────────────────────────────
// plotshape() draws a marker on the chart at the crossover bar.
plotshape(
     bullCross,
     title    = "Bullish Cross",
     style    = shape.triangleup,
     location = location.belowbar,
     color    = color.new(color.green, 0),
     size     = size.small
 )

plotshape(
     bearCross,
     title    = "Bearish Cross",
     style    = shape.triangledown,
     location = location.abovebar,
     color    = color.new(color.red, 0),
     size     = size.small
 )

// ─── Background Highlight ─────────────────────────────────────────────────────
// Color the chart background based on which EMA is on top.
// fastEma > slowEma → bullish regime (green tint)
// fastEma < slowEma → bearish regime (red tint)
bgcolor(
     fastEma > slowEma
         ? color.new(color.green, 92)
         : color.new(color.red,   92),
     title = "Trend Background"
 )

7. Why EMA Starts at Bar 0 — The Recursive Initialization

Unlike ta.sma(), which requires exactly n bars before returning a non-na value, ta.ema() is recursive and begins computing from the very first bar (bar_index = 0). Pine Script's built-in ta.ema() seeds itself with the first available source value and then applies the recursive formula on every subsequent bar. This means:

On bar_index = 0: EMA = src (seed value)
On bar_index = 1: EMA = src * k + EMA[0] * (1 - k)
On bar_index = t: EMA = src * k + EMA[t-1] * (1 - k)

The practical consequence is that EMA plots have no leading na gap equal to their length, unlike SMA. The early bars of an EMA are influenced heavily by the seed value and stabilize after approximately 3× to 5× the period length of bars have elapsed — but they are never na due to insufficient data.

8. Pine Script v6 Type Qualifier Notes for EMA

Understanding Pine Script's type qualifier system is essential when using ta.ema() in dynamic contexts:

Pattern	Length Qualifier	Legal for ta.ema()?	Notes
`int len = 20`	const int	✅ Yes	const satisfies simple
`input.int(20)`	input int	✅ Yes	input satisfies simple
`int(ta.atr(14) * 2)`	series int	❌ No	series int fails simple int requirement
`var int len = 20; len := x`	series int	❌ No	var + reassignment forces series qualifier

Key rule: ta.ema() requires a simple int for its length parameter. Use input.int() or a literal constant. Never pass a series int (e.g., a dynamically computed value) as the length — this causes a compile error. If you need a dynamic-length moving average, use ta.sma() which accepts series int lengths.

9. Conclusion

EMA applies exponentially decaying weights via the multiplier $k = 2/(n+1)$, giving the current bar a weight of $k$ and all prior bars a geometrically shrinking share — this is why EMA tracks price changes faster than SMA.
Pine Script's ta.ema() starts from bar_index = 0 with no na warm-up gap equal to its length, because it is recursive; its length parameter requires simple int, so only input.int() or literal constants are valid lengths.
The manual EMA formula (src * k + prev * (1 - k)) produces output mathematically identical to ta.ema(), which can be verified by plotting their difference — confirming that the built-in function is a direct implementation of the standard recursive definition.

Ideas for Further Development

Double EMA (DEMA): Compute DEMA = 2 * EMA(src, n) - EMA(EMA(src, n), n) to further reduce lag while maintaining smoothness — implement this in Pine Script v6 using two sequential ta.ema() calls with input int lengths.
Adaptive EMA (KAMA): Replace the fixed smoothing factor k with a dynamically computed efficiency ratio, allowing the EMA to self-adjust its speed based on current market volatility — a natural extension once the fixed-k mechanics are fully understood.

Search This Blog

The Wealth Lab