# Pine function reference (PineTS 0.11.1)

> Every function, variable and constant the Tradequix engine implements. Verified = used in scripts the test suite runs. Not available = this feed cannot supply the data (returns na).

## Built-ins and plotting

Declarations, plotting, colouring the chart, and the small helpers every script uses: na, nz, fixnan.

### indicator (Verified)

```pine
indicator(title, shorttitle, overlay, format, precision, max_bars_back, max_lines_count, max_labels_count, max_boxes_count)
```

Declares the script an indicator. Must be the first statement after the version line.

- `title` (const string): The name shown in the legend and the catalogue.
- `shorttitle` (const string, optional): A shorter name for the legend.
- `overlay` (const bool, optional): true draws on the price chart; false (default) gives the script its own pane.
- `precision` (const int, optional): Decimal places for values in the legend.

### strategy (Verified)

```pine
strategy(title, shorttitle, overlay, initial_capital, default_qty_type, default_qty_value, pyramiding, commission_type, commission_value, slippage)
```

Declares the script a strategy, which can place simulated orders and produce a backtest.

- `title` (const string): The strategy's name.
- `overlay` (const bool, optional): Draw on the price chart.
- `initial_capital` (const float, optional): Starting equity. Default 1,000,000.
- `default_qty_type` (const string, optional): strategy.fixed, strategy.cash or strategy.percent_of_equity.
- `default_qty_value` (const float, optional): The order size in that unit.
- `pyramiding` (const int, optional): How many entries may stack in one direction. Default 0.
- `commission_type` (const string, optional): strategy.commission.percent, cash_per_contract or cash_per_order.
- `commission_value` (const float, optional): Commission in that unit.
- `slippage` (const int, optional): Slippage in ticks added to market fills.

### plot (Verified)

```pine
plot(series, title, color, linewidth, style, trackprice, histbase, offset, join, editable, show_last, display, force_overlay)
```

Draws a series on the chart, one value per bar.

- `series` (series int/float): The values to draw. na leaves a gap.
- `title` (const string, optional): Name in the legend and settings.
- `color` (series color, optional): Line colour; may change per bar.
- `linewidth` (input int, optional): Width in pixels, 1 to 4.
- `style` (input plot_style, optional): plot.style_line, _linebr, _stepline, _histogram, _columns, _area, _areabr, _circles, _cross.
- `offset` (simple int, optional): Shift the plot left (negative) or right by bars.
- `show_last` (input int, optional): Draw only the last N bars.
- `display` (input plot_display, optional): display.none computes without drawing.
- `force_overlay` (const bool, optional): Draw on the price chart from a pane script.

Returns: `A plot id, for fill().`

```pine
//@version=6
indicator("plot", overlay = true)
plot(ta.sma(close, 20), "SMA 20", color = color.orange, linewidth = 2)
```

### plotshape (Verified)

```pine
plotshape(series, title, style, location, color, offset, text, textcolor, size, show_last, display, force_overlay)
```

Draws a shape on bars where the series is true or a non-zero number.

- `series` (series bool/float): Where to draw. na, false and 0 draw nothing.
- `style` (input string, optional): shape.triangleup, triangledown, circle, cross, xcross, diamond, square, flag, arrowup, arrowdown, labelup, labeldown.
- `location` (input string, optional): location.abovebar, belowbar, top, bottom, absolute.
- `size` (const string, optional): size.tiny, small, normal, large, huge, auto.
- `text` (const string, optional): Text drawn with the shape.

```pine
//@version=6
indicator("plotshape", overlay = true)
plotshape(ta.crossover(ta.ema(close, 9), ta.ema(close, 21)), "Cross", style = shape.triangleup, location = location.belowbar, color = color.teal, size = size.small)
```

### plotchar (Verified)

```pine
plotchar(series, title, char, location, color, offset, text, textcolor, size, show_last, display)
```

Draws a single character on bars where the series is true or non-zero.

- `char` (input string): One character, for example "x" or "▲".

### plotarrow (Supported)

```pine
plotarrow(series, title, colorup, colordown, offset, minheight, maxheight, show_last, display)
```

Draws an up arrow for positive values and a down arrow for negative ones; zero and na draw nothing.

### plotcandle (Verified)

```pine
plotcandle(open, high, low, close, title, color, wickcolor, bordercolor, display)
```

Draws candles from your own OHLC series, for example Heikin Ashi computed in the script.

### plotbar (Supported)

```pine
plotbar(open, high, low, close, title, color, display)
```

Like plotcandle, but draws OHLC bars.

### hline (Verified)

```pine
hline(price, title, color, linestyle, linewidth, editable, display)
```

A fixed horizontal line at a price or level.

- `price` (input int/float): Where the line sits.
- `linestyle` (input hline_style, optional): hline.style_solid, style_dotted, style_dashed.

Returns: `An hline id, for fill().`

### fill (Verified)

```pine
fill(plot1, plot2, color, title, editable, fillgaps, display)  ·  fill(hline1, hline2, color, …)
```

Shades the area between two plots or two hlines.

- `plot1, plot2` (plot or hline): The ids returned by plot() or hline().
- `color` (series color, optional): Usually a transparent colour from color.new().

```pine
//@version=6
indicator("fill", overlay = true)
[m, u, l] = ta.bb(close, 20, 2)
p1 = plot(u, "Upper")
p2 = plot(l, "Lower")
fill(p1, p2, color = color.new(color.purple, 85))
```

### bgcolor (Verified)

```pine
bgcolor(color, offset, editable, show_last, title, display, force_overlay)
```

Tints the background behind each bar. na leaves it untouched.

### barcolor (Verified)

```pine
barcolor(color, offset, editable, show_last, title, display)
```

Recolours the chart's candles.

### na (Verified)

```pine
na(x)  ·  na
```

As a value, na means "no value". As a function, na(x) is true when x has no value.

### nz (Verified)

```pine
nz(source, replacement)
```

Replaces na with a value: 0 by default, or replacement.

```pine
//@version=6
indicator("nz")
change = close - close[1]
plot(nz(change), "Change, na as 0")
```

### fixnan (Supported)

```pine
fixnan(source)
```

Replaces na with the last value that was not na.

### alert (Verified)

```pine
alert(message, freq)
```

Emits an alert event when called. On Tradequix it appears in the editor console.

- `freq` (input string, optional): alert.freq_all, freq_once_per_bar, freq_once_per_bar_close.

### alertcondition (Verified)

```pine
alertcondition(condition, title, message)
```

Declares a condition that can be alerted on. Captured and shown in the editor console.

### timestamp (Supported)

```pine
timestamp(year, month, day, hour, minute, second)  ·  timestamp(timezone, year, …)
```

A time in milliseconds, for drawings with xloc.bar_time or comparing with time. The feed runs on UTC.

### max_bars_back (Supported)

```pine
max_bars_back(var, num)
```

Reserves history for a series that is referenced further back than the engine can infer.
- `bar_index` (Verified)
- `bool` (Supported)
- `day` (Supported)
- `dayofmonth` (Supported)
- `dayofweek` (Supported)
- `error` (Supported)
- `float` (Verified)
- `freq_all` (Supported)
- `freq_once_per_bar` (Supported)
- `freq_once_per_bar_close` (Supported)
- `hour` (Verified)
- `int` (Verified)
- `linestyle_dashed` (Supported)
- `linestyle_dotted` (Supported)
- `linestyle_solid` (Supported)
- `minute` (Supported)
- `month` (Supported)
- `second` (Supported)
- `string` (Supported)
- `style_area` (Supported)
- `style_areabr` (Supported)
- `style_circles` (Supported)
- `style_columns` (Supported)
- `style_cross` (Supported)
- `style_dashed` (Supported)
- `style_dotted` (Supported)
- `style_histogram` (Supported)
- `style_line` (Supported)
- `style_linebr` (Supported)
- `style_solid` (Supported)
- `style_stepline` (Supported)
- `style_stepline_diamond` (Supported)
- `style_steplinebr` (Supported)
- `weekofyear` (Supported)
- `year` (Verified)

## ta: technical analysis

Averages, oscillators, bands, trend studies, crosses, pivots and lookbacks. Each returns a series and handles its own warm-up.

### ta.sma (Verified)

```pine
ta.sma(source, length)
```

Simple moving average: the mean of the last length values.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.

Returns: `series float`

```pine
//@version=6
indicator("ta.sma", overlay = true)
plot(ta.sma(close, 50), "SMA 50", color = color.orange, linewidth = 2)
```

### ta.ema (Verified)

```pine
ta.ema(source, length)
```

Exponential moving average; recent bars weigh more.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.

Returns: `series float`

```pine
//@version=6
indicator("ta.ema", overlay = true)
plot(ta.ema(close, 21), "EMA 21", color = color.teal, linewidth = 2)
```

### ta.wma (Verified)

```pine
ta.wma(source, length)
```

Weighted moving average with linearly decreasing weights.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.hma (Verified)

```pine
ta.hma(source, length)
```

Hull moving average: smooth with little lag.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.rma (Verified)

```pine
ta.rma(source, length)
```

Wilder's moving average, the smoothing used inside RSI and ATR.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.vwma (Verified)

```pine
ta.vwma(source, length)
```

Volume-weighted moving average. Volume on this feed is a tick count.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.alma (Verified)

```pine
ta.alma(series, length, offset, sigma, floor)
```

Arnaud Legoux moving average: a Gaussian-weighted average.

- `series` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.
- `offset` (simple float): 0 to 1; higher reacts faster. 0.85 is usual.
- `sigma` (simple float): Smoothness; 6 is usual.

Returns: `series float`

### ta.swma (Supported)

```pine
ta.swma(source)
```

Symmetrically weighted average over a fixed 4 bars.

Returns: `series float`

### ta.linreg (Verified)

```pine
ta.linreg(source, length, offset)
```

Linear regression line's value, offset bars from the end.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.
- `offset` (simple int): 0 for the current bar.

Returns: `series float`

### ta.rsi (Verified)

```pine
ta.rsi(source, length)
```

Relative Strength Index, 0 to 100.

- `source` (series float): The series to read, usually close.
- `length` (series int): Usually 14.

Returns: `series float`

```pine
//@version=6
indicator("ta.rsi")
r = ta.rsi(close, 14)
plot(r, "RSI", color = color.purple)
hline(70)
hline(30)
```

### ta.stoch (Verified)

```pine
ta.stoch(source, high, low, length)
```

Stochastic %K, unsmoothed. Smooth it with ta.sma for the classic %K and %D.

- `source` (series float): The series to read, usually close.
- `high` (series float): Usually high.
- `low` (series float): Usually low.
- `length` (series int): How many bars to look back.

Returns: `series float`

```pine
//@version=6
indicator("ta.stoch")
k = ta.sma(ta.stoch(close, high, low, 14), 3)
plot(k, "%K")
plot(ta.sma(k, 3), "%D", color = color.orange)
```

### ta.cci (Verified)

```pine
ta.cci(source, length)
```

Commodity Channel Index.

- `source` (series float): Usually hlc3.
- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.mfi (Verified)

```pine
ta.mfi(series, length)
```

Money Flow Index, RSI weighted by volume (tick count here).

- `series` (series float): Usually hlc3.
- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.mom (Verified)

```pine
ta.mom(source, length)
```

Momentum: source minus source length bars ago.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.roc (Verified)

```pine
ta.roc(source, length)
```

Rate of change, in percent.

- `source` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.tsi (Verified)

```pine
ta.tsi(source, short_length, long_length)
```

True Strength Index, -1 to 1.

Returns: `series float`

### ta.wpr (Verified)

```pine
ta.wpr(length)
```

Williams %R, -100 to 0.

- `length` (series int): How many bars to look back.

Returns: `series float`

### ta.cmo (Verified)

```pine
ta.cmo(series, length)
```

Chande Momentum Oscillator.

Returns: `series float`

### ta.atr (Verified)

```pine
ta.atr(length)
```

Average True Range: the typical bar range, smoothed with RMA.

- `length` (series int): Usually 14.

Returns: `series float`

```pine
//@version=6
indicator("ta.atr")
plot(ta.atr(14), "ATR 14", color = color.orange)
```

### ta.tr (Verified)

```pine
ta.tr  ·  ta.tr(handle_na)
```

True range of the current bar.

Returns: `series float`

### ta.stdev (Verified)

```pine
ta.stdev(source, length, biased)
```

Standard deviation over length bars.

Returns: `series float`

### ta.dev (Supported)

```pine
ta.dev(source, length)
```

Mean absolute deviation from the SMA.

Returns: `series float`

### ta.variance (Supported)

```pine
ta.variance(source, length, biased)
```

Variance over length bars.

Returns: `series float`

### ta.bb (Verified)

```pine
ta.bb(series, length, mult)
```

Bollinger Bands.

- `series` (series float): The series to read, usually close.
- `length` (series int): How many bars to look back.
- `mult` (simple float): Standard deviations; 2 is usual.

Returns: `[middle, upper, lower]`

```pine
//@version=6
indicator("ta.bb", overlay = true)
[m, u, l] = ta.bb(close, 20, 2)
plot(m, "Basis", color = color.orange)
plot(u, "Upper")
plot(l, "Lower")
```

### ta.bbw (Supported)

```pine
ta.bbw(series, length, mult)
```

Bollinger Band width as a fraction of the basis.

Returns: `series float`

### ta.kc (Verified)

```pine
ta.kc(series, length, mult, useTrueRange)
```

Keltner Channels around an EMA.

Returns: `[middle, upper, lower]`

### ta.kcw (Supported)

```pine
ta.kcw(series, length, mult, useTrueRange)
```

Keltner Channel width.

Returns: `series float`

### ta.macd (Verified)

```pine
ta.macd(source, fastlen, slowlen, siglen)
```

MACD line, signal line and histogram.

Returns: `[macdLine, signalLine, histLine]`

```pine
//@version=6
indicator("ta.macd")
[m, s, h] = ta.macd(close, 12, 26, 9)
plot(h, "Hist", style = plot.style_columns, color = h >= 0 ? color.teal : color.red)
plot(m, "MACD")
plot(s, "Signal", color = color.orange)
```

### ta.dmi (Verified)

```pine
ta.dmi(diLength, adxSmoothing)
```

Directional Movement: +DI, -DI and ADX.

Returns: `[plus, minus, adx]`

```pine
//@version=6
indicator("ta.dmi")
[p, m, adx] = ta.dmi(14, 14)
plot(p, "+DI", color = color.teal)
plot(m, "-DI", color = color.red)
plot(adx, "ADX", color = color.orange)
```

### ta.supertrend (Verified)

```pine
ta.supertrend(factor, atrPeriod)
```

Supertrend line and direction. A negative direction is an up trend.

Returns: `[supertrend, direction]`

```pine
//@version=6
indicator("ta.supertrend", overlay = true)
[st, dir] = ta.supertrend(3, 10)
plot(st, "Supertrend", color = dir < 0 ? color.teal : color.red)
```

### ta.sar (Verified)

```pine
ta.sar(start, inc, max)
```

Parabolic SAR.

- `start` (simple float): 0.02 is usual.
- `inc` (simple float): 0.02 is usual.
- `max` (simple float): 0.2 is usual.

Returns: `series float`

```pine
//@version=6
indicator("ta.sar", overlay = true)
plot(ta.sar(0.02, 0.02, 0.2), "SAR", style = plot.style_cross, color = color.orange)
```

### ta.crossover (Verified)

```pine
ta.crossover(source1, source2)
```

true on the bar source1 moves from below source2 to above it.

Returns: `series bool`

```pine
//@version=6
indicator("ta.crossover", overlay = true)
f = ta.ema(close, 9)
s = ta.ema(close, 21)
plotshape(ta.crossover(f, s), style = shape.triangleup, location = location.belowbar, color = color.teal)
```

### ta.crossunder (Verified)

```pine
ta.crossunder(source1, source2)
```

true on the bar source1 moves from above source2 to below it.

Returns: `series bool`

### ta.cross (Verified)

```pine
ta.cross(source1, source2)
```

true on any cross, either direction.

Returns: `series bool`

### ta.highest (Verified)

```pine
ta.highest(source, length)
```

Highest value over the last length bars, including this one.

Returns: `series float`

```pine
//@version=6
indicator("ta.highest", overlay = true)
plot(ta.highest(high, 20), "20-bar high", color = color.teal)
plot(ta.lowest(low, 20), "20-bar low", color = color.red)
```

### ta.lowest (Verified)

```pine
ta.lowest(source, length)
```

Lowest value over the last length bars.

Returns: `series float`

### ta.highestbars (Verified)

```pine
ta.highestbars(source, length)
```

Offset (0 or negative) to the highest bar in the window.

Returns: `series int`

### ta.lowestbars (Verified)

```pine
ta.lowestbars(source, length)
```

Offset (0 or negative) to the lowest bar in the window.

Returns: `series int`

### ta.pivothigh (Verified)

```pine
ta.pivothigh(source, leftbars, rightbars)  ·  ta.pivothigh(leftbars, rightbars)
```

The pivot's price, reported rightbars after it; na elsewhere.

Returns: `series float`

Shift markers back with offset = -rightbars to draw them on the pivot bar.

```pine
//@version=6
indicator("ta.pivothigh", overlay = true)
ph = ta.pivothigh(high, 5, 5)
plotshape(not na(ph), style = shape.triangledown, location = location.abovebar, color = color.red, offset = -5)
```

### ta.pivotlow (Verified)

```pine
ta.pivotlow(source, leftbars, rightbars)  ·  ta.pivotlow(leftbars, rightbars)
```

The pivot low's price, reported rightbars after it; na elsewhere.

Returns: `series float`

### ta.valuewhen (Verified)

```pine
ta.valuewhen(condition, source, occurrence)
```

source's value on the occurrence-th most recent bar where condition was true (0 is the latest).

Returns: `series`

```pine
//@version=6
indicator("ta.valuewhen", overlay = true)
up = ta.crossover(close, ta.sma(close, 20))
plot(ta.valuewhen(up, close, 0), "Close at last cross", style = plot.style_stepline)
```

### ta.barssince (Supported)

```pine
ta.barssince(condition)
```

Bars since condition was last true; na before it ever was.

Returns: `series int`

### ta.change (Verified)

```pine
ta.change(source, length)
```

source minus source length bars ago (length defaults to 1). For bools, true when the value changed.

Returns: `series`

### ta.rising (Supported)

```pine
ta.rising(source, length)
```

true when source has risen on each of the last length bars.

Returns: `series bool`

### ta.falling (Supported)

```pine
ta.falling(source, length)
```

true when source has fallen on each of the last length bars.

Returns: `series bool`

### ta.cum (Supported)

```pine
ta.cum(source)
```

Running total of source since the first bar.

Returns: `series float`

### ta.correlation (Supported)

```pine
ta.correlation(source1, source2, length)
```

Pearson correlation of two series, -1 to 1.

Returns: `series float`

### ta.percentrank (Supported)

```pine
ta.percentrank(source, length)
```

Percent of the last length values below the current one.

Returns: `series float`

### ta.median (Supported)

```pine
ta.median(source, length)
```

Median over length bars.

Returns: `series float`

### ta.range (Supported)

```pine
ta.range(source, length)
```

Highest minus lowest over length bars.

Returns: `series float`

### ta.obv (Verified)

```pine
ta.obv
```

On Balance Volume. Meaningful on tick-count volume.

Returns: `series float`

### ta.accdist (Verified)

```pine
ta.accdist
```

Accumulation/Distribution. Treats volume as size, so it is approximate here.

Returns: `series float`

### ta.vwap (Verified)

```pine
ta.vwap(source)  ·  ta.vwap(source, anchor, stdev_mult)
```

Volume-weighted average price. Volume is a tick count on this feed, so treat it as approximate.

Returns: `series float  ·  [vwap, upper, lower]`
- `ta.cog` (Supported): Center of Gravity (COG) The cog (center of gravity) is an indicator based on statistics and the Fibonacci golden ratio.
- `ta.iii` (Supported): Intraday Intensity Index (III) Formula (as TradingView computes it; its reference manual shows a division by volume): (2 * close - high - low) / (high - low) * volume
- `ta.max` (Supported): Trailing Maximum (ta.max) Returns the all-time high value of `source` from the first bar of the chart up to the current bar.
- `ta.min` (Supported): Trailing Minimum (ta.min) Returns the all-time low value of `source` from the first bar of the chart up to the current bar.
- `ta.mode` (Supported): Mode Returns the mode of the series.
- `ta.nvi` (Supported): Negative Volume Index (NVI) Formula: If close or close[1] is 0, nvi = nvi[1] Else if volume < volume[1], nvi = nvi[1] + ((close - close[1]) / close[1]) * nvi[1] Else nvi = nvi[1] Initial value is 1.0
- `ta.percentile_linear_interpolation` (Supported): Percentile Linear Interpolation Calculates percentile using method of linear interpolation between the two nearest ranks.
- `ta.percentile_nearest_rank` (Supported): Percentile Nearest Rank Calculates percentile using method of Nearest Rank.
- `ta.pivot_point_levels` (Supported): ta.pivot_point_levels(type, anchor, developing) → array<float> of 11 levels [P, R1, S1, …, R5, S5].
- `ta.pvi` (Supported): Positive Volume Index (PVI) Formula: If close or close[1] is 0, pvi = pvi[1] Else if volume > volume[1], pvi = pvi[1] + ((close - close[1]) / close[1]) * pvi[1] Else pvi = pvi[1] Initial value is 1.0
- `ta.pvt` (Verified): Price-Volume Trend (PVT) The PVT function calculates the Price-Volume Trend, which is a cumulative total of volume adjusted by the percentage change in price.
- `ta.rci` (Supported): Rank Correlation Index: Spearman's rank correlation between the last `length` values of `source` and their bar order, scaled to -100..100 (100 = rose on every bar).
- `ta.wad` (Supported): Williams Accumulation/Distribution (WAD) Formula: trueHigh = math.max(high, close[1]) trueLow = math.min(low, close[1]) mom = ta.change(close) gain = (mom > 0) ?
- `ta.wvad` (Supported): Williams Variable Accumulation/Distribution (WVAD) Formula: (close - open) / (high - low) * volume

## math

Arithmetic, rounding, logs, trigonometry and aggregates.

### math.abs (Verified)

```pine
math.abs(number)
```

Absolute value.

### math.max (Verified)

```pine
math.max(number0, number1, …)
```

The largest of its arguments.

### math.min (Verified)

```pine
math.min(number0, number1, …)
```

The smallest of its arguments.

### math.avg (Verified)

```pine
math.avg(number0, number1, …)
```

The mean of its arguments.

### math.sum (Verified)

```pine
math.sum(source, length)
```

Sum of the last length values of a series.

### math.round (Supported)

```pine
math.round(number, precision)
```

Rounds to the nearest whole number, or to precision decimals.

### math.round_to_mintick (Supported)

```pine
math.round_to_mintick(number)
```

Rounds to the symbol's price step (syminfo.mintick).

### math.floor (Verified)

```pine
math.floor(number)
```

Largest whole number not greater than number.

### math.ceil (Supported)

```pine
math.ceil(number)
```

Smallest whole number not less than number.

### math.sign (Supported)

```pine
math.sign(number)
```

1, 0 or -1.

### math.pow (Supported)

```pine
math.pow(base, exponent)
```

base raised to exponent.

### math.sqrt (Verified)

```pine
math.sqrt(number)
```

Square root.

### math.log (Verified)

```pine
math.log(number)
```

Natural logarithm.

### math.log10 (Supported)

```pine
math.log10(number)
```

Base-10 logarithm.

### math.exp (Supported)

```pine
math.exp(number)
```

e raised to number.

### math.random (Supported)

```pine
math.random(min, max, seed)
```

A pseudo-random number between min and max.

### math.pi (Supported)

```pine
math.pi
```

π.
- `math.acos` (Supported)
- `math.asin` (Supported)
- `math.atan` (Supported)
- `math.cos` (Supported)
- `math.e` (Supported): Euler's number (e) The base of natural logarithms, approximately 2.718281828459045
- `math.ln` (Supported)
- `math.phi` (Supported): Golden ratio (φ, phi) Calculated as (1 + sqrt(5)) / 2, approximately 1.618033988749895
- `math.rphi` (Supported): Reciprocal of golden ratio (1/φ) Equal to phi - 1, approximately 0.6180339887498948
- `math.sin` (Supported)
- `math.tan` (Supported)
- `math.todegrees` (Supported): Converts an angle in radians to degrees.
- `math.toradians` (Supported): Converts an angle in degrees to radians.

## str: strings

Format numbers, build and search text for labels and tables.

### str.tostring (Verified)

```pine
str.tostring(value, format)
```

Text from a number or bool. format can be format.mintick, format.percent, or a pattern like "#.00".

### str.format (Verified)

```pine
str.format(formatString, arg0, arg1, …)
```

Fills {0}, {1}… in formatString, for example str.format("{0} at {1}", "RSI", r).

### str.tonumber (Supported)

```pine
str.tonumber(string)
```

Parses a number; na when it cannot.

### str.contains (Supported)

```pine
str.contains(source, str)
```

true when source contains str.

### str.length (Supported)

```pine
str.length(string)
```

Number of characters.

### str.split (Supported)

```pine
str.split(string, separator)
```

An array of strings.

### str.replace_all (Supported)

```pine
str.replace_all(source, target, replacement)
```

Replaces every occurrence.

### str.upper (Supported)

```pine
str.upper(source)  ·  str.lower(source)
```

Changes case.

### str.format_time (Supported)

```pine
str.format_time(time, format, timezone)
```

Formats a millisecond time, for example "yyyy-MM-dd HH:mm". The feed runs on UTC.
- `str.endswith` (Supported)
- `str.lower` (Supported)
- `str.match` (Supported)
- `str.pos` (Supported)
- `str.repeat` (Supported)
- `str.replace` (Supported)
- `str.startswith` (Supported)
- `str.substring` (Supported)
- `str.trim` (Supported)

## input

Every input becomes a field in the indicator's settings. See the Inputs guide for how saved values behave.

### input.int (Verified)

```pine
input.int(defval, title, minval, maxval, step, tooltip, inline, group, confirm, options)
```

A whole-number field.

### input.float (Verified)

```pine
input.float(defval, title, minval, maxval, step, tooltip, inline, group, confirm, options)
```

A decimal field.

### input.bool (Verified)

```pine
input.bool(defval, title, tooltip, inline, group, confirm)
```

A checkbox.

### input.string (Verified)

```pine
input.string(defval, title, options, tooltip, inline, group, confirm)
```

Text, or a dropdown when options is given.

### input.color (Verified)

```pine
input.color(defval, title, tooltip, inline, group, confirm)
```

A colour picker.

### input.source (Verified)

```pine
input.source(defval, title, tooltip, inline, group)
```

A choice of price series: close, open, hl2, hlc3, ohlc4…

### input.timeframe (Supported)

```pine
input.timeframe(defval, title, options, tooltip, inline, group, confirm)
```

A timeframe picker for request.security.

### input.text_area (Supported)

```pine
input.text_area(defval, title, tooltip, group, confirm)
```

Multi-line text.

### input.enum (Supported)

```pine
input.enum(defval, title, options, tooltip, inline, group, confirm)
```

A dropdown of an enum's members.
- `input.price` (Supported)
- `input.session` (Supported)
- `input.symbol` (Supported)
- `input.time` (Supported)

## request: other data

Other timeframes work. Company, economic and order-flow data are not in this feed and return na with a warning.

### request.security (Supported)

```pine
request.security(symbol, timeframe, expression, gaps, lookahead, ignore_invalid_symbol, currency, calc_bars_count)
```

Evaluates expression on another timeframe of the chart's symbol.

Use syminfo.tickerid. Fourteen timeframes come from the feed; others are aggregated; under 5 seconds is refused. At most 40 request contexts per script.

### request.security_lower_tf (Supported)

```pine
request.security_lower_tf(symbol, timeframe, expression, ignore_invalid_symbol, currency, ignore_invalid_timeframe, calc_bars_count)
```

An array of the lower-timeframe values inside each chart bar.

### request.financial (Not available)

```pine
request.financial(symbol, financial_id, period, …)
```

Not available on this feed: returns na with a warning.

### request.earnings (Not available)

```pine
request.earnings(ticker, field, …)
```

Not available on this feed: returns na with a warning.

### request.dividends (Not available)

```pine
request.dividends(ticker, field, …)
```

Not available on this feed: returns na with a warning.

### request.economic (Not available)

```pine
request.economic(country_code, field, …)
```

Not available on this feed: returns na with a warning.

### request.footprint (Not available)

```pine
request.footprint(…)
```

Needs order-flow data, which this feed does not carry. Returns na with a warning.
- `request.currency_rate` (Supported): request.currency_rate(from, to, ignore_invalid_currency): 1 for a currency to itself (as on TradingView); otherwise there is no exchange-rate source, so na with a warning (see unsupportedRequest).
- `request.quandl` (Not available): No source of Nasdaq Data Link / Quandl data (request.quandl): na, with a warning (see unsupportedRequest).
- `request.seed` (Supported): No source of Pine Seeds data (request.seed): na, with a warning (see unsupportedRequest).
- `request.splits` (Not available): No source of split data (request.splits): na, with a warning (see unsupportedRequest).

## strategy

Orders and the backtest's running statistics. Declare strategy() instead of indicator() to use them.

### strategy.entry (Verified)

```pine
strategy.entry(id, direction, qty, limit, stop, oca_name, oca_type, comment, alert_message)
```

Opens or adds to a position. An entry in the opposite direction reverses it.

- `id` (series string): Names the entry; exits refer to it.
- `direction` (strategy_direction): strategy.long or strategy.short.

```pine
//@version=6
strategy("strategy.entry", overlay = true)
if ta.crossover(ta.ema(close, 9), ta.ema(close, 21))
    strategy.entry("Long", strategy.long)
if ta.crossunder(ta.ema(close, 9), ta.ema(close, 21))
    strategy.close("Long")
```

### strategy.exit (Verified)

```pine
strategy.exit(id, from_entry, qty, qty_percent, profit, limit, loss, stop, trail_price, trail_points, trail_offset, …)
```

Attaches a take-profit and/or stop-loss to an entry. limit/stop are prices; profit/loss are ticks.

### strategy.close (Verified)

```pine
strategy.close(id, comment, qty, qty_percent, alert_message, immediately)
```

Closes the position from entry id at market.

### strategy.close_all (Supported)

```pine
strategy.close_all(comment, alert_message, immediately)
```

Closes every open position.

### strategy.order (Supported)

```pine
strategy.order(id, direction, qty, limit, stop, …)
```

A raw order without entry's reversal logic.

### strategy.cancel (Supported)

```pine
strategy.cancel(id)  ·  strategy.cancel_all()
```

Cancels pending orders.

### strategy.position_size (Supported)

```pine
strategy.position_size
```

Current position: positive long, negative short, 0 flat.

### strategy.netprofit (Supported)

```pine
strategy.netprofit
```

Profit of closed trades so far.

### strategy.openprofit (Supported)

```pine
strategy.openprofit
```

Unrealised profit of the open position.

### strategy.equity (Supported)

```pine
strategy.equity
```

Initial capital + net profit + open profit.
- `strategy.account_currency` (Supported): Account currency configured in the strategy() declaration's `currency=`.
- `strategy.avg_losing_trade` (Supported): Average loss across losing closed trades, returned as a POSITIVE number (Pine convention: average loss is unsigned).
- `strategy.avg_losing_trade_percent` (Supported): Average per-trade loss (as a SIGNED negative percent) across losing closed trades.
- `strategy.avg_trade` (Supported): Average profit/loss across all closed trades (post-commission).
- `strategy.avg_trade_percent` (Supported): Average per-trade return as a percent.
- `strategy.avg_winning_trade` (Supported): Average profit across winning closed trades.
- `strategy.avg_winning_trade_percent` (Supported): Average per-trade return (as a percent) across winning closed trades.
- `strategy.cancel_all` (Supported): Cancel all pending orders — entries AND exits, as on TradingView.
- `strategy.cash` (Supported): Constant for order sizing type: cash Used in default_qty_type parameter
- `strategy.closedtrades` (Supported): Pine's `strategy.closedtrades` serves a dual role: - As a scalar: a series int count of closed trades.
- `strategy.convert_to_account` (Supported): Convert a value from the symbol's currency to the account currency.
- `strategy.convert_to_symbol` (Supported): Inverse of convert_to_account: from account currency → symbol currency.
- `strategy.default_entry_qty` (Supported): Returns the qty that would be used for an entry at the given fill price, given the strategy's `default_qty_type` and `default_qty_value`.
- `strategy.eventrades` (Supported): Count of breakeven (profit === 0) closed trades.
- `strategy.fixed` (Supported): Constant for order sizing type: fixed Used in default_qty_type parameter
- `strategy.grossloss` (Supported): Total currency value of all completed losing trades, as a POSITIVE number (the absolute sum of losses).
- `strategy.grossloss_percent` (Supported): strategy.grossloss as a percent of initial capital.
- `strategy.grossprofit` (Supported): Total currency value of all completed winning trades (post-commission).
- `strategy.grossprofit_percent` (Supported): strategy.grossprofit as a percent of initial capital.
- `strategy.initial_capital` (Supported): The initial capital configured on the strategy() declaration.
- `strategy.long` (Verified): Constant representing long direction
- `strategy.losstrades` (Supported): Count of closed trades with profit < 0.
- `strategy.margin_liquidation_price` (Supported): Price at which the current leveraged position would be force-liquidated.
- `strategy.max_contracts_held_all` (Supported): Peak |position_size| seen across the run.
- `strategy.max_contracts_held_long` (Supported): Peak long-side position_size seen.
- `strategy.max_contracts_held_short` (Supported): Peak |short-side position_size| seen.
- `strategy.max_drawdown` (Supported): Maximum peak-to-trough equity drawdown over the whole run (currency).
- `strategy.max_drawdown_percent` (Supported): Maximum drawdown percent.
- `strategy.max_runup` (Supported): Maximum equity run-up over the whole run (currency).
- `strategy.max_runup_percent` (Supported): Maximum equity run-up percent.
- `strategy.netprofit_percent` (Supported): Realized net profit expressed as a percent of initial capital.
- `strategy.openprofit_percent` (Supported): Unrealized P&L expressed as a percent of initial capital.
- `strategy.opentrades` (Supported): Pine's `strategy.opentrades` mirrors strategy.closedtrades' dual-role pattern — see that file's header for the rationale.
- `strategy.percent_of_equity` (Verified): Constant for order sizing type: percent_of_equity Used in default_qty_type parameter
- `strategy.position_avg_price` (Supported): Weighted-average entry price of the current open position.
- `strategy.position_entry_name` (Supported): Id string of the entry that initially opened the current position.
- `strategy.risk` (Supported): `strategy.risk` is a nested namespace with 6 setter functions that configure pre-trade risk rules.
- `strategy.short` (Verified): Constant representing short direction
- `strategy.wintrades` (Supported): Count of closed trades with profit > 0.

## color

Named colours and functions to make your own. Transparency runs 0 (opaque) to 100 (invisible).

### color.new (Verified)

```pine
color.new(color, transp)
```

The same colour with transparency transp (0 to 100).

### color.rgb (Supported)

```pine
color.rgb(red, green, blue, transp)
```

A colour from 0 to 255 channels.

### color.from_gradient (Verified)

```pine
color.from_gradient(value, bottom_value, top_value, bottom_color, top_color)
```

A colour between two, by where value sits in a range.

```pine
//@version=6
indicator("color.from_gradient")
r = ta.rsi(close, 14)
plot(r, "RSI", color = color.from_gradient(r, 30, 70, color.red, color.teal), linewidth = 3)
```

### color.r (Supported)

```pine
color.r(color)  ·  color.g · color.b · color.t
```

Read one channel or the transparency.
- `color.aqua` (Supported)
- `color.b` (Supported)
- `color.black` (Supported)
- `color.blue` (Supported)
- `color.fuchsia` (Supported)
- `color.g` (Supported)
- `color.gray` (Verified)
- `color.green` (Supported)
- `color.lime` (Supported)
- `color.maroon` (Supported)
- `color.navy` (Supported)
- `color.olive` (Supported)
- `color.orange` (Verified)
- `color.purple` (Verified)
- `color.red` (Verified)
- `color.silver` (Supported)
- `color.t` (Supported)
- `color.teal` (Verified)
- `color.white` (Verified)
- `color.yellow` (Supported)

## Drawings: label, line, box, table

Objects placed at coordinates. Create with *.new(), keep the id to update or delete it. See the Drawings guide.

### label.new (Verified)

```pine
label.new(x, y, text, xloc, yloc, color, style, textcolor, size, textalign, tooltip, force_overlay)
```

A text label at a bar and price.

### line.new (Verified)

```pine
line.new(x1, y1, x2, y2, xloc, extend, color, style, width, force_overlay)
```

A straight line between two points. extend.right/left/both continues it.

### box.new (Verified)

```pine
box.new(left, top, right, bottom, border_color, border_width, border_style, extend, xloc, bgcolor, text, …)
```

A rectangle.

### table.new (Verified)

```pine
table.new(position, columns, rows, bgcolor, frame_color, frame_width, border_color, border_width, force_overlay)
```

A grid pinned to a corner: position.top_right and so on.

### table.cell (Verified)

```pine
table.cell(table_id, column, row, text, width, height, text_color, text_halign, text_valign, text_size, bgcolor, tooltip)
```

Sets one cell. Columns and rows count from 0.

### linefill.new (Supported)

```pine
linefill.new(line1, line2, color)
```

Shades between two lines.

### polyline.new (Supported)

```pine
polyline.new(points, curved, closed, xloc, line_color, fill_color, line_style, line_width, force_overlay)
```

A path through an array of chart.point.
- `label.all` (Supported)
- `label.copy` (Supported)
- `label.delete` (Supported)
- `label.get_text` (Supported)
- `label.get_x` (Supported)
- `label.get_y` (Supported)
- `label.set_color` (Supported)
- `label.set_point` (Supported)
- `label.set_size` (Supported)
- `label.set_style` (Supported)
- `label.set_text` (Supported)
- `label.set_text_font_family` (Supported)
- `label.set_text_formatting` (Supported)
- `label.set_textalign` (Supported)
- `label.set_textcolor` (Supported)
- `label.set_tooltip` (Supported)
- `label.set_x` (Supported)
- `label.set_xloc` (Supported)
- `label.set_xy` (Supported)
- `label.set_y` (Supported)
- `label.set_yloc` (Supported)
- `label.style_arrowdown` (Supported)
- `label.style_arrowup` (Supported)
- `label.style_circle` (Supported)
- `label.style_cross` (Supported)
- `label.style_diamond` (Supported)
- `label.style_flag` (Supported)
- `label.style_label_center` (Supported)
- `label.style_label_down` (Verified)
- `label.style_label_left` (Supported)
- `label.style_label_lower_left` (Supported)
- `label.style_label_lower_right` (Supported)
- `label.style_label_right` (Supported)
- `label.style_label_up` (Verified)
- `label.style_label_upper_left` (Supported)
- `label.style_label_upper_right` (Supported)
- `label.style_none` (Supported)
- `label.style_square` (Supported)
- `label.style_text_outline` (Supported)
- `label.style_triangledown` (Supported)
- `label.style_triangleup` (Supported)
- `label.style_xcross` (Supported)
- `line.all` (Supported)
- `line.copy` (Supported)
- `line.delete` (Supported)
- `line.get_price` (Supported)
- `line.get_x1` (Supported)
- `line.get_x2` (Supported)
- `line.get_y1` (Supported)
- `line.get_y2` (Supported)
- `line.linefills` (Supported)
- `line.set_color` (Supported)
- `line.set_extend` (Supported)
- `line.set_first_point` (Supported)
- `line.set_second_point` (Supported)
- `line.set_style` (Supported)
- `line.set_width` (Supported)
- `line.set_x1` (Supported)
- `line.set_x2` (Supported)
- `line.set_xloc` (Supported)
- `line.set_xy1` (Supported)
- `line.set_xy2` (Supported)
- `line.set_y1` (Supported)
- `line.set_y2` (Supported)
- `line.style_arrow_both` (Supported)
- `line.style_arrow_left` (Supported)
- `line.style_arrow_right` (Supported)
- `line.style_dashed` (Supported)
- `line.style_dotted` (Supported)
- `line.style_solid` (Supported)
- `box.all` (Supported)
- `box.copy` (Supported)
- `box.delete` (Supported)
- `box.get_bottom` (Supported)
- `box.get_left` (Supported)
- `box.get_right` (Supported)
- `box.get_top` (Supported)
- `box.set_bgcolor` (Supported)
- `box.set_border_color` (Supported)
- `box.set_border_style` (Supported)
- `box.set_border_width` (Supported)
- `box.set_bottom` (Supported)
- `box.set_bottom_right_point` (Supported)
- `box.set_extend` (Supported)
- `box.set_left` (Supported)
- `box.set_lefttop` (Supported)
- `box.set_right` (Supported)
- `box.set_rightbottom` (Supported)
- `box.set_text` (Supported)
- `box.set_text_color` (Supported)
- `box.set_text_font_family` (Supported)
- `box.set_text_formatting` (Supported)
- `box.set_text_halign` (Supported)
- `box.set_text_size` (Supported)
- `box.set_text_valign` (Supported)
- `box.set_text_wrap` (Supported)
- `box.set_top` (Supported)
- `box.set_top_left_point` (Supported)
- `box.set_xloc` (Supported)
- `table.all` (Supported)
- `table.cell_set_bgcolor` (Supported)
- `table.cell_set_height` (Supported)
- `table.cell_set_text` (Supported)
- `table.cell_set_text_color` (Supported)
- `table.cell_set_text_font_family` (Supported)
- `table.cell_set_text_formatting` (Supported)
- `table.cell_set_text_halign` (Supported)
- `table.cell_set_text_size` (Supported)
- `table.cell_set_text_valign` (Supported)
- `table.cell_set_tooltip` (Supported)
- `table.cell_set_width` (Supported)
- `table.clear` (Supported)
- `table.delete` (Supported)
- `table.merge_cells` (Supported)
- `table.set_bgcolor` (Supported)
- `table.set_border_color` (Supported)
- `table.set_border_width` (Supported)
- `table.set_frame_color` (Supported)
- `table.set_frame_width` (Supported)
- `table.set_position` (Supported)
- `linefill.all` (Supported)
- `linefill.delete` (Supported)
- `linefill.get_line1` (Supported)
- `linefill.get_line2` (Supported)
- `linefill.set_color` (Supported)
- `polyline.all` (Supported)
- `polyline.delete` (Supported)

## array, matrix, map

Collections of values. Up to 100,000 elements each.

### array.new (Verified)

```pine
array.new<type>(size, initial_value)  ·  array.new_float(size, initial_value)
```

Creates an array.

### array.push (Supported)

```pine
array.push(id, value)
```

Adds to the end.

### array.get (Supported)

```pine
array.get(id, index)
```

Reads an element. Out of range is a runtime error.

### array.size (Supported)

```pine
array.size(id)
```

Number of elements.

### array.shift (Supported)

```pine
array.shift(id)
```

Removes and returns the first element; with push, makes a rolling window.

### matrix.new (Supported)

```pine
matrix.new<type>(rows, columns, initial_value)
```

Creates a matrix.

### map.new (Supported)

```pine
map.new<keyType, valueType>()
```

Creates a map.

### map.put (Supported)

```pine
map.put(id, key, value)
```

Sets a key.
- `array.abs` (Supported)
- `array.avg` (Supported)
- `array.binary_search` (Supported)
- `array.binary_search_leftmost` (Supported)
- `array.binary_search_rightmost` (Supported)
- `array.clear` (Supported)
- `array.concat` (Supported)
- `array.copy` (Supported)
- `array.covariance` (Supported)
- `array.every` (Supported)
- `array.fill` (Supported)
- `array.first` (Supported)
- `array.from` (Supported)
- `array.includes` (Supported)
- `array.indexof` (Supported)
- `array.insert` (Supported)
- `array.join` (Supported): Joins the elements of the array into a string, separated by the separator (default: none).
- `array.last` (Supported)
- `array.lastindexof` (Supported)
- `array.max` (Supported)
- `array.median` (Supported)
- `array.min` (Supported)
- `array.mode` (Supported)
- `array.new_bool` (Supported)
- `array.new_box` (Supported)
- `array.new_color` (Supported)
- `array.new_float` (Supported)
- `array.new_int` (Supported)
- `array.new_label` (Supported)
- `array.new_line` (Supported)
- `array.new_linefill` (Supported)
- `array.new_string` (Supported)
- `array.new_table` (Supported)
- `array.percentile_linear_interpolation` (Supported)
- `array.percentile_nearest_rank` (Supported)
- `array.percentrank` (Supported)
- `array.pop` (Supported)
- `array.range` (Supported)
- `array.remove` (Supported)
- `array.reverse` (Supported)
- `array.set` (Supported)
- `array.slice` (Supported)
- `array.some` (Supported)
- `array.sort` (Supported)
- `array.sort_indices` (Supported)
- `array.standardize` (Supported)
- `array.stdev` (Supported)
- `array.sum` (Supported)
- `array.unshift` (Supported)
- `array.variance` (Supported)
- `matrix.add_col` (Supported)
- `matrix.add_row` (Supported)
- `matrix.avg` (Supported)
- `matrix.col` (Supported)
- `matrix.columns` (Supported)
- `matrix.concat` (Supported)
- `matrix.copy` (Supported)
- `matrix.det` (Supported)
- `matrix.diff` (Supported)
- `matrix.eigenvalues` (Supported)
- `matrix.eigenvectors` (Supported)
- `matrix.elements_count` (Supported)
- `matrix.fill` (Supported)
- `matrix.get` (Supported)
- `matrix.inv` (Supported)
- `matrix.is_antidiagonal` (Supported)
- `matrix.is_antisymmetric` (Supported)
- `matrix.is_binary` (Supported)
- `matrix.is_diagonal` (Supported)
- `matrix.is_identity` (Supported)
- `matrix.is_square` (Supported)
- `matrix.is_stochastic` (Supported)
- `matrix.is_symmetric` (Supported)
- `matrix.is_triangular` (Supported)
- `matrix.is_zero` (Supported)
- `matrix.kron` (Supported)
- `matrix.max` (Supported)
- `matrix.median` (Supported)
- `matrix.min` (Supported)
- `matrix.mode` (Supported)
- `matrix.mult` (Supported)
- `matrix.pinv` (Supported): Moore-Penrose pseudoinverse.
- `matrix.pow` (Supported)
- `matrix.rank` (Supported)
- `matrix.remove_col` (Supported)
- `matrix.remove_row` (Supported)
- `matrix.reshape` (Supported)
- `matrix.reverse` (Supported)
- `matrix.row` (Supported)
- `matrix.rows` (Supported)
- `matrix.set` (Supported)
- `matrix.sort` (Supported)
- `matrix.submatrix` (Supported)
- `matrix.sum` (Supported)
- `matrix.swap_columns` (Supported)
- `matrix.swap_rows` (Supported)
- `matrix.trace` (Supported)
- `matrix.transpose` (Supported)
- `map.clear` (Supported)
- `map.contains` (Supported)
- `map.copy` (Supported)
- `map.get` (Supported)
- `map.keys` (Supported)
- `map.put_all` (Supported)
- `map.remove` (Supported)
- `map.size` (Supported)
- `map.values` (Supported)

## Bar states, time, timeframe, session

What the script knows about the bar, the chart and the clock. The feed trades 24x7 on UTC.

### barstate.islast (Verified)

```pine
barstate.islast
```

true on the last bar on the chart.

### barstate.isconfirmed (Verified)

```pine
barstate.isconfirmed
```

true once a bar has closed. Use for signals that must not change.

### barstate.isfirst (Supported)

```pine
barstate.isfirst
```

true on the first bar.

### barstate.isrealtime (Supported)

```pine
barstate.isrealtime
```

true on bars that formed while the chart was open.

### timeframe.period (Supported)

```pine
timeframe.period
```

The chart's timeframe as a Pine string, for example "5" or "15S".

### timeframe.in_seconds (Supported)

```pine
timeframe.in_seconds(timeframe)
```

A timeframe string in seconds.

### timeframe.change (Supported)

```pine
timeframe.change(timeframe)
```

true on the first chart bar of a new higher-timeframe bar.

### runtime.error (Supported)

```pine
runtime.error(message)
```

Stops the script with your message, shown in the console.
- `barstate.ishistory` (Supported)
- `barstate.islastconfirmedhistory` (Supported)
- `barstate.isnew` (Supported)
- `timeframe.from_seconds` (Supported)
- `timeframe.isdaily` (Supported)
- `timeframe.isdwm` (Supported)
- `timeframe.isintraday` (Supported)
- `timeframe.isminutes` (Supported)
- `timeframe.ismonthly` (Supported)
- `timeframe.isseconds` (Supported)
- `timeframe.isticks` (Supported)
- `timeframe.isweekly` (Supported)
- `timeframe.main_period` (Supported)
- `timeframe.multiplier` (Supported)
- `session.isfirstbar` (Supported)
- `session.isfirstbar_regular` (Supported)
- `session.islastbar` (Supported)
- `session.islastbar_regular` (Supported)
- `session.ismarket` (Supported)
- `session.ispostmarket` (Supported)
- `session.ispremarket` (Supported)
- `ticker.heikinashi` (Supported)
- `ticker.inherit` (Supported)
- `ticker.kagi` (Supported)
- `ticker.linebreak` (Supported)
- `ticker.modify` (Supported)
- `ticker.new` (Supported)
- `ticker.pointfigure` (Supported)
- `ticker.renko` (Supported)
- `ticker.standard` (Supported)
- `log.error` (Supported)
- `log.info` (Supported)
- `log.warning` (Supported)
