Technical analysis

The simple moving average: the arithmetic mean of the last len values of src, every bar weighted equally. It is the baseline average and the one traders mean by "the 50 day" and "the 200 day" on a daily chart.

sma(src: series number, len: number) -> series number

Returns

series number

First value

bar len - 1

version 1
study("50 and 200 day averages", overlay = true)

sma50  = sma(close, 50)
sma200 = sma(close, 200)

plot(sma50, "SMA 50", aqua)
plot(sma200, "SMA 200", orange, width = 2)

if crossUp(sma50, sma200)
    signal("GOLDEN CROSS", color = lime, at = "below", shape = "triangleUp")
if crossDown(sma50, sma200)
    signal("DEATH CROSS", color = red, at = "above", shape = "triangleDown")

Remarks. A 200 bar average has no value until bar 199, which on a daily NSE chart is roughly ten months of sessions, so load enough history before you judge the line. The sum is taken afresh over the window on every bar, oldest value first, and divided once by len. The cost per bar grows with len but not with the length of the chart. An absent value anywhere in the window makes that bar's average absent.

See also. ema(), wma(), ma(), sum()

The exponential moving average gives the newest value a weight of 2 / (len + 1) and the running average the rest, so recent bars count more and old bars fade away without ever dropping out abruptly. It reacts to a new move sooner than sma() of the same length, which makes it the usual choice for crossover systems.

ema(src: series number, len: number) -> series number

Returns

series number

First value

bar len - 1

version 1
study("EMA 9 and 21", overlay = true)

fastLen = input(9, "Fast", min = 1, max = 200)
slowLen = input(21, "Slow", min = 2, max = 400)

fast = ema(close, fastLen)
slow = ema(close, slowLen)

fastPlot = plot(fast, "EMA fast", aqua, width = 2)
slowPlot = plot(slow, "EMA slow", orange, width = 2)
fill(fastPlot, slowPlot, colorUp = fade(lime, 88), colorDown = fade(red, 88))

if crossUp(fast, slow)
    signal("BUY", color = lime, at = "below", shape = "arrowUp")
if crossDown(fast, slow)
    signal("SELL", color = red, at = "above", shape = "arrowDown")

The picture shows a 20 and 50 bar variant of this study on a daily SBIN chart, with the band shaded the same way and each crossing labelled Golden cross or Death cross in place of an arrow:

Remarks. The average is seeded on bar len - 1 with the simple average of the first len values, and is absent before that. It does not start from the first close and drift into shape, so the line you see is correct from its first point. Each later bar computes value * weight + previous * (1 - weight). With len of 9 the newest close carries 20 percent of the weight. If the source is absent on a bar after the seed, that bar's result is absent and the running value is held, so the next present bar carries on where the last one left off.

See also. sma(), rma(), dema(), tema(), crossUp()

The weighted moving average weights the last len values in a straight line: the newest value counts len times, the one before it len - 1 times, down to 1 for the oldest. At the same length it turns sooner than both sma() and ema(), and it forgets a bar completely once the bar leaves the window.

wma(src: series number, len: number) -> series number

Returns

series number

First value

bar len - 1

version 1
study("WMA against SMA", overlay = true)

len = input(20, "Length", min = 1, max = 500)

plot(wma(close, len), "WMA", lime, width = 2)
plot(sma(close, len), "SMA", fade(silver, 30))

Remarks. The weighted sum is divided once by len * (len + 1) / 2, the total of the weights. With len of 20 the newest bar carries 20 of 210 parts, just under 10 percent. hma() is built from three of these averages.

See also. sma(), hma(), swma()

The running moving average, often called Wilder's smoothing: an exponential average whose newest value gets a weight of 1 / len. It is the smoothing inside rsi(), atr() and adx(), and you reach for it when you rebuild or adapt one of those indicators yourself.

rma(src: series number, len: number) -> series number

Returns

series number

First value

bar len - 1

version 1
study("RSI built from rma", precision = 2, range = [0, 100])

len = input(14, "Length", min = 1, max = 200)

delta = change(close)
gain  = max(delta, 0)
loss  = max(-delta, 0)

avgGain = rma(gain, len)
avgLoss = rma(loss, len)
manual  = avgLoss == 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss)

plot(manual, "RSI by hand", purple, width = 2)
plot(rsi(close, len), "rsi()", fade(orange, 40))

The two lines in this example lie on top of each other, because this is how rsi() is defined.

Remarks. Seeded like ema(): on bar len - 1, with the simple average of the first len values. Each later bar computes (previous * (len - 1) + value) / len. A weight of 1 / len is the same decay as an ema of length 2 * len - 1, so rma(x, 14) moves about as slowly as ema(x, 27). Keep that in mind when you compare the two.

See also. ema(), rsi(), atr(), adx()

The Hull moving average combines weighted averages so that most of the lag cancels out: it follows price closely while staying smooth. Traders often colour it by its slope and treat a change of slope as a change of trend.

hma(src: series number, len: number) -> series number

Returns

series number

First value

bar len + round(sqrt(len)) - 2

version 1
study("Hull average", overlay = true)

len = input(55, "Length", min = 2, max = 500)
h = hma(close, len)

plot(h, "HMA", h > h[1] ? lime : red, width = 2)

Remarks. The recipe is wma(2 * wma(src, half) - wma(src, len), round(sqrt(len))), where half is floor(len / 2) held at a minimum of 1. The first value arrives on bar len + round(sqrt(len)) - 2, bar 60 for a length of 55. Because it removes lag by extrapolating, it can overshoot price at sharp turns.

See also. wma(), ema(), ma()

The double exponential moving average subtracts an average's own lag once: 2 * ema - ema(ema). It hugs price more closely than ema() of the same length.

dema(src: series number, len: number) -> series number

Returns

series number

First value

bar 2 * len - 2

version 1
study("DEMA against EMA", overlay = true)

len = input(20, "Length", min = 1, max = 300)

plot(ema(close, len), "EMA", fade(silver, 30))
plot(dema(close, len), "DEMA", aqua, width = 2)

Remarks. The second average is fed the first one's output, absent bars included, so it seeds on the first len values the first one produced. That gives the first value on bar 2 * len - 2, bar 38 for a length of 20.

See also. ema(), tema()

The triple exponential moving average applies the same lag correction twice: 3 * e1 - 3 * e2 + e3, where e1 is the ema of the source, e2 the ema of e1 and e3 the ema of e2. It is the fastest of the exponential family and the most prone to overshoot.

tema(src: series number, len: number) -> series number

Returns

series number

First value

bar 3 * len - 3

version 1
study("Triple EMA trend", overlay = true)

len = input(20, "Length", min = 1, max = 200)
t = tema(close, len)

plot(t, "TEMA", t > t[1] ? teal : maroon, width = 2)

Remarks. Three chained averages need three warmups, so the first value is on bar 3 * len - 3, bar 57 for a length of 20. trix() measures the rate of change of the same triple smoothing.

See also. dema(), ema(), trix()

The volume weighted moving average weights each value by the volume traded on its bar, so a heavily traded bar pulls the average more than a quiet one. When it sits above sma() of the same length, the higher closes came on heavier volume.

vwma(src: series number, len: number) -> series number

Returns

series number

First value

bar len - 1

version 1
study("VWMA against SMA", overlay = true)

len = input(20, "Length", min = 1, max = 500)

v = vwma(close, len)
s = sma(close, len)

vPlot = plot(v, "VWMA", orange, width = 2)
sPlot = plot(s, "SMA", fade(silver, 30))
fill(vPlot, sPlot, colorUp = fade(lime, 85), colorDown = fade(red, 85))

Remarks. It is the window sum of src * volume divided by the window sum of volume. It is absent where any bar in the window has no volume, and where the volume in the window adds up to zero. An index itself, such as NIFTY 50, trades no volume, so there is nothing to weight by on an index chart: chart the index future on NFO instead.

See also. sma(), vwap(), volume

The symmetric weighted moving average is a fixed four-bar smoothing with weights 1, 2, 2 and 1. It has no length to set. Use it to take the jitter out of an oscillator or a noisy series while adding only a bar and a half of lag.

swma(src: series number) -> series number

Returns

series number

First value

bar 3

version 1
study("Smoothed RSI", precision = 2, range = [0, 100])

r = rsi(close, 14)

plot(r, "RSI", fade(purple, 60))
plot(swma(r), "RSI, smoothed", purple, width = 2)
level(70, "Overbought", fade(red, 40))
level(30, "Oversold", fade(lime, 40))

Remarks. The result is (w3 + 2 * w2 + 2 * w1 + w0) / 6, where w0 is this bar's value and w3 the value three bars back. It needs four values, so it starts on bar 3 of its source: on rsi(close, 14), which starts on bar 14, it starts on bar 17.

See also. wma(), sma()

The Arnaud Legoux moving average weights the window with a bell curve whose peak you place. offset moves the peak between the oldest bar (0) and the newest (1), and sigma sets how narrow the bell is. It lets you choose your own balance between responsiveness and smoothness.

alma(
    src: series number,
    len: number,
    offset?: number = 0.85,
    sigma?: number = 6
) -> series number

Returns

series number

First value

bar len - 1

version 1
study("ALMA", overlay = true)

len    = input(21, "Length", min = 1, max = 500)
offset = input(0.85, "Offset", min = 0, max = 1, step = 0.05)
sigma  = input(6.0, "Sigma", min = 0.5, max = 20)

plot(alma(close, len, offset, sigma), "ALMA", aqua, width = 2)

Remarks. The peak sits at position offset * (len - 1), counting 0 as the oldest bar in the window. Each weight is exp(-(gap * gap) / (2 * spread * spread)), where gap is the distance from the peak and spread is len / sigma, and the weighted sum is divided by the total of the weights. A larger sigma narrows the bell so fewer bars near the peak carry the weight; a smaller one widens it toward an equal-weight average. The default offset of 0.85 leans toward recent bars.

See also. wma(), ema()

The linear regression value: fit a least squares straight line through the last len values and return the line's value on this bar. It tracks a steady trend closely, and the line's slope tells you how fast the trend is moving.

linreg(src: series number, len: number, offset?: number = 0) -> series number

Returns

series number

First value

bar len - 1

version 1
study("Regression line and slope", overlay = true)

len = input(50, "Length", min = 2, max = 500)

fitted = linreg(close, len)
slope  = fitted - linreg(close, len, 1)

plot(fitted, "Regression", slope > 0 ? lime : red, width = 2)

Remarks. The fit places the oldest bar of the window at 0 and this bar at len - 1. offset reads the same fitted line offset bars back without fitting it again, so linreg(src, len) - linreg(src, len, 1) is the slope per bar, as the example uses it. A length of 1 has no line to fit and returns none on every bar.

See also. sma(), correlation()

One call for six averages, chosen by name: "sma", "ema", "wma", "rma", "hma" or "vwma". Feed type from an input() with those options and the user can switch the average from the study's settings dialog without editing the script.

ma(src: series number, len: number, type?: string = "sma") -> series number

Returns

series number

First value

the named type's

version 1
study("Switchable average", overlay = true)

kind = input("ema", "Average", options = ["sma", "ema", "wma", "rma", "hma", "vwma"])
len  = input(20, "Length", min = 1, max = 500)

plot(ma(close, len, kind), "Average", aqua, width = 2)

Remarks. The result and its first value are exactly those of the named average. A literal type that is not one of the six is error OS3008 when you compile. A type that only arrives while the script runs and names none of the six gives none on every bar rather than silently drawing a different average. Each type keeps its own state, so switching type starts the new average from its own seed.

See also. sma(), ema(), keltner(), Inputs

A trailing band set a multiple of the average true range away from the bar's midpoint. In an uptrend the line trails below price and only rises; in a downtrend it trails above and only falls. When the close crosses through the line, it flips to the other side. It returns [line, direction], and direction is -1 while the line is below price (long) and 1 while it is above (short).

supertrend(factor?: number = 3, atrLen?: number = 10) -> array<number>

Returns

array<number>

First value

element 0 at bar atrLen, element 1 at bar atrLen

version 1
study("Supertrend", overlay = true)

factor = input(3.0, "Factor", min = 0.5, max = 10, step = 0.5)
atrLen = input(10, "ATR length", min = 1, max = 100)

st   = supertrend(factor, atrLen)
band = st[0]
dir  = st[1]

plot(dir == -1 ? band : none, "Up trend", lime, width = 2)
plot(dir == 1 ? band : none, "Down trend", red, width = 2)

if dir == -1 and dir[1] == 1
    signal("LONG", color = lime, at = "below", shape = "triangleUp")
if dir == 1 and dir[1] == -1
    signal("SHORT", color = red, at = "above", shape = "triangleDown")

A Supertrend with the same settings on a BHEL 15 minute chart, from a study that also shades between the line and the candles and labels each flip BUY or SELL in place of a triangle:

The example plots the line twice, once per direction, so each flip leaves a gap instead of a vertical jump across the candles. The flip tests compare with dir[1], which is absent on the line's first bar; == against an absent value is false, so no flip is marked there.

Remarks. The raw bands are hl2 + factor * atr(atrLen) and hl2 - factor * atr(atrLen). From bar to bar the lower band may only rise, unless the previous close fell below it, and the upper band may only fall, unless the previous close rose above it.

The line starts on the upper band, so on a rising chart the first values can read short (1) until the first close above that band flips it. While it follows the upper band it stays there as long as the close is at or below that band; while it follows the lower band it stays as long as the close is at or above it. An exact touch therefore does not flip it.

The first value arrives one bar after atr() has one, on bar atrLen, because the bands need a previous band and a previous close to trail against.

See also. psar(), atr(), barColor(), signal()

The parabolic stop and reverse: a stop that starts at the last swing extreme and moves toward price a little faster each time the trend makes a new extreme. When price reaches the stop, the trend is taken to have reversed and the stop jumps to the other side. It returns [sar, direction], with direction -1 while long and 1 while short, the same convention as supertrend().

psar(start?: number = 0.02, step?: number = 0.02, max?: number = 0.2) -> array<number>

Returns

array<number>

First value

element 0 at bar 1, element 1 at bar 1

version 1
study("Parabolic SAR", overlay = true)

p   = psar(0.02, 0.02, 0.2)
sar = p[0]
dir = p[1]

plot(dir == -1 ? sar : none, "SAR, long", lime, style = "lineWithMarkers")
plot(dir == 1 ? sar : none, "SAR, short", red, style = "lineWithMarkers")

if dir == -1 and dir[1] == 1
    signal("SAR LONG", color = lime, at = "below")
if dir == 1 and dir[1] == -1
    signal("SAR SHORT", color = red, at = "above")

Remarks. It is seeded on bar 1: the direction is up if bar 1 closed above bar 0, and the stop starts at bar 0's low when up or its high when down. The acceleration starts at start.

On each later bar, in this order:

1. The stop moves toward the extreme: stop + acceleration * (extreme - stop).
2. If a long stop is now above the bar's low (or a short stop below its high), the direction flips, the stop jumps to the extreme the old trend reached, and the acceleration returns to start.
3. Otherwise, a new extreme (a higher high while long, a lower low while short) raises the acceleration by step, up to max.

The stop is reported as computed: it is not pulled back outside the previous two bars' range, as some published versions do. A study that wants that clamp writes it itself.

See also. supertrend(), atr(), Exits and brackets

The average directional index and its two directional indicators. +DI measures how much of recent movement was upward and -DI how much was downward, each as a percentage of the true range. ADX measures how far apart they are, smoothed: the strength of the trend, whichever way it runs. It returns [adx, plusDI, minusDI].

adx(diLen?: number = 14, adxLen?: number = 14) -> array<number>

Returns

array<number>

First value

element 1 and 2 at bar diLen, element 0 at bar diLen + adxLen - 1

version 1
study("ADX and DI", precision = 2)

diLen  = input(14, "DI length", min = 1, max = 100)
adxLen = input(14, "ADX smoothing", min = 1, max = 100)

a = adx(diLen, adxLen)

plot(a[0], "ADX", orange, width = 2)
plot(a[1], "+DI", lime)
plot(a[2], "-DI", red)
level(25, "Trending", fade(gray, 40), "dotted")
level(20, "Weak", fade(gray, 60), "dotted")

An ADX above about 25 and rising is commonly read as a trending market, and one below 20 as a weak or sideways one. ADX says how strong the trend is, not which way it runs: for the direction, compare the two DI lines. +DI above -DI says buyers own the move.

Remarks. Upward movement is high - high[1] and downward movement is low[1] - low; on each bar only the larger one counts, and only if it is positive. Both movements and the true range are smoothed with rma() over diLen, and each DI is smoothed movement / smoothed range * 100. ADX is the rma() over adxLen of abs(+DI - -DI) / (+DI + -DI) * 100. The two DI lines start on bar diLen (bar 14 by default) because movement needs the previous bar, and ADX starts on bar diLen + adxLen - 1 (bar 27). The DI values are absent where the smoothed range is zero, and the ratio inside ADX counts as 0 on a bar where both DI values are zero.

See also. aroon(), chop(), rma(), trueRange()

Aroon measures how recently the window's highest high and lowest low were set, as a percentage. Aroon up is 100 when this bar set the high and falls toward 0 as the high ages; Aroon down does the same for the low. It returns [up, down]. A strong uptrend keeps Aroon up near 100 and Aroon down low.

aroon(len?: number = 14) -> array<number>

Returns

array<number>

First value

both elements at bar len

version 1
study("Aroon", precision = 2, range = [0, 100])

len = input(25, "Length", min = 1, max = 200)

ar = aroon(len)

plot(ar[0], "Aroon up", lime, width = 2)
plot(ar[1], "Aroon down", red, width = 2)
level(70, "Strong", fade(gray, 40), "dotted")
level(30, "Weak", fade(gray, 40), "dotted")

Remarks. Each line is 100 * (len - bars since the extreme) / len, measured over a window of len + 1 bars so that an extreme set exactly len bars ago still counts and a reading of 0 is possible. That extra bar is why the first value is on bar len. When two bars share the extreme, the more recent one counts. The Aroon oscillator is simply ar[0] - ar[1].

See also. adx(), highestBars(), lowestBars()

The Ichimoku cloud: five lines that together describe trend, support and momentum. The conversion and base lines are the midpoints of the highest high and lowest low over 9 and 26 bars. Span A is the average of those two, span B is the 52 bar midpoint, and the space between the spans forms the cloud. The lagging line is the close. It returns [conversion, base, spanA, spanB, lagging].

ichimoku(
    convLen?: number = 9,
    baseLen?: number = 26,
    spanLen?: number = 52
) -> array<number>

Returns

array<number>

First value

element by element at bar convLen - 1, baseLen - 1, baseLen - 1, spanLen - 1, baseLen - 1

version 1
study("Ichimoku cloud", overlay = true)

ich = ichimoku(9, 26, 52)

plot(ich[0], "Conversion", aqua)
plot(ich[1], "Base", maroon)
spanA = plot(ich[2], "Span A", lime, offset = 26)
spanB = plot(ich[3], "Span B", red, offset = 26)
fill(spanA, spanB, colorUp = fade(lime, 85), colorDown = fade(red, 85))
plot(ich[4], "Lagging", gray, offset = -26)

The spans come back on the bar they are computed on, not shifted. The plot's offset draws them 26 bars forward and the lagging line 26 bars back, which is how the cloud is traditionally shown. If you change baseLen, change the offsets to match. To compare today's close with the part of the cloud drawn above today's bar, read the spans 26 bars back:

version 1
study("Close above the cloud", overlay = true)

ich   = ichimoku()
spanA = ich[2]
spanB = ich[3]

cloudTop = max(spanA[26], spanB[26])

background(close > cloudTop ? fade(lime, 92) : none)

Remarks. Each value has its own first bar: conversion on bar convLen - 1, base, span A and lagging on bar baseLen - 1, and span B on bar spanLen - 1 (bars 8, 25 and 51 with the defaults). Span A is the average of the conversion and base values, not a midpoint over a window of its own. Returning the spans unshifted means you can compare them with anything else in the script directly.

See also. donchian(), plot(), Fills

The choppiness index, a 0 to 100 reading of whether the window trended or went sideways. It compares the distance price travelled bar by bar with the range it covered overall: a market that went straight up travels about its range and reads low, while one that went back and forth travels many times its range and reads high. Use it as a filter to switch between trend-following and range-trading rules.

chop(len?: number = 14) -> series number

Returns

series number

First value

bar len

version 1
study("Choppiness", precision = 2, range = [0, 100])

len = input(14, "Length", min = 2, max = 200)
c = chop(len)

plot(c, "Choppiness", silver, width = 2)
level(61.8, "Choppy", fade(red, 40))
level(38.2, "Trending", fade(lime, 40))

Remarks. The reading is 100 * log10(sum of true range / (highest high - lowest low)) / log10(len). Readings above 61.8 are commonly taken as choppy and below 38.2 as trending. Each true range here needs the previous close, so the first value is on bar len rather than len - 1. The result is absent when the range or the travelled distance is not above zero, and for a length of 1.

See also. adx(), trueRange(), atr()

The relative strength index: a 0 to 100 reading of how one-sided the recent changes were. It averages the up moves and the down moves separately and compares them. Readings above 70 are traditionally overbought and below 30 oversold, and many traders watch the 50 line as the boundary between bullish and bearish momentum.

rsi(src: series number, len?: number = 14) -> series number

Returns

series number

First value

bar len

version 1
study("RSI", precision = 2, range = [0, 100])

len = input(14, "Length", min = 1, max = 200)
r = rsi(close, len)

plot(r, "RSI", purple, width = 2)
level(70, "Overbought", fade(red, 40))
level(50, "Middle", fade(gray, 60))
level(30, "Oversold", fade(lime, 40))

if crossUp(r, 30)
    alert("RSI crossed back above 30", id = "rsi-oversold-exit")

Remarks. Each change src - src[1] is split into a gain and a loss, each is smoothed with rma() over len, and the result is 100 - 100 / (1 + averageGain / averageLoss). When the average loss is zero, including a window where price never moved, the result is 100. The example under rma() rebuilds it step by step. RSI of RSI, or RSI of any series, works the same way: pass the series as src.

See also. stochRsi(), mfi(), cmo(), rma(), level()

The stochastic oscillator places the close inside the window's range: 100 at the highest high, 0 at the lowest low. It returns [k, d], where %K is the position smoothed over smoothK bars and %D is %K smoothed over smoothD bars. With smoothK of 1 you get the fast stochastic; 3 gives the common slow stochastic.

stoch(len?: number = 14, smoothK?: number = 1, smoothD?: number = 3) -> array<number>

Returns

array<number>

First value

element 0 at bar len + smoothK - 2, element 1 at bar len + smoothK + smoothD - 3

version 1
study("Slow stochastic", precision = 2, range = [0, 100])

s = stoch(14, 3, 3)
k = s[0]
d = s[1]

plot(k, "%K", aqua, width = 2)
plot(d, "%D", orange)
level(80, "Overbought", fade(red, 40))
level(20, "Oversold", fade(lime, 40))

if crossUp(k, d) and k < 20
    signal("K UP", color = lime, at = "below", shape = "triangleUp")

Remarks. The raw position is 100 * (close - lowest low) / (highest high - lowest low) over len bars, using the bars' own highs and lows rather than the highest and lowest close. %K is sma() of that over smoothK and %D is sma() of %K over smoothD. With stoch(14, 3, 3), %K starts on bar 15 and %D on bar 17. The position is absent on a bar where the window's high equals its low.

See also. stochRsi(), williamsR(), donchian()

The stochastic RSI applies the stochastic position test to rsi() instead of to price: where does today's RSI sit within its own recent range? It moves faster than RSI and reaches its extremes far more often, so it suits short-term timing. It returns [k, d].

stochRsi(
    src: series number,
    rsiLen?: number = 14,
    stochLen?: number = 14,
    smoothK?: number = 3,
    smoothD?: number = 3
) -> array<number>

Returns

array<number>

First value

element 0 at bar rsiLen + stochLen + smoothK - 2

version 1
study("Stochastic RSI", precision = 2, range = [0, 100])

s = stochRsi(close, 14, 14, 3, 3)

plot(s[0], "%K", aqua, width = 2)
plot(s[1], "%D", orange)
level(80, "High", fade(red, 40))
level(20, "Low", fade(lime, 40))

Remarks. The window's high and low are taken from the RSI values themselves, over stochLen bars. %K starts on bar rsiLen + stochLen + smoothK - 2 and %D follows smoothD - 1 bars later: bars 29 and 31 with the defaults. When RSI makes a new high for the window on bar after bar, the raw reading sits at 100 (and at 0 for a run of new lows), so %K can stay pinned at an extreme through a steady trend. The raw reading is absent when RSI has not moved across the window, since its high then equals its low.

See also. rsi(), stoch()

Williams %R is the stochastic position on an inverted scale: 0 when the close is at the window's highest high and -100 at its lowest low. Readings above -20 are commonly called overbought and below -80 oversold.

williamsR(len?: number = 14) -> series number

Returns

series number

First value

bar len - 1

version 1
study("Williams %R", precision = 2, range = [-100, 0])

len = input(14, "Length", min = 1, max = 200)

plot(williamsR(len), "%R", red, width = 2)
level(-20, "Overbought", fade(red, 40))
level(-80, "Oversold", fade(lime, 40))

Remarks. It is computed as -100 * (highest high - close) / (highest high - lowest low), from the distance below the window high. It reads levels, not changes, so the first value is on bar len - 1. It is absent where the window's high equals its low.

See also. stoch(), stochRsi()

The commodity channel index measures how far the typical price, hlc3, sits from its own average, in units of its usual deviation. Readings beyond +100 or -100 mark a price that has moved unusually far from its mean, which traders read either as the start of a strong move or as stretched, depending on context.

cci(len?: number = 20) -> series number

Returns

series number

First value

bar len - 1

version 1
study("CCI", precision = 2)

len = input(20, "Length", min = 2, max = 200)
c = cci(len)

plot(c, "CCI", orange, width = 2)
level(100, "+100", fade(red, 40))
level(0, "Zero", fade(gray, 60))
level(-100, "-100", fade(lime, 40))

Remarks. The reading is (typical - sma(typical, len)) / (0.015 * mean deviation), where the mean deviation is the average absolute distance of the window's typical prices from their mean. It uses the mean absolute deviation, not the standard deviation: the 0.015 constant is calibrated for it, and a standard deviation would change every reading while still drawing a plausible line. The first value is on bar len - 1.

See also. hlc3, stdev(), bbPercent()

Moving average convergence divergence: the gap between a fast and a slow ema() of the source. It returns [macd, signal, histogram]: the gap itself, an ema() of the gap, and the difference between the two. The line crossing its signal and the histogram crossing zero are the classic momentum turns.

macd(
    src: series number,
    fast?: number = 12,
    slow?: number = 26,
    signal?: number = 9
) -> array<number>

Returns

array<number>

First value

element 0 at bar max(fast, slow) - 1, elements 1 and 2 at bar max(fast, slow) + signal - 2

version 1
study("MACD", precision = 2)

fastLen   = input(12, "Fast", min = 1, max = 200)
slowLen   = input(26, "Slow", min = 2, max = 400)
signalLen = input(9, "Signal", min = 1, max = 100)

m    = macd(close, fastLen, slowLen, signalLen)
line = m[0]
sig  = m[1]
hist = m[2]

plot(hist, "Histogram", hist >= 0 ? fade(lime, 40) : fade(red, 40), style = "histogram")
plot(line, "MACD", aqua, width = 2)
plot(sig, "Signal", orange)
level(0, "Zero", fade(gray, 60))

if crossUp(line, sig)
    signal("MACD UP", color = lime, at = "below", shape = "triangleUp")

Remarks. The line is ema(src, fast) - ema(src, slow). The signal average is fed the line from its first value, so it seeds on the first signal values the line produced, and the histogram is line - signal as reported. With the defaults the line starts on bar 25 and the signal and histogram on bar 33. The line is in price units, so a stock near 3,000 shows a much larger MACD than one near 300; use ppo() to compare them. Give the signal line a name other than signal: that is a library function, and assigning to it is error OS2002.

See also. ppo(), ema(), crossUp()

The percentage price oscillator is MACD expressed as a percentage of the slow average. Because it is scaled by price, a stock near 3,000 and one near 300 can be compared on the same axis, and so can the same stock years apart. It returns [ppo, signal, histogram].

ppo(
    src: series number,
    fast?: number = 12,
    slow?: number = 26,
    signal?: number = 9
) -> array<number>

Returns

array<number>

First value

as macd

version 1
study("PPO", precision = 2)

p    = ppo(close, 12, 26, 9)
hist = p[2]

plot(hist, "Histogram", hist >= 0 ? fade(lime, 40) : fade(red, 40), style = "histogram")
plot(p[0], "PPO", aqua, width = 2)
plot(p[1], "Signal", orange)
level(0, "Zero", fade(gray, 60))

Remarks. The line is 100 * (ema(src, fast) - ema(src, slow)) / ema(src, slow); the signal and histogram are formed exactly as in macd(), with the same first values.

See also. macd(), roc()

Momentum: the change in the source over a fixed distance, src - src[len]. Positive means price is higher than it was len bars ago, and the size says by how much, in price units.

mom(src: series number, len?: number = 10) -> series number

Returns

series number

First value

bar len

version 1
study("Momentum", precision = 2)

len = input(10, "Length", min = 1, max = 200)
m = mom(close, len)

plot(m, "Momentum", m >= 0 ? lime : red, style = "histogram")
level(0, "Zero", fade(gray, 60))

Remarks. The first value is on bar len, the first bar that has a value len bars behind it. It is not smoothed; tsi() is a smoothed relative of it and roc() expresses the same change as a percentage.

See also. roc(), change(), tsi()

Rate of change: the change over len bars as a percentage of the older value. On a daily chart, roc(close, 250) is roughly the one-year return in percent, since NSE and BSE trade about 250 sessions a year.

roc(src: series number, len?: number = 9) -> series number

Returns

series number

First value

bar len

version 1
study("Rate of change", precision = 2)

len = input(9, "Length", min = 1, max = 500)

plot(roc(close, len), "ROC", lime, width = 2)
level(0, "Zero", fade(gray, 60))

Remarks. The reading is 100 * (src - src[len]) / src[len], first available on bar len. It is absent where the older value is zero.

See also. mom(), ppo(), trix()

The Chande momentum oscillator: the sum of the up moves minus the sum of the down moves over the window, divided by their total, on a scale from -100 to 100. It is not smoothed, so a turn shows on the bar it happens. Readings beyond +50 or -50 are commonly read as strong momentum.

cmo(src: series number, len?: number = 9) -> series number

Returns

series number

First value

bar len

version 1
study("Chande momentum", precision = 2, range = [-100, 100])

len = input(9, "Length", min = 1, max = 200)

plot(cmo(close, len), "CMO", aqua, width = 2)
level(50, "+50", fade(red, 40))
level(0, "Zero", fade(gray, 60))
level(-50, "-50", fade(lime, 40))

Remarks. The reading is 100 * (rise - fall) / (rise + fall), where rise and fall are the window sums of the up and down changes. It is 100 when every change in the window was up and -100 when every change was down. It is absent when price did not change at all across the window. The first value is on bar len.

See also. rsi(), mom()

The true strength index smooths the bar-to-bar change twice, then divides by the size of the change smoothed the same way. The result, between -100 and 100, is a clean reading of the direction of momentum without the noise of mom().

tsi(src: series number, longLen?: number = 25, shortLen?: number = 13) -> series number

Returns

series number

First value

bar longLen + shortLen - 1

version 1
study("True strength index", precision = 2)

t   = tsi(close, 25, 13)
sig = ema(t, 7)

plot(t, "TSI", teal, width = 2)
plot(sig, "Signal", orange)
level(0, "Zero", fade(gray, 60))

Remarks. The reading is 100 * ema(ema(change, longLen), shortLen) / ema(ema(abs(change), longLen), shortLen), with the long length applied first. The first value is on bar longLen + shortLen - 1, bar 37 with the defaults. A signal line is not part of the call; the example makes one with ema().

See also. mom(), ema(), macd()

TRIX is the one-bar percentage change of a triple exponential average. The triple smoothing filters out short swings, so TRIX turns only on sustained changes of direction. The values are small, so give the study a few extra decimals.

trix(src: series number, len?: number = 18) -> series number

Returns

series number

First value

bar 3 * len - 2

version 1
study("TRIX", precision = 4)

len = input(18, "Length", min = 1, max = 100)
t = trix(close, len)

plot(t, "TRIX", fuchsia, width = 2)
plot(ema(t, 9), "Signal", orange)
level(0, "Zero", fade(gray, 60))

Remarks. It is 100 * (e3 - e3[1]) / e3[1], where e3 is ema(ema(ema(src, len), len), len). That is the percentage change of the average, not the change of its logarithm. The first value is on bar 3 * len - 2, bar 52 for a length of 18.

See also. tema(), roc()

The detrended price oscillator removes the trend from price so that shorter cycles stand out. It subtracts a moving average taken from about half a window ago, and the peaks and troughs that remain show the rhythm of the swings. Measure the bars between its peaks to estimate a cycle length.

dpo(src: series number, len?: number = 21) -> series number

Returns

series number

First value

bar len + floor(len / 2)

version 1
study("Detrended price", precision = 2)

len = input(21, "Length", min = 2, max = 200)

plot(dpo(close, len), "DPO", silver, width = 2)
level(0, "Zero", fade(gray, 60))

Remarks. The reading is src - sma(src, len)[floor(len / 2) + 1]: this bar's value less the simple average as it stood floor(len / 2) + 1 bars ago. It is reported on the current bar, not drawn back in time. The first value is on bar len + floor(len / 2), bar 31 for a length of 21.

See also. sma(), linreg()

The ultimate oscillator blends buying pressure over three windows, 7, 14 and 28 bars by default, so that no single length dominates. It reads from 0 to 100, with 70 and 30 as the usual overbought and oversold levels.

ultimateOsc(len1?: number = 7, len2?: number = 14, len3?: number = 28) -> series number

Returns

series number

First value

bar max(len1, len2, len3)

version 1
study("Ultimate oscillator", precision = 2, range = [0, 100])

u = ultimateOsc(7, 14, 28)

plot(u, "UO", orange, width = 2)
level(70, "Overbought", fade(red, 40))
level(30, "Oversold", fade(lime, 40))

Remarks. Buying pressure is close - min(low, previous close) and the bar's range is max(high, previous close) - min(low, previous close). At each length the window sum of pressure is divided by the window sum of range, and the three ratios are blended as 100 * (4 * short + 2 * middle + long) / 7, the shortest window weighted most. Both terms need the previous close, so the first value is on bar max(len1, len2, len3), bar 28 by default.

See also. stoch(), rsi()

The awesome oscillator is the difference between a 5 bar and a 34 bar simple average of the bar midpoint, hl2. It is drawn as a histogram, coloured by whether each bar is higher than the one before.

awesomeOsc(fast?: number = 5, slow?: number = 34) -> series number

Returns

series number

First value

bar max(fast, slow) - 1

version 1
study("Awesome oscillator", precision = 2)

ao = awesomeOsc(5, 34)

plot(ao, "AO", ao > ao[1] ? lime : red, style = "histogram")
level(0, "Zero", fade(gray, 60))

Remarks. The reading is sma(hl2, fast) - sma(hl2, slow), first available on bar max(fast, slow) - 1, bar 33 by default.

See also. macd(), sma(), hl2

True range is the bar's full range including any gap from the previous close: the largest of high - low, abs(high - previous close) and abs(low - previous close). It is the building block of atr(), and on NSE, where most gaps happen at the 09:15 open, it captures the overnight move that high - low misses.

trueRange() -> series number

Returns

series number

First value

bar 0

version 1
study("True range and gaps", precision = 2)

tr     = trueRange()
gapped = tr > high - low

plot(tr, "True range", gapped ? orange : silver, style = "column")

When the true range is larger than the bar's own range, the previous close lay outside this bar: price gapped. The example colours those bars orange.

Remarks. On the chart's first bar there is no previous close, so the result there is high - low. This is the one deliberate exception in the library to absence spreading from a missing value: the bar's own range is a true statement about that bar, and it lets atr() start on bar len - 1.

See also. atr(), natr(), chop()

The average true range is the rma() of trueRange(): the typical distance this instrument moves in one bar, in its own price units. It is the working measure for stop distances, target distances and position sizes.

atr(len?: number = 14) -> series number

Returns

series number

First value

bar len - 1

version 1
study("ATR stop levels", overlay = true)

len  = input(14, "ATR length", min = 1, max = 100)
mult = input(2.0, "Multiple", min = 0.5, max = 10, step = 0.5)

a = atr(len)

plot(close - mult * a, "Long stop", fade(red, 30), style = "step")
plot(close + mult * a, "Short stop", fade(lime, 30), style = "step")

Remarks. Because true range has a value on bar 0, the first value is on bar len - 1. The value is in price units, rupees for an NSE stock and index points for an index future, so a 2 ATR stop on a NIFTY future and on a stock are very different amounts. To size a position so every trade risks the same amount, divide the amount by the stop distance; see Position and sizing.

See also. natr(), trueRange(), supertrend(), keltner()

The normalised average true range is atr() as a percentage of the close. It lets you compare volatility between instruments at different prices, or the same instrument across years.

natr(len?: number = 14) -> series number

Returns

series number

First value

bar len - 1

version 1
study("ATR percent", precision = 2)

hot = input(3.0, "High volatility above, percent", min = 0.1, max = 20)
n   = natr(14)

plot(n, "ATR %", n > hot ? orange : aqua, width = 2)
level(hot, "Threshold", fade(gray, 50))

Remarks. The reading is 100 * atr(len) / close, with the same first value as atr().

See also. atr(), hv()

The standard deviation of the last len values: how widely they are spread around their mean, in the source's own units. By default it divides by len (the population form, which is what the band indicators use); pass sample = true to divide by len - 1. A second form takes an array and returns the standard deviation of its elements.

stdev(src: series number, len: number, sample?: bool = false) -> series number
stdev(arr: array<number>) -> number

Returns

series number | number

First value

bar len - 1

version 1
study("Z-score", precision = 2)

len = input(20, "Length", min = 2, max = 500)

mean = sma(close, len)
dev  = stdev(close, len)
z    = dev > 0 ? (close - mean) / dev : none

plot(z, "Z-score", aqua, width = 2)
level(2, "+2", fade(red, 40))
level(0, "Mean", fade(gray, 60))
level(-2, "-2", fade(lime, 40))

The z-score says how many standard deviations the close sits from its average. The array form works on any list you build:

version 1
study("Spread of the last five closes", precision = 2)

closes = [close, close[1], close[2], close[3], close[4]]

plot(stdev(closes), "Deviation of five closes", silver)

Remarks. The series form computes the mean first and then the squared distances from it, in two passes, which stays accurate on prices where the values are large and the spread is small. The first value is on bar len - 1. The array form always uses the population divisor and returns none for an empty array or one holding an absent element.

See also. variance(), bollinger(), hv(), Collections

The variance of the last len values: the square of stdev(). It is in squared units (rupees squared for a price), which makes it hard to read on a chart but useful in calculations that add or compare spreads. sample = true switches to the len - 1 divisor.

variance(src: series number, len: number, sample?: bool = false) -> series number

Returns

series number

First value

bar len - 1

version 1
study("Variance, population and sample", precision = 4)

len = input(20, "Length", min = 2, max = 500)

plot(variance(close, len), "Population", silver)
plot(variance(close, len, sample = true), "Sample", orange)

Remarks. It is computed in two passes, the mean first and then the squared deviations from it, so it never comes out negative. The first value is on bar len - 1. With sample = true and a length of 1 there is nothing to divide by, and the result is absent.

See also. stdev(), covariance()

Historical volatility: the standard deviation of the bar-to-bar log returns, annualised. It is the realised counterpart of an option's implied volatility, so comparing the two on NIFTY or BANKNIFTY tells you whether options are pricing more or less movement than the index has actually shown. On Indian index options the implied side of that comparison comes from Black-76 pricing off the synthetic future; hv() gives you the realised side.

hv(
    src: series number,
    len?: number = 20,
    periodsPerYear?: number = 252
) -> series number

Returns

series number

First value

bar len

version 1
study("Historical volatility", precision = 2)

len     = input(20, "Length", min = 2, max = 500)
periods = input(252, "Bars per year", min = 1)

plot(hv(close, len, periods) * 100, "HV %", purple, width = 2)

Remarks. The reading is stdev(log(src / src[1]), len) * sqrt(periodsPerYear), with the population deviation. It is a proportion, not a percentage: 0.18 means 18 percent a year, so the example multiplies by 100 at the plot. periodsPerYear is the number of the chart's bars in a year: 252 for daily bars, and for intraday NSE bars the bars in the 09:15 to 15:30 session times the sessions, for example 75 * 252 (18900) on a 5-minute chart. A log return needs the previous bar, so the first value is on bar len.

See also. stdev(), natr(), log()

Bollinger Bands: a simple moving average with bands a multiple of the standard deviation above and below it. The bands widen when price becomes volatile and narrow when it calms. It returns [basis, upper, lower].

bollinger(src: series number, len?: number = 20, mult?: number = 2) -> array<number>

Returns

array<number>

First value

all elements at bar len - 1

version 1
study("Bollinger Bands", overlay = true)

len  = input(20, "Length", min = 2, max = 500)
mult = input(2.0, "Deviations", min = 0.5, max = 5, step = 0.5)

bb = bollinger(close, len, mult)

plot(bb[0], "Basis", orange)
upper = plot(bb[1], "Upper", aqua)
lower = plot(bb[2], "Lower", aqua)
fill(upper, lower, fade(aqua, 92))

Bollinger Bands with the same settings on a BHEL 15 minute chart, from the Bollinger Bands study in Example scripts, which draws the bands in blue and labels each close that crosses outside a band:

Remarks. The basis is sma(src, len), and the bands are basis + mult * stdev(src, len) and basis - mult * stdev(src, len), with the population deviation. All three values start on bar len - 1.

See also. bbWidth(), bbPercent(), keltner(), stdev()

Bollinger band width: the distance between the bands divided by the basis. It turns the bands' shape into a single number, so a squeeze, the narrow and quiet stretch that often comes before a large move, shows up as a low.

bbWidth(src: series number, len?: number = 20, mult?: number = 2) -> series number

Returns

series number

First value

bar len - 1

version 1
study("Band width squeeze", precision = 4)

len      = input(20, "Length", min = 2, max = 500)
lookback = input(120, "Squeeze lookback", min = 10, max = 1000)

w       = bbWidth(close, len, 2)
squeeze = w <= lowest(w, lookback)

plot(w, "Band width", squeeze ? orange : aqua, width = 2)

Remarks. The reading is (upper - lower) / basis, computed from the bands exactly as bollinger() reports them, so a study that plots both agrees to the last digit. A value of 0.05 means the bands are 5 percent of the basis apart. The first value is on bar len - 1.

See also. bollinger(), bbPercent(), keltner()

Percent B says where the source sits between the Bollinger Bands: 0 at the lower band, 0.5 at the basis and 1 at the upper band. It goes above 1 or below 0 when price closes outside the bands.

bbPercent(src: series number, len?: number = 20, mult?: number = 2) -> series number

Returns

series number

First value

bar len - 1

version 1
study("Percent B", precision = 2)

pb = bbPercent(close, 20, 2)

plot(pb, "%B", aqua, width = 2)
level(1, "Upper band", fade(red, 40))
level(0.5, "Basis", fade(gray, 60))
level(0, "Lower band", fade(lime, 40))

Remarks. The reading is (src - lower) / (upper - lower), from the bands as reported. It is absent on a bar where the bands meet: when every value in the window is equal, or when mult is 0. The first value is on bar len - 1.

See also. bollinger(), bbWidth(), stoch()

Keltner channels: a moving average of the close with bands a multiple of the average true range above and below it. Where Bollinger Bands widen with the spread of closes, Keltner channels widen with how far the bars actually travel, which makes them steadier. It returns [basis, upper, lower].

keltner(
    len?: number = 20,
    mult?: number = 2,
    atrLen?: number = 10,
    maType?: string = "ema"
) -> array<number>

Returns

array<number>

First value

all elements at bar max(len, atrLen) - 1

version 1
study("Keltner channel and squeeze", overlay = true)

len  = input(20, "Length", min = 2, max = 500)
mult = input(1.5, "ATR multiple", min = 0.5, max = 5, step = 0.25)

kc = keltner(len, mult, 10, "ema")
bb = bollinger(close, len, 2)

plot(kc[0], "Basis", orange)
upper = plot(kc[1], "Upper", teal)
lower = plot(kc[2], "Lower", teal)
fill(upper, lower, fade(teal, 92))

squeezed = bb[1] < kc[1] and bb[2] > kc[2]
background(squeezed ? fade(yellow, 90) : none)

The background marks a squeeze: the Bollinger Bands sitting inside the Keltner channel. During warmup either side of the comparison is absent, the condition takes the false branch, and nothing is painted.

Remarks. The basis is the average of the close over len, of the type maType names: "sma", "ema", "wma", "rma", "hma" or "vwma", as in ma(). The width is atr(atrLen), and the bands are basis + mult * atr and basis - mult * atr. All three values start on bar max(len, atrLen) - 1. The compiler does not check maType; a name that is not one of the six leaves all three values absent on every bar.

See also. bollinger(), atr(), ma(), donchian()

Donchian channels: the highest high and lowest low of the last len bars, with the midpoint between them. A close beyond the previous bar's channel is a breakout, the basis of many trend-following systems. It returns [upper, basis, lower], upper first.

donchian(len?: number = 20) -> array<number>

Returns

array<number>

First value

all elements at bar len - 1

version 1
study("Donchian breakout", overlay = true)

len = input(20, "Length", min = 2, max = 500)

dc    = donchian(len)
upper = dc[0]
lower = dc[2]

plot(upper, "Upper", lime, style = "step")
plot(dc[1], "Middle", fade(gray, 40), style = "step")
plot(lower, "Lower", red, style = "step")

if close > upper[1]
    signal("BREAKOUT", color = lime, at = "below", shape = "triangleUp")
if close < lower[1]
    signal("BREAKDOWN", color = red, at = "above", shape = "triangleDown")