Technical analysis

Worked out as max(high - low, abs(high - prev_close), abs(low - prev_close)). It keeps no memory of its own, so unlike the other ta functions it may be called anywhere in on bar, inside an if too.

Price points, in the symbol's quote currency.

Gives missing when a price it needs (this bar's high or low, or the previous close) is missing.

Every value in the window counts the same. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

It starts with ta.sma of its first length values. After that each bar is a * x + (1 - a) * previous, with a = 2 / (length + 1). It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the seeding again from scratch.

The same as ta.ema, but with a = 1 / length: it starts with ta.sma of its first length values, then each bar is a * x + (1 - a) * previous. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the seeding again.

The oldest value has weight 1 and the newest has weight length. The weighted sum is divided by length * (length + 1) / 2. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

Worked out as ta.sum(x * volume, length) / ta.sum(volume, length). It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length bars in a row where both x and volume are valid. A missing value starts the warm-up again. It is also missing when the volume in the window adds up to 0.

It fits the straight line that is closest to the last length values (least squares) and gives that line's value on this bar. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

The window is this bar and the length - 1 bars before it. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

The window is this bar and the length - 1 bars before it. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

It looks at the same window as ta.highest. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Bars.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

It looks at the same window as ta.lowest. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Bars.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

It takes the mean of the window, adds up the squared distance of each value from it, divides by length (not length - 1) and takes the square root. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

It takes the mean of the window, then the average of how far each value is from it, ignoring the sign. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

Use ta.cumsum for a running total that never forgets. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

A positive number means x is higher than it was, a negative one that it is lower. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Percent.

Gives missing for the first length bars, when x or its value length bars ago is missing, and when that earlier value is 0.

The current value is compared with the length values before it; it is not part of the window itself. 100 means x is at least as high as all of them. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Percent, 0 to 100.

Gives missing until it has seen length + 1 values, and whenever x or any of the previous length values is missing.

Each bar's change is split into a gain (or 0) and a loss (or 0). Both are smoothed with ta.rma over length, and the result is 100 - 100 / (1 + gains / losses). It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

A 0 to 100 scale.

Gives missing until it has seen length + 1 valid values in a row (the first bar has no change yet). A missing input gives missing and starts the warm-up again.

The window is always four bars, so there is no length to give. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing for the first three bars, and whenever any of the four values is missing.

It never forgets. Use ta.sum for a total over a fixed number of bars. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Missing values are skipped and do not reset the total. It gives missing only until the first valid value arrives.

ta.change(close) is the same as close - close[1], but it works on any number worked out in the script, not only on named series. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing for the first length bars, and when x or its value length bars ago is missing.

Worked out as ta.rma(ta.true_range(), length). It reads the chart's own high, low and close, so it takes no series. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Price points, in the symbol's quote currency.

Gives missing until it has seen length valid true ranges in a row. A missing price starts the warm-up again.

Worked out as 100 * (x - lowest(low)) / (highest(high) - lowest(low)) over the last length bars. Smooth it with ta.sma for the usual slow line. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

A 0 to 100 scale.

Gives missing until high and low have each had length valid values in a row, and whenever x is missing. A missing high or low starts the warm-up again.

Read the parts by name (m.hist) or take them in order: let (line, sig, hist) = ta.macd(close, 12, 26, 9). It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Each part is missing until it has warmed up: macd after slow valid values in a row (when slow is the longer length), signal and hist after signal - 1 more. A missing input starts all three again.

Read the parts by name (b.upper) or take them in order with let (basis, upper, lower) = ta.bands(close, 20). The standard deviation is the population one, as in ta.stdev. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

All three parts are missing until it has seen length valid values in a row, or when mult is missing. A missing input starts the warm-up again.

It remembers both values from the previous bar. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives false when a or b is missing now or was missing on the previous bar.

It remembers both values from the previous bar. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives false when a or b is missing now or was missing on the previous bar.

It remembers both values from the previous bar. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives false when a or b is missing now or was missing on the previous bar.

It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Bars.

Gives missing until cond has been true at least once. A Bool is never missing, so nothing else restarts it.

Only the latest occurrence + 1 matches are kept. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Compute first, decide after. Each place you write it keeps its own memory.

Gives missing until cond has been true at least once. If x was missing on that bar, the remembered value is missing until cond is true again.

The mean is ta.sma(x, length) and the deviation ta.mean_dev(x, length), worked out from the same window. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row, and on a bar where every value of the window is the same (the deviation is 0).

Each bar's flow is x * volume; it counts as buying when x rose from the previous bar and as selling when it fell. The result is 100 - 100 / (1 + buying / selling) over the last length bars. Pass the typical price hlc3 for the usual index. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

A 0 to 100 scale.

Gives missing until it has seen length + 1 bars with a value and a volume in a row; a missing volume starts it again.

The weight of the value at position k (0 the oldest) is exp(-(k - m)^2 / (2 * s^2)) with m = offset * (length - 1) and s = length / sigma; the weighted sum is divided by the sum of the weights. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing until it has seen length valid values in a row. A missing input gives missing and starts the warm-up again.

A value equal to the swing on either side means no swing. The answer comes right bars late, because only then are the later values known: read the swing's own bar with [right], such as high[2]. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing on bars that are not right bars after a swing, before left + right + 1 values were seen, and when any value of the window is missing.

A value equal to the swing on either side means no swing. The answer comes right bars late. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing on bars that are not right bars after a swing, before left + right + 1 values were seen, and when any value of the window is missing.

It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing only until x has had a value once.

Both averages are seeded like ta.ema. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing until both averages are seeded (about 2 * length - 1 valid values in a row).

All three averages are seeded like ta.ema. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing until the three averages are seeded (about 3 * length - 2 valid values in a row).

It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing until all six averages are seeded (about 6 * length - 5 valid values in a row).

It reads high, low and close. The second bar starts the trend from the direction of the closes; then each bar moves the stop by acceleration * (extreme - stop), never inside the previous two bars' range, and a bar that crosses the stop turns the trend and puts the stop at the old extreme. It gives exactly what the built-in Parabolic SAR draws. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing on the first bar only.

Missing values are skipped. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing only until x has had a value once.

Missing values are skipped. Together with ta.cummax it scales a series to 0 to 1 over everything seen so far. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

Gives missing only until x has had a value once.

Each bar first stores its own features and label. Then it walks the stored bars, oldest first, every stride-th one, and works out the Lorentzian distance to each: the sum of log(1 + |a - b|) over the features, which lets one wild feature count less than a squared distance would. A stored bar at least as far as the last one accepted joins the neighbours; once there are more than neighbors, the oldest leaves and the bar for acceptance becomes the distance three quarters down the list. The neighbours carry over from one bar to the next. It counts one step for each stored bar it compares, so a 2,000-bar window fits the step budget on long one-minute charts. It keeps its own memory, so it must run on every bar: write it straight in on bar (or in a higher block or a function), never inside a for loop or an if whose condition changes from bar to bar. Each place you write it keeps its own memory.

A bar whose features include missing never joins the neighbours. Gives 0 before any bar has joined.