Pine Script

https://www.tradingview.com/pine-script-reference/
Admin
Pine Script is a programming language developed by TradingView for creating custom indicators and...
Tokens:422,390
Snippets:2,699
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### matrix.swap_columns() example

Source: https://www.tradingview.com/pine-script-reference/v6

Pine Script v6 example creating a 2x2 matrix, copying it, swapping columns 0 and 1 in the copy, and displaying both matrices in a table. Indexing starts at zero.

```pine
//@version=6  
indicator("`matrix.swap_columns()` Example")  
  
// For efficiency, execute this code only once.  
if barstate.islastconfirmedhistory  
    // Create a 2x2 matrix with ‘na’ values.  
    var m1 = matrix.new<int>(2, 2, na)  
    // Fill the matrix with values.  
    matrix.set(m1, 0, 0, 1)  
    matrix.set(m1, 0, 1, 2)  
    matrix.set(m1, 1, 0, 3)  
    matrix.set(m1, 1, 1, 4)  
  
    // Copy the matrix to a new one.  
    var m2 = matrix.copy(m1)  
  
    // Swap the first and second columns of the matrix copy.  
    matrix.swap_columns(m2, 0, 1)  
  
    // Display using a table.  
    var t = table.new(position.top_right, 2, 2, color.green)  
    table.cell(t, 0, 0, "Original matrix:")  
    table.cell(t, 0, 1, str.tostring(m1))  
    table.cell(t, 1, 0, "Swapped columns in copy:")  
    table.cell(t, 1, 1, str.tostring(m2))  

```

--------------------------------

### matrix.swap_rows() example

Source: https://www.tradingview.com/pine-script-reference/v6

Pine Script v6 example creating a 3x2 matrix, copying it, swapping rows 0 and 1 in the copy, and displaying both matrices in a table. Indexing starts at zero.

```pine
//@version=6  
indicator("`matrix.swap_rows()` Example")  
  
// For efficiency, execute this code only once.  
if barstate.islastconfirmedhistory  
    // Create a 3x2 matrix with ‘na’ values.  
    var m1 = matrix.new<int>(3, 2, na)  
    // Fill the matrix with values.  
    matrix.set(m1, 0, 0, 1)  
    matrix.set(m1, 0, 1, 2)  
    matrix.set(m1, 1, 0, 3)  
    matrix.set(m1, 1, 1, 4)  
    matrix.set(m1, 2, 0, 5)  
    matrix.set(m1, 2, 1, 6)  
  
    // Copy the matrix to a new one.  
    var m2 = matrix.copy(m1)  
  
    // Swap the first and second rows of the matrix copy.  
    matrix.swap_rows(m2, 0, 1)  
  
    // Display using a table.  
    var t = table.new(position.top_right, 2, 2, color.green)  
    table.cell(t, 0, 0, "Original matrix:")  
    table.cell(t, 0, 1, str.tostring(m1))  
    table.cell(t, 1, 0, "Swapped rows in copy:")  
    table.cell(t, 1, 1, str.tostring(m2))  

```

--------------------------------

### array.new_table() syntax and example

Source: https://www.tradingview.com/pine-script-reference/v6

Syntax for array.new_table() and an example that creates a table array and pushes a table. The example uses //@version=6 and plots a dummy value.

```pine
array.new_table(size, initial_value) → array<table>
```

```pine
//@version=6  
indicator("table array")  
tables = array.new_table()  
array.push(tables, table.new(position = position.top_left, rows = 1, columns = 2, bgcolor = color.yellow, border_width=1))  
plot(1)  
```

--------------------------------

### time() Example: Time in Range and New Bar Detection

Source: https://www.tradingview.com/pine-script-reference/v6

Example script showing how to use time() with a session and timezone to detect if the current bar is within a specified time range, and to detect the start of a new bar on a higher timeframe.

```pine
//@version=6  
indicator("Time", overlay=true)  
// Try this on chart AAPL,1  
timeinrange(res, sess) => not na(time(res, sess, "America/New_York")) ? 1 : 0  
plot(timeinrange("1", "1300-1400"), color=color.red)  
  
// This plots 1.0 at every start of 10 minute bar on a 1 minute chart:  
newbar(res) => ta.change(time(res)) == 0 ? 0 : 1  
plot(newbar("10"))  
```

--------------------------------

### ta.kc() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example script using ta.kc() and a Pine equivalent implementation.

```pine
//@version=6  
indicator("ta.kc")  
  
[middle, upper, lower] = ta.kc(close, 5, 4)  
plot(middle, color=color.yellow)  
plot(upper, color=color.yellow)  
plot(lower, color=color.yellow)  
  
  
// the same on pine  
f_kc(src, length, mult, useTrueRange) =>  
    float basis = ta.ema(src, length)  
    float span = (useTrueRange) ? ta.tr : (high - low)  
    float rangeEma = ta.ema(span, length)  
    [basis, basis + rangeEma * mult, basis - rangeEma * mult]  
  
[pineMiddle, pineUpper, pineLower] = f_kc(close, 5, 4, true)  
  
plot(pineMiddle)  
plot(pineUpper)  
plot(pineLower)  
```

--------------------------------

### array.new_string() syntax and example

Source: https://www.tradingview.com/pine-script-reference/v6

Syntax and example for creating an array of string elements. The example creates an array of length 5 initialized with "text" and displays the first element in a label.

```pine
array.new_string(size, initial_value) → array<string>
```

```pine
//@version=6  
indicator("array.new_string example")  
length = 5  
a = array.new_string(length, "text")  
label.new(bar_index, close, array.get(a, 0))  

```

--------------------------------

### map.get() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing how to retrieve a value from a map using map.get().

```pine
//@version=6  
indicator("map.get example")  
a = map.new<int, int>()  
size = 10  
for i = 0 to size  
    a.put(i, size-i)  
plot(map.get(a, 1))  
  

```

--------------------------------

### array.new_int() syntax and example

Source: https://www.tradingview.com/pine-script-reference/v6

Syntax and example for creating an array of int elements. The example creates an array of length 5 initialized with the current close price and plots the average.

```pine
array.new_int(size, initial_value) → array<int>
```

```pine
//@version=6  
indicator("array.new_int example")  
length = 5  
a = array.new_int(length, int(close))  
plot(array.sum(a) / length)  

```

--------------------------------

### array.get() syntax and example

Source: https://www.tradingview.com/pine-script-reference/v6

Syntax and example for array.get(). The example creates a float array, pushes differences between close and open, and plots the element at index 9. Index can be negative to count from the end.

```pine
array.get(id, index) → series <type>
```

```pine
//@version=6  
indicator("array.get example")  
a = array.new_float(0)  
for i = 0 to 9  
    array.push(a, close[i] - open[i])  
plot(array.get(a, 9))  

```

--------------------------------

### hline() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example of using hline() with a dotted line and filling between two hlines.

```pine
//@version=6  
indicator("input.hline", overlay=true)  
hline(3.14, title='Pi', color=color.blue, linestyle=hline.style_dotted, linewidth=2)  
  
// You may fill the background between any two hlines with a fill() function:  
h1 = hline(20)  
h2 = hline(10)  
fill(h1, h2, color=color.new(color.green, 90))  
```

--------------------------------

### ticker.new() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example usage of ticker.new() with syminfo.prefix and syminfo.ticker, then passing the ticker to ticker.heikinashi() and request.security().

```pine
//@version=6  
indicator("ticker.new", overlay=true)  
t = ticker.new(syminfo.prefix, syminfo.ticker, session.regular, adjustment.splits)  
t2 = ticker.heikinashi(t)  
c = request.security(t2, timeframe.period, low, barmerge.gaps_on)  
plot(c, style=plot.style_linebr)  
```

--------------------------------

### ta.valuewhen example

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing how to use ta.valuewhen to get the close value on the second most recent cross of two moving averages.

```pine
//@version=6  
indicator("ta.valuewhen")  
slow = ta.sma(close, 7)  
fast = ta.sma(close, 14)  
// Get value of `close` on second most recent cross  
plot(ta.valuewhen(ta.cross(slow, fast), close, 1))  
```

--------------------------------

### log.warning() example with strategy

Source: https://www.tradingview.com/pine-script-reference/v6

Example strategy using log.info(), log.warning(), and log.error() to log order placements and strategy status. Shows how to use format placeholders {0}, {1}.

```pine
//@version=6  
strategy("My strategy", overlay = true, process_orders_on_close = true)  
bracketTickSizeInput = input.int(1000, "Stoploss/Take-Profit distance (in ticks)")  
  
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))  
if (longCondition)  
    limitLevel = close * 1.01  
    log.info("Long limit order has been placed at {0}", limitLevel)  
    strategy.order("My Long Entry Id", strategy.long, limit = limitLevel)  
  
    log.info("Exit orders have been placed: Take-profit at {0}, Stop-loss at {1}", close, limitLevel)  
    strategy.exit("Exit", "My Long Entry Id", profit = bracketTickSizeInput, loss = bracketTickSizeInput)  
  
if strategy.opentrades > 10  
    log.warning("{0} positions opened in the same direction in a row. Try adjusting `bracketTickSizeInput`", strategy.opentrades)  
  
last10Perc = strategy.initial_capital / 10 > strategy.equity  
if (last10Perc and not last10Perc[1])  
    log.error("The strategy has lost 90% of the initial capital!")  
  

```

--------------------------------

### syminfo.prefix() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example of using syminfo.prefix() to get the exchange prefix of a symbol input, then using it with syminfo.ticker() and ticker.new() to request security data.

```pine
//@version=6
indicator("syminfo.prefix fun", overlay=true)
i_sym = input.symbol("NASDAQ:AAPL")
pref = syminfo.prefix(i_sym)
tick = syminfo.ticker(i_sym)
t = ticker.new(pref, tick, session.extended)
s = request.security(t, "1D", close)
plot(s)
```

--------------------------------

### Basic strategy() example with entry and exit

Source: https://www.tradingview.com/pine-script-reference/v6

Example of a strategy() call with overlay=true, entering a long position when the current open is greater than the previous high, and setting a full exit bracket with profit and loss points.

```pine
//@version=6  
strategy("My strategy", overlay = true)  
  
// Enter long by market if current open is greater than previous high.  
if open > high[1]  
    strategy.entry("Long", strategy.long, 1)  
// Generate a full exit bracket (profit 10 points, loss 5 points per contract) from the entry named "Long".  
strategy.exit("Exit", "Long", profit = 10, loss = 5)  

```

--------------------------------

### strategy.opentrades.entry_price() example 2

Source: https://www.tradingview.com/pine-script-reference/v6

Example strategy with pyramiding that calculates the average entry price for the open position using entry_price() and size().

```pine
// Calculates the average price for the open position.  
//@version=6  
strategy("strategy.opentrades.entry_price Example 2", pyramiding = 2)  
  
// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.  
if bar_index % 15 == 0  
    strategy.entry("Long", strategy.long)  
if bar_index % 20 == 0  
    strategy.close("Long")  
  
// Calculates the average price for the open position.  
avgOpenPositionPrice() =>  
    sumOpenPositionPrice = 0.0  
    for tradeNo = 0 to strategy.opentrades - 1  
        sumOpenPositionPrice += strategy.opentrades.entry_price(tradeNo) * strategy.opentrades.size(tradeNo) / strategy.position_size  
    result = nz(sumOpenPositionPrice / strategy.opentrades)  
  
plot(avgOpenPositionPrice())  
```

--------------------------------

### input() Example

Source: https://www.tradingview.com/pine-script-reference/v6

Example script demonstrating various input() calls: boolean switch, integer length, source, float border, color, and string message. The script plots based on these inputs and uses a label to display the text input.

```pine
//@version=6  
indicator("input", overlay=true)  
i_switch = input(true, "On/Off")  
plot(i_switch ? open : na)  
  
i_len = input(7, "Length")  
i_src = input(close, "Source")  
plot(ta.sma(i_src, i_len))  
  
i_border = input(142.50, "Price Border")  
hline(i_border)  
bgcolor(close > i_border ? color.green : color.red)  
  
i_col = input(color.red, "Plot Color")  
plot(close, color=i_col)  
  
i_text = input("Hello!", "Message")  
l = label.new(bar_index, high, text=i_text)  
label.delete(l[1])  
```

--------------------------------

### strategy.opentrades.entry_bar_index() example

Source: https://www.tradingview.com/pine-script-reference/v6

Pine Script example that waits 10 bars after the last entry and then closes the position. It uses strategy.opentrades.entry_bar_index() to get the entry bar index of the most recent open trade.

```pine
// Wait 10 bars and then close the position.  
//@version=6  
strategy("`strategy.opentrades.entry_bar_index` Example")  
  
barsSinceLastEntry() =>  
    strategy.opentrades > 0 ? bar_index - strategy.opentrades.entry_bar_index(strategy.opentrades - 1) : na  
  
// Enter a long position if there are no open positions.  
if strategy.opentrades == 0  
    strategy.entry("Long", strategy.long)  
  
// Close the long position after 10 bars.  
if barsSinceLastEntry() >= 10  
    strategy.close("Long")  
```

--------------------------------

### library() example: Math library

Source: https://www.tradingview.com/pine-script-reference/v6

Example of a library declaration with overlay=true and an exported function sinh(). The library is named 'num_methods' and exports a function that calculates hyperbolic sine.

```pine
//@version=6  
// @description Math library 
library("num_methods", overlay = true)  
// Calculate "sinh()" from the float parameter `x` 
export sinh(float x) =>  
    (math.exp(x) - math.exp(-x)) / 2.0 
plot(sinh(0))  
```

--------------------------------

### Pine Script: Detect Friday sessions using time_tradingday

Source: https://www.tradingview.com/pine-script-reference/v6

Example script that uses time_tradingday to get the trading day's day of week in UTC+0 and compares it with the exchange-time dayofweek to highlight Friday sessions. Useful for overnight symbols where the session starts on the previous calendar day. The script plots both dayofweek values and uses bgcolor to highlight when each condition is true.

```Pine Script
//@version=6  
indicator("Friday session")  
  
//@variable The day of week, based on the current `time_tradingday` value.  
//          Uses "UTC+0" to return the daily session's timestamp at 00:00 UTC.  
int tradingDayOfWeek = dayofweek(time_tradingday, "UTC+0")  
  
//@variable Returns `true` if the `dayofweek` represents Friday, in exchange time.
//          It might never return `true` on overnight symbols, depending on the timeframe, since the Friday session  
//          starts on Thursday.  
bool isFriday = dayofweek == dayofweek.friday  
//@variable Returns `true` if the `tradingDayOfWeek` is Friday.  
//          Differs from `isFriday` on symbols with overnight sessions and for timeframes > "1D" on others.  
bool isFridaySession = tradingDayOfWeek == dayofweek.friday  
  
// Create a horizontal line at the `dayofweek.friday` value.  
hline(dayofweek.friday, "Friday value", color.gray, hline.style_dashed, 2)  
// Plot the `dayofweek` and `tradingDayOfWeek` for comparison.  
plot(dayofweek, "Day of week", color.blue, 2)  
plot(tradingDayOfWeek, "Trading day", color.teal, 3)  
// Highlight the background when `isFriday` and `isFridaySession` occur.  
bgcolor(isFriday ? color.new(color.blue, 90) : na, title = "isFriday highlight")  
bgcolor(isFridaySession ? color.new(color.teal, 80) : na, title = "isFridaySession highlight")  

```

--------------------------------

### Create a matrix with initial value (matrix.new Example 1)

Source: https://www.tradingview.com/pine-script-reference/v6

Creates a 2x3 integer matrix with all values set to zero and displays it using a label on the last confirmed history bar.

```pine
//@version=6  
indicator("`matrix.new<type>()` Example 1")  
  
// Create a 2x3 (2 rows x 3 columns) "int" matrix with values zero.  
var m = matrix.new<int>(2, 3, 0)  
  
// Display using a label.  
if barstate.islastconfirmedhistory  
    label.new(bar_index, high, str.tostring(m))  

```

--------------------------------

### varip keyword example

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing how varip increments on every tick in real time, while var would only increment once per bar.

```pine
//@version=6  
indicator("varip")  
varip int v = -1  
v := v + 1  
plot(v)  
```

--------------------------------

### strategy.opentrades.size() Example 2 - average profit percentage for all open trades

Source: https://www.tradingview.com/pine-script-reference/v6

Example strategy that enters long every 15 bars and closes every 20 bars, then calculates and plots the average profit percentage for all open trades using strategy.opentrades.size() and entry_price().

```pine
// Calculates the average profit percentage for all open trades.
//@version=6
strategy("`strategy.opentrades.size` Example 2")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")

// Calculate profit for all open trades.
profitPct = 0.0
for tradeNo = 0 to strategy.opentrades - 1
    entryP = strategy.opentrades.entry_price(tradeNo)
    exitP = close
    profitPct += (exitP - entryP) / entryP * strategy.opentrades.size(tradeNo) * 100

// Calculate average profit percent for all open trades.
avgProfitPct = nz(profitPct / strategy.opentrades)
plot(avgProfitPct)
```

--------------------------------

### request.security_lower_tf() example in Pine Script

Source: https://www.tradingview.com/pine-script-reference/v6

Shows how to call request.security_lower_tf() to get an array of close values from a lower timeframe. The example uses syminfo.tickerid and "60" to request 60-minute data, and displays the array in a label on the last bar.

```pine
//@version=6  
indicator("`request.security_lower_tf()` Example", overlay = true)  
  
// If the current chart timeframe is set to 120 minutes, then the `arrayClose` array will contain two 'close' values from the 60 minute timeframe for each bar.  
arrClose = request.security_lower_tf(syminfo.tickerid, "60", close)  
  
if bar_index == last_bar_index - 1  
    label.new(bar_index, high, str.tostring(arrClose))  
```

--------------------------------

### strategy.opentrades.entry_time() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example strategy that enters long trades every 15 bars and exits every 20 bars, then plots the number of days since the last entry using entry_time().

```pine
//@version=6  
strategy("strategy.opentrades.entry_time Example")  
  
// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.  
if bar_index % 15 == 0  
    strategy.entry("Long", strategy.long)  
if bar_index % 20 == 0  
    strategy.close("Long")  
  
// Calculates duration in milliseconds since the last position was opened.  
timeSinceLastEntry()=>  
    strategy.opentrades > 0 ? (time - strategy.opentrades.entry_time(strategy.opentrades - 1)) : na  
  
plot(timeSinceLastEntry() / 1000 * 60 * 60 * 24, "Days since last entry")  
```

--------------------------------

### matrix.col() example: extract a column from a matrix

Source: https://www.tradingview.com/pine-script-reference/v6

Creates a 2x3 float matrix from hlc3 values and returns an array with the values of the first column using matrix.col(m, 0). The example plots the first value from the returned array. Indexing of rows starts at 0.

```Pine Script
//@version=6  
indicator("`matrix.col()` Example", "", true)  
  
// Create a 2x3 "float" matrix from `hlc3` values.  
m = matrix.new<float>(2, 3, hlc3)  
  
// Return an array with the values of the first column of matrix `m`.  
a = matrix.col(m, 0)  
  
// Plot the first value from the array `a`.  
plot(array.get(a, 0))  

```

--------------------------------

### matrix.row() example in Pine Script v6

Source: https://www.tradingview.com/pine-script-reference/v6

Creates a 2x3 float matrix from hlc3 values, extracts the first row as an array, and plots the first element of that array. Row indexing starts at zero.

```Pine Script
//@version=6  
indicator("`matrix.row()` Example", "", true)  
  
// Create a 2x3 "float" matrix from `hlc3` values.  
m = matrix.new<float>(2, 3, hlc3)  
  
// Return an array with the values of the first row of the matrix.  
a = matrix.row(m, 0)  
  
// Plot the first value from the array `a`.  
plot(array.get(a, 0))  
```

--------------------------------

### line.new() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example script using line.new with both bar_index and bar_time xloc, and demonstrating setter functions.

```pine
//@version=6  
indicator("line.new")  
var line1 = line.new(0, low, bar_index, high, extend=extend.right)  
var line2 = line.new(time, open, time + 60 * 60 * 24, close, xloc=xloc.bar_time, style=line.style_dashed)  
line.set_x2(line1, 0)  
line.set_xloc(line1, time, time + 60 * 60 * 24, xloc.bar_time)  
line.set_color(line2, color.green)  
line.set_width(line2, 5)  

```

--------------------------------

### matrix.rank() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example script demonstrating matrix.rank() by creating a 2x2 matrix, filling it with values, and displaying the rank in a table.

```pine
//@version=6  
indicator("`matrix.rank()` Example")  
  
// For efficiency, execute this code only once.  
if barstate.islastconfirmedhistory  
    // Create a 2x2 matrix.  
    var m1 = matrix.new<int>(2, 2, na)  
    // Fill the matrix with values.  
    matrix.set(m1, 0, 0, 1)  
    matrix.set(m1, 0, 1, 2)  
    matrix.set(m1, 1, 0, 3)  
    matrix.set(m1, 1, 1, 4)  
  
    // Get the rank of the matrix.  
    r = matrix.rank(m1)  
  
    // Display matrix elements.  
    var t = table.new(position.top_right, 2, 2, color.green)  
    table.cell(t, 0, 0, "Matrix elements:")  
    table.cell(t, 0, 1, str.tostring(m1))  
    table.cell(t, 1, 0, "Rank of the matrix:")  
    table.cell(t, 1, 1, str.tostring(r))  
```

--------------------------------

### matrix.columns() example: get number of columns

Source: https://www.tradingview.com/pine-script-reference/v6

Creates a 2x6 integer matrix filled with zeros and retrieves the number of columns using matrix.columns(m). The result is displayed in a label on the last confirmed history bar.

```Pine Script
//@version=6  
indicator("`matrix.columns()` Example")  
  
// Create a 2x6 matrix with values `0`.  
var m = matrix.new<int>(2, 6, 0)  
  
// Get the quantity of columns in matrix `m`.  
var x = matrix.columns(m)  
  
// Display using a label.  
if barstate.islastconfirmedhistory  
    label.new(bar_index, high, "Columns: " + str.tostring(x) + "\n" + str.tostring(m))  

```

--------------------------------

### matrix.remove_row() example in Pine Script v6

Source: https://www.tradingview.com/pine-script-reference/v6

Creates a 2x2 int matrix, copies it, removes the first row from the copy, and displays the original, removed elements, and result in a table. Row indexing starts at zero.

```Pine Script
//@version=6  
indicator("matrix_remove_row", overlay = true)  
  
// Create a 2x2 "int" matrix containing values `1`.  
var matrixOrig = matrix.new<int>(2, 2, 1)  
  
// Set values to the 'matrixOrig' matrix.  
matrix.set(matrixOrig, 0, 1, 2)  
matrix.set(matrixOrig, 1, 0, 3)  
matrix.set(matrixOrig, 1, 1, 4)  
  
// Create a copy of the 'matrixOrig' matrix.  
matrixCopy = matrix.copy(matrixOrig)  
  
// Remove the first row from the matrix `matrixCopy`.  
arr = matrix.remove_row(matrixCopy, 0)  
  
// Display matrix elements.  
if barstate.islastconfirmedhistory  
    var t = table.new(position.top_right, 3, 2, color.green)  
    table.cell(t, 0, 0, "Original Matrix:")  
    table.cell(t, 0, 1, str.tostring(matrixOrig))  
    table.cell(t, 1, 0, "Removed Elements:")  
    table.cell(t, 1, 1, str.tostring(arr))  
    table.cell(t, 2, 0, "Result Matrix:")  
    table.cell(t, 2, 1, str.tostring(matrixCopy))  
```

--------------------------------

### ta.swma example with manual implementation

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing how to use ta.swma and a manual Pine implementation (pine_swma) that is less efficient. The manual version uses the same weights [1/6, 2/6, 2/6, 1/6].

```pine
//@version=6  
indicator("ta.swma")  
plot(ta.swma(close))  
  
// same on pine, but less efficient  
pine_swma(x) =>  
    x[3] * 1 / 6 + x[2] * 2 / 6 + x[1] * 2 / 6 + x[0] * 1 / 6  
plot(pine_swma(close))  
```

--------------------------------

### strategy.convert_to_account() example 2

Source: https://www.tradingview.com/pine-script-reference/v6

Calculates the 'Buy and hold return' percentage using the account's currency, with a date input.

```pine
// Calculates the "Buy and hold return" using your account's currency.  
//@version=6  
strategy("`strategy.convert_to_account` Example 2", currency = currency.EUR)  
  
dateInput = input.time(timestamp("20 Jul 2021 00:00 +0300"), "From Date", confirm = true)  
  
buyAndHoldReturnPct(fromDate) =>  
    if time >= fromDate  
        money = close * syminfo.pointvalue  
        var initialBal = strategy.convert_to_account(money)  
        (strategy.convert_to_account(money) - initialBal) / initialBal * 100  
  
plot(buyAndHoldReturnPct(dateInput))  
```

--------------------------------

### Filter backtesting bars using last_bar_index

Source: https://www.tradingview.com/pine-script-reference/v6

Example for the last_bar_index variable. Stores the last bar index at the start of the script and uses it to determine if the current bar is within a user-defined number of bars from the last bar, or if the chart is in real-time. Note that using this variable can cause indicator repainting.

```Pine Script
//@version=6  
strategy("Mark Last X Bars For Backtesting", overlay = true, calc_on_every_tick = true)  
lastBarsFilterInput = input.int(100, "Bars Count:")  
// Here, we store the 'last_bar_index' value that is known from the beginning of the script's calculation.  
// The 'last_bar_index' will change when new real-time bars appear, so we declare 'lastbar' with the 'var' keyword.  
var lastbar = last_bar_index  
// Check if the current bar_index is 'lastBarsFilterInput' removed from the last bar on the chart, or the chart is traded in real-time.  
allowedToTrade = (lastbar - bar_index <= lastBarsFilterInput) or barstate.isrealtime  
bgcolor(allowedToTrade ? color.new(color.green, 80) : na)  

```

--------------------------------

### ta.dev() example with Pine equivalent

Source: https://www.tradingview.com/pine-script-reference/v6

Example usage of ta.dev() and a Pine script equivalent implementation. The example plots the deviation and the equivalent function.

```pine
//@version=6  
indicator("ta.dev")  
plot(ta.dev(close, 10))  
  
// the same on pine  
pine_dev(source, length) =>  
    mean = ta.sma(source, length)  
    sum = 0.0  
    for i = 0 to length - 1  
        val = source[i]  
        sum := sum + math.abs(val - mean)  
    dev = sum/length  
plot(pine_dev(close, 10))  
```

--------------------------------

### array.new<string> example

Source: https://www.tradingview.com/pine-script-reference/v6

Example creating an array of strings with an initial value and displaying it in a label.

```pine
//@version=6  
indicator("array.new<string> example")  
a = array.new<string>(1, "Hello, World!")  
label.new(bar_index, close, array.get(a, 0))  
```

--------------------------------

### ta.cog() example with Pine equivalent

Source: https://www.tradingview.com/pine-script-reference/v6

Example usage of ta.cog() and a Pine script equivalent implementation. The example plots the indicator and the equivalent function.

```pine
//@version=6  
indicator("ta.cog", overlay=true)  
plot(ta.cog(close, 10))  
  
// the same on pine  
pine_cog(source, length) =>  
    sum = math.sum(source, length)  
    num = 0.0  
    for i = 0 to length - 1  
        price = source[i]  
        num := num + price * (i + 1)  
    -num / sum  
  
plot(pine_cog(close, 10))  
```

--------------------------------

### matrix.median() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example script that creates a 2x2 matrix, fills it with values, calculates the median, and plots it. Note that na elements are not considered in the calculation.

```pine
//@version=6  
indicator("`matrix.median()` Example")  
  
// Create a 2x2 matrix.  
m = matrix.new<int>(2, 2, na)  
// Fill the matrix with values.  
matrix.set(m, 0, 0, 1)  
matrix.set(m, 0, 1, 2)  
matrix.set(m, 1, 0, 3)  
matrix.set(m, 1, 1, 4)  
  
// Get the median of the matrix.  
x = matrix.median(m)  
  
plot(x, 'Median of the matrix')  
```

--------------------------------

### %= operator example

Source: https://www.tradingview.com/pine-script-reference/v6

Example of the modulo assignment operator.

```pine
//@version=6  
indicator("%=")  
// Equals to expr1 = expr1 % expr2.  
a = 3  
b = 3  
a %= b  
// Result: a = 0.  
plot(a)  
```

--------------------------------

### *= operator example

Source: https://www.tradingview.com/pine-script-reference/v6

Example of the multiplication assignment operator.

```pine
//@version=6  
indicator("*=")  
// Equals to expr1 = expr1 * expr2.  
a = 2  
b = 3  
a *= b  
// Result: a = 6.  
plot(a)  
```

--------------------------------

### matrix.pow() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example script demonstrating matrix.pow() by creating a 2x2 matrix and calculating its power of three, then displaying the results in a table.

```pine
//@version=6  
indicator("`matrix.pow()` Example")  
  
// Display using a table.  
if barstate.islastconfirmedhistory  
    // Create a 2x2 matrix.  
    var m1 = matrix.new<int>(2, 2, 2)  
    // Calculate the power of three of the matrix.  
    var m2 = matrix.pow(m1, 3)  
  
    // Display matrix elements.  
    var t = table.new(position.top_right, 2, 2, color.green)  
    table.cell(t, 0, 0, "Original Matrix:")  
    table.cell(t, 0, 1, str.tostring(m1))  
    table.cell(t, 1, 0, "Matrix³:")  
    table.cell(t, 1, 1, str.tostring(m2))  
```

--------------------------------

### table.cell_set_text() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing how to create a table and set text in a cell using table.cell_set_text(). The example uses version 6 of Pine Script.

```pine
//@version=6  
indicator("TABLE example")  
var tLog = table.new(position = position.top_left, rows = 1, columns = 2, bgcolor = color.yellow, border_width=1)  
table.cell(tLog, row = 0, column = 0, text = "sometext", text_color = color.blue)  
table.cell_set_text(tLog, row = 0, column = 0, text = "sometext")  

```

--------------------------------

### ta.wma example with equivalent Pine implementation

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing ta.wma usage and a less efficient Pine equivalent using a loop.

```pine
//@version=6  
indicator("ta.wma")  
plot(ta.wma(close, 15))  
  
// same on pine, but much less efficient  
pine_wma(x, y) =>  
    norm = 0.0  
    sum = 0.0  
    for i = 0 to y - 1  
        weight = (y - i) * y  
        norm := norm + weight  
        sum := sum + x[i] * weight  
    sum / norm  
plot(pine_wma(close, 15))  

```

--------------------------------

### ta.sar() example with Pine equivalent

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing the built-in ta.sar() function and a Pine Script equivalent (pine_sar) that implements the same logic. The example plots both on a chart.

```pine
//@version=6  
indicator("ta.sar")  
plot(ta.sar(0.02, 0.02, 0.2), style=plot.style_cross, linewidth=3)  
  
// The same on Pine Script®  
pine_sar(start, inc, max) =>  
    var float result = na  
    var float maxMin = na  
    var float acceleration = na  
    var bool isBelow = false  
    bool isFirstTrendBar = false  
  
    if bar_index == 1  
        if close > close[1]  
            isBelow := true  
            maxMin := high  
            result := low[1]  
        else  
            isBelow := false  
            maxMin := low  
            result := high[1]  
        isFirstTrendBar := true  
        acceleration := start  
  
    result := result + acceleration * (maxMin - result)  
  
    if isBelow  
        if result > low  
            isFirstTrendBar := true  
            isBelow := false  
            result := math.max(high, maxMin)  
            maxMin := low  
            acceleration := start  
    else  
        if result < high  
            isFirstTrendBar := true  
            isBelow := true  
            result := math.min(low, maxMin)  
            maxMin := high  
            acceleration := start  
             
    if not isFirstTrendBar  
        if isBelow  
            if high > maxMin  
                maxMin := high  
                acceleration := math.min(acceleration + inc, max)  
        else  
            if low < maxMin  
                maxMin := low  
                acceleration := math.min(acceleration + inc, max)  
  
    if isBelow  
        result := math.min(result, low[1])  
        if bar_index > 1  
            result := math.min(result, low[2])  
         
    else  
        result := math.max(result, high[1])  
        if bar_index > 1  
            result := math.max(result, high[2])  
  
    result  
  
plot(pine_sar(0.02, 0.02, 0.2), style=plot.style_cross, linewidth=3)  
```

--------------------------------

### matrix.trace() example

Source: https://www.tradingview.com/pine-script-reference/v6

Pine Script v6 example showing how to create a 2x2 integer matrix, fill it with values, compute its trace, and display the matrix and trace in a table. Uses barstate.islastconfirmedhistory for efficiency.

```pine
//@version=6  
indicator("`matrix.trace()` Example")  
  
// For efficiency, execute this code only once.  
if barstate.islastconfirmedhistory  
    // Create a 2x2 matrix.  
    var m1 = matrix.new<int>(2, 2, na)  
    // Fill the matrix with values.  
    matrix.set(m1, 0, 0, 1)  
    matrix.set(m1, 0, 1, 2)  
    matrix.set(m1, 1, 0, 3)  
    matrix.set(m1, 1, 1, 4)  
  
    // Get the trace of the matrix.  
    tr = matrix.trace(m1)  
  
    // Display matrix elements.  
    var t = table.new(position.top_right, 2, 2, color.green)  
    table.cell(t, 0, 0, "Matrix elements:")  
    table.cell(t, 0, 1, str.tostring(m1))  
    table.cell(t, 1, 0, "Trace of the matrix:")  
    table.cell(t, 1, 1, str.tostring(tr))  
```

--------------------------------

### ta.rsi() example with Pine equivalent

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing the built-in ta.rsi() function and a Pine Script equivalent (pine_rsi) that implements the same logic. The example plots both on a chart.

```pine
//@version=6  
indicator("ta.rsi")  
plot(ta.rsi(close, 7))  
  
// same on pine, but less efficient  
pine_rsi(x, y) =>  
    u = math.max(x - x[1], 0) // upward ta.change  
    d = math.max(x[1] - x, 0) // downward ta.change  
    rs = ta.rma(u, y) / ta.rma(d, y)  
    res = 100 - 100 / (1 + rs)  
    res  
  
plot(pine_rsi(close, 7))  
```

--------------------------------

### matrix.min() example

Source: https://www.tradingview.com/pine-script-reference/v6

Example script that creates a 2x2 matrix, fills it with values, calculates the minimum, and plots it. The result is the smallest value from the matrix.

```pine
//@version=6  
indicator("`matrix.min()` Example")  
  
// Create a 2x2 matrix.  
var m = matrix.new<int>(2, 2, na)  
// Fill the matrix with values.  
matrix.set(m, 0, 0, 1)  
matrix.set(m, 0, 1, 2)  
matrix.set(m, 1, 0, 3)  
matrix.set(m, 1, 1, 4)  
  
// Get the minimum value from the matrix.  
var x = matrix.min(m)  
  
plot(x, 'Matrix minimum value')  
```

--------------------------------

### ta.rma() example with Pine equivalent

Source: https://www.tradingview.com/pine-script-reference/v6

Example showing the built-in ta.rma() function and a Pine Script equivalent (pine_rma) that implements the same logic. The example plots both on a chart.

```pine
//@version=6  
indicator("ta.rma")  
plot(ta.rma(close, 15))  
  
//the same on pine  
pine_rma(src, length) =>  
    alpha = 1/length  
    sum = 0.0  
    sum := na(sum[1]) ? ta.sma(src, length) : alpha * src + (1 - alpha) * nz(sum[1])  
plot(pine_rma(close, 15))  
```

--------------------------------

### label.set_text_font_family() Syntax and Example

Source: https://www.tradingview.com/pine-script-reference/v6

Syntax and example for the label.set_text_font_family() function, which sets the font family of the label text. The example creates a label and sets its font to monospace.

```pine
label.set_text_font_family(id, text_font_family) → void
```

```pine
//@version=6  
indicator("Example of setting the label font")  
if barstate.islastconfirmedhistory  
    l = label.new(bar_index, 0, "monospace", yloc=yloc.abovebar)  
    label.set_text_font_family(l, font.family_monospace)  

```

--------------------------------

### strategy.opentrades.entry_price() example 1

Source: https://www.tradingview.com/pine-script-reference/v6

Example strategy that enters long trades on SMA crossover and uses entry_price() to set an exit price 5% above the entry price.

```pine
//@version=6  
strategy("strategy.opentrades.entry_price Example 1", overlay = true)  
  
// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.  
if ta.crossover(close, ta.sma(close, 14))  
    strategy.entry("Long", strategy.long)  
  
// Return the entry price for the latest closed trade.  
currEntryPrice = strategy.opentrades.entry_price(strategy.opentrades - 1)  
currExitPrice = currEntryPrice * 1.05  
  
if high >= currExitPrice  
    strategy.close("Long")  
  
plot(currEntryPrice, "Long entry price", style = plot.style_linebr)  
plot(currExitPrice, "Long exit price", color.green, style = plot.style_linebr)  
```

--------------------------------

### input.int() Example

Source: https://www.tradingview.com/pine-script-reference/v6

Example usage of input.int() with minval/maxval/step and with options. The result must be assigned to a variable.

```pine
//@version=6  
indicator("input.int", overlay=true)  
i_len1 = input.int(10, "Length 1", minval=5, maxval=21, step=1)  
plot(ta.sma(close, i_len1))  
  
i_len2 = input.int(10, "Length 2", options=[5, 10, 21])  
plot(ta.sma(close, i_len2))  
```
Tokens:
Raw