TradingView Pine Script

https://www.tradingview.com/pine-script-reference/v6
Admin
TradingView's Pine Script is a domain-specific language used for creating custom trading indicators...
Tokens:354,219
Snippets:2,504
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### strategy.convert_to_account() example 2

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

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

```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))  

```

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

### matrix.submatrix() example

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

Creates a 2x3 integer matrix, fills it with values 1-6, extracts a 2x2 submatrix using indices (0,2,1,3), and displays both in a table. Indexing starts at zero.

```pine
//@version=6  
indicator("`matrix.submatrix()` Example")  
  
// For efficiency, execute this code only once.  
if barstate.islastconfirmedhistory  
    // Create a 2x3 matrix matrix with values `0`.  
    var m1 = matrix.new<int>(2, 3, 0)  
    // Fill the matrix with values.  
    matrix.set(m1, 0, 0, 1)  
    matrix.set(m1, 0, 1, 2)  
    matrix.set(m1, 0, 2, 3)  
    matrix.set(m1, 1, 0, 4)  
    matrix.set(m1, 1, 1, 5)  
    matrix.set(m1, 1, 2, 6)  
  
    // Create a 2x2 submatrix of the `m1` matrix.  
    var m2 = matrix.submatrix(m1, 0, 2, 1, 3)  
  
    // 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, "Submatrix:")  
    table.cell(t, 1, 1, str.tostring(m2))  

```

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

### time() with session and timezone example

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

Example script using time() with a session and timezone to plot 1 when the bar is in the session, and a newbar function that plots 1 at the start of each 10-minute bar on a 1-minute chart.

```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"))  
```

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

### matrix.columns() Example

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

Example usage of matrix.columns() to get the number of columns in a 2x6 integer matrix and display it with a label.

```pine
//@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))  
```

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

### syminfo.prefix() example

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

Example using syminfo.prefix() to get the exchange prefix from an input symbol, then using it with syminfo.ticker() and ticker.new() to request security data and plot the close.

```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)
```

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

### strategy.convert_to_account() example 1

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

Example strategy that plots the close price and its converted value to the strategy currency (EUR).

```pine
//@version=6  
strategy("`strategy.convert_to_account` Example 1", currency = currency.EUR)  
  
plot(close, "Close price using default currency")  
plot(strategy.convert_to_account(close), "Close price converted to strategy currency")  

```

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

### matrix.rows() example

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

Creates a 2x6 integer matrix, gets its row count with matrix.rows(), and displays the result in a label on the last confirmed bar.

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

```

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

### strategy.cancel() example

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

Example for strategy.cancel(). It places a limit entry order when the condition is true and cancels it when the condition is false.

```pine
//@version=6  
strategy(title = "Order cancellation demo")  
  
conditionForBuy = open > high[1]  
if conditionForBuy  
    strategy.entry("Long", strategy.long, 1, limit = low) // Enter long using limit order at low price of current bar if `conditionForBuy` is `true`.  
if not conditionForBuy  
    strategy.cancel("Long") // Cancel the entry order with name "Long" if `conditionForBuy` is `false`.  

```

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

### ta.swma() Example

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

Example usage of ta.swma() and a manual Pine Script implementation with the same weights.

```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))  

```

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

### [] operator example

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

Example of the [] operator. Shows how to access previous bar values and save variable values between bars.

```pine
//@version=6  
indicator("[]")  
// [] can be used to "save" variable value between bars  
a = 0.0 // declare `a`  
a := a[1] // immediately set current value to the same as previous. `na` in the beginning of history  
if high == low // if some condition - change `a` value to another  
    a := low  
plot(a)  
```

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

### array.size() Example

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

Example for array.size(). It creates an array of 10 close values, then creates a slice and pushes an element to the slice, demonstrating that the size changes in both the slice and the original array. The example plots the sizes of both arrays.

```pine
//@version=6  
indicator("array.size example")  
a = array.new_float(0)  
for i = 0 to 9  
    array.push(a, close[i])  
// note that changes in slice also modify original array  
slice = array.slice(a, 0, 5)  
array.push(slice, open)  
// size was changed in slice and in original array  
plot(array.size(a))  
plot(array.size(slice))  

```

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

### ta.bbw() Example

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

Example usage of ta.bbw() with a manual Pine Script implementation (f_bbw) that calculates the width as a percentage.

```pine
//@version=6  
indicator("ta.bbw")  
  
plot(ta.bbw(close, 5, 4), color=color.yellow)  
  
// the same on pine  
f_bbw(src, length, mult) =>  
    float basis = ta.sma(src, length)  
    float dev = mult * ta.stdev(src, length)  
    (((basis + dev) - (basis - dev)) / basis) * 100  
  
plot(f_bbw(close, 5, 4))  

```

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

### ta.valuewhen() Example

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

Example usage of ta.valuewhen() to get the close value on the second most recent cross of two SMAs.

```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))  

```

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

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

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

Example strategy with pyramiding that calculates and plots the average entry price of open positions using strategy.opentrades.entry_price() and strategy.opentrades.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())  
```

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

### array.sort_indices() Example

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

Example for array.sort_indices(). It creates an array, sorts its indices, and uses the first sorted index to get the smallest value. The example plots that smallest value.

```pine
//@version=6  
indicator("array.sort_indices")  
a = array.from(5, -2, 0, 9, 1)  
sortedIndices = array.sort_indices(a) // [1, 2, 4, 0, 3]  
indexOfSmallestValue = array.get(sortedIndices, 0) // 1  
smallestValue = array.get(a, indexOfSmallestValue) // -2  
plot(smallestValue)  

```

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

### library() Example

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

Example of a library declaration with an exported function. The library is named "num_methods" and uses `overlay = true`. The exported `sinh` function calculates the 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))  

```

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

### strategy() basic entry and exit example

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

Basic strategy() call with overlay mode, a market entry when open exceeds previous high, and a bracket exit with profit and loss limits. Every strategy script must have one strategy() call.

```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)  

```

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

### timeframe.in_seconds() example

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

Example script that gets a user-selected timeframe with input.timeframe() and converts it to seconds using timeframe.in_seconds(), then plots the result.

```pine
//@version=6  
indicator("`timeframe_in_seconds()`"),  
  
// Get a user-selected timeframe.  
tfInput = input.timeframe("1D")  
  
// Convert it into an "int" number of seconds.  
secondsInTf = timeframe.in_seconds(tfInput)  
  
plot(secondsInTf)  

```

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

### 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 exits when price reaches 5% above the entry price, plotting the entry and exit prices.

```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)  
```

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

### array.min() example with nth

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

Example usage of array.min() with the nth parameter. Creates an array from values, gets the second smallest value (index 1), and plots it. The default nth is zero.

```pine
//@version=6  
indicator("array.min")  
a = array.from(5, -2, 0, 9, 1)  
secondLowest = array.min(a, 1) // 0  
plot(secondLowest)  

```

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

### hline() example with fill()

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

Example showing hline() with a dotted style and filling the background between two hlines using fill().

```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))  
```

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

### time_tradingday example: detect Friday trading sessions

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

Use `time_tradingday` to get the timestamp of the trading day's 00:00 UTC, which helps handle overnight sessions where the session starts on the previous calendar day. The example compares `dayofweek` (based on exchange time) with `tradingDayOfWeek` (based on UTC+0) to identify Friday sessions, and plots both with background highlights. Note that `isFriday` may never be true on overnight symbols, and `time_tradingday` returns the last trading day's timestamp for timeframes higher than "1D".

```pine
//@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")  

```

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

### 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 strategy.opentrades.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")  
```

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

### array.new_string() Example

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

Example of creating a string array with a specified length and initial value, then displaying the first element in a label.

```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))  

```

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

### matrix.get() Example

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

Example usage of matrix.get() in Pine Script v6. Creates a 2x3 float matrix from hl2 values, retrieves the element at index [0,0], and plots it. Indexing starts at zero.

```pine
//@version=6  
indicator("`matrix.get()` Example", "", true)  
  
// Create a 2x3 "float" matrix from the `hl2` values.  
m = matrix.new<float>(2, 3, hl2)  
  
// Return the value of the element at index [0, 0] of matrix `m`.  
x = matrix.get(m, 0, 0)  
  
plot(x)  
```

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

### matrix.row() Example

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

Example usage of matrix.row(). It creates a 2x3 float matrix from hlc3 values, extracts the first row into an array, and plots the first value of that array. Row indexing starts at 0.

```pine
//@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))  

```

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

### matrix.kron() example

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

Pine Script v6 example that creates two 2x2 matrices with default values 1 and 2, computes their Kronecker product, and displays the matrices and result in a table on the last confirmed bar.

```pine
//@version=6  
indicator("`matrix.kron()` Example")  
  
// Display using a table.  
if barstate.islastconfirmedhistory  
    // Create two matrices with default values `1` and `2`.  
    var m1 = matrix.new<float>(2, 2, 1)  
    var m2 = matrix.new<float>(2, 2, 2)  
  
    // Calculate the Kronecker product of the matrices.  
    var m3 = matrix.kron(m1, m2)  
  
    // Display matrix elements.  
    var t = table.new(position.top_right, 5, 2, color.green)  
    table.cell(t, 0, 0, "Matrix 1:")  
    table.cell(t, 0, 1, str.tostring(m1))  
    table.cell(t, 1, 1, "⊗")  
    table.cell(t, 2, 0, "Matrix 2:")  
    table.cell(t, 2, 1, str.tostring(m2))  
    table.cell(t, 3, 1, "=")  
    table.cell(t, 4, 0, "Kronecker product:")  
    table.cell(t, 4, 1, str.tostring(m3))  
```

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

### matrix.remove_row() Example

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

Example usage of matrix.remove_row(). It creates a 2x2 integer matrix, copies it, removes the first row from the copy, and displays the original, removed elements, and result matrix in a table. The row index starts at zero.

```pine
//@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))  

```

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

### strategy.cancel_all() example

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

Example for strategy.cancel_all(). It places two limit entry orders and cancels both when a stop-trading condition becomes true.

```pine
//@version=6  
strategy(title = "Cancel all orders demo")  
conditionForBuy1 = open > high[1]  
if conditionForBuy1  
    strategy.entry("Long entry 1", strategy.long, 1, limit = low) // Enter long using a limit order if `conditionForBuy1` is `true`.  
conditionForBuy2 = conditionForBuy1 and open[1] > high[2]  
float lowest2 = ta.lowest(low, 2)  
if conditionForBuy2  
    strategy.entry("Long entry 2", strategy.long, 1, limit = lowest2) // Enter long using a limit order if `conditionForBuy2` is `true`.  
conditionForStopTrading = open < lowest2  
if conditionForStopTrading  
    strategy.cancel_all() // Cancel both limit orders if `conditionForStopTrading` is `true`.  

```

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

### matrix.remove_col() example

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

Example for matrix.remove_col() that creates a 2x2 matrix, copies it, removes the first column from the copy, and displays the original, removed elements, and resulting matrix in a table. Note that indexing starts at zero and removing columns is slower than removing rows.

```pine
//@version=6  
indicator("matrix_remove_col", overlay = true)  
  
// Create a 2x2 matrix with ones.  
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 column from the `matrixCopy` matrix.  
arr = matrix.remove_col(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))  

```

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

### array.new<string>() example

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

Example of creating a string array with an initial value and displaying the first element 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))  
```

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

### matrix.sort() example

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

Creates a 2x2 float matrix, copies it, sorts the copy with default arguments (first column, ascending), and displays both matrices in a table.

```pine
//@version=6  
indicator("`matrix.sort()` Example")  
  
// For efficiency, execute this code only once.  
if barstate.islastconfirmedhistory  
    // Create a 2x2 matrix.  
    var m1 = matrix.new<float>(2, 2, na)  
    // Fill the matrix with values.  
    matrix.set(m1, 0, 0, 3)  
    matrix.set(m1, 0, 1, 4)  
    matrix.set(m1, 1, 0, 1)  
    matrix.set(m1, 1, 1, 2)  
  
    // Copy the matrix to a new one.  
    var m2 = matrix.copy(m1)  
    // Sort the rows of `m2` using the default arguments (first column and ascending order).  
    matrix.sort(m2)  
  
    // Display using a table.  
    if barstate.islastconfirmedhistory  
        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, "Sorted matrix:")  
        table.cell(t, 1, 1, str.tostring(m2))  

```

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

### import library example

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

Example of importing a library and calling one of its functions. The library is bound to the alias m, and the sinh() function is called with 3.14.

```pine
//@version=6  
indicator("num_methods import")  
// Import the first version of the username’s "num_methods" library and assign it to the "m" namespace",  
import username/num_methods/1 as m  
// Call the “sinh()” function from the imported library  
y = m.sinh(3.14)  
// Plot value returned by the "sinh()" function",  
plot(y)  
```

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

### Plot bar_index and conditional close

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

Plots the bar_index variable and a conditional plot that shows the close price only when bar_index exceeds 5000. Use this example to see how bar_index behaves and to verify that bar indexing starts from 0 on the first historical bar.

```pine
//@version=6  
indicator("bar_index")  
plot(bar_index)  
plot(bar_index > 5000 ? close : 0)  

```

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

### var keyword example

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

Example showing var usage: 'a' holds the first bar's close, 'b' the first green bar's close, and 'c' the tenth green bar's close.

```pine
//@version=6  
indicator("Var keyword example")  
var a = close  
var b = 0.0  
var c = 0.0  
var green_bars_count = 0  
if close > open  
    var x = close  
    b := x  
    green_bars_count := green_bars_count + 1  
    if green_bars_count >= 10  
        var y = close  
        c := y  
plot(a)  
plot(b)  
plot(c)  
```

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

### Extensive str.format() demo with modifiers

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

Extensive example showing format modifiers for decimals, integer rounding, currency, and percent, plus examples with multiple arguments. Each line includes the expected return value in comments.

```pine
//@version=6  
indicator("Extensive `str.format()` demo", overlay=true)  
// The format specifier inside the curly braces accepts certain modifiers:  
// - Specify the number of decimals to display:  
s1 = str.format("{0,number,#.#}", 1.34) // returns: 1.3  
label.new(bar_index, close, text=s1)  
// - Round a float value to an integer:  
s2 = str.format("{0,number,integer}", 1.34) // returns: 1  
label.new(bar_index - 1, close, text=s2)  
// - Display a number in currency:  
s3 = str.format("{0,number,currency}", 1.34) // returns: $1.34  
label.new(bar_index - 2, close, text=s3)  
// - Display a number as a percentage:  
s4 = str.format("{0,number,percent}", 0.5) // returns: 50%  
label.new(bar_index - 3, close, text=s4)  
// EXAMPLES WITH SEVERAL ARGUMENTS  
// returns: Number 1 is not equal to 4  
s5 = str.format("Number {0} is not {1} to {2}", 1, "equal", 4)  
label.new(bar_index - 4, close, text=s5)  
// returns: 1.34 != 1.3  
s6 = str.format("{0} != {0, number, #.#}", 1.34)  
label.new(bar_index - 5, close, text=s6)  
// returns: 1 is equal to 1, but 2 is equal to 2  
s7 = str.format("{0, number, integer} is equal to 1, but {1, number, integer} is equal to 2", 1.34, 1.52)  
label.new(bar_index - 6, close, text=s7)  
// returns: The cash turnover amounted to $1,340,000.00  
s8 = str.format("The cash turnover amounted to {0, number, currency}", 1340000)  
label.new(bar_index - 7, close, text=s8)  
// returns: Expected return is 10% - 20%  
s9 = str.format("Expected return is {0, number, percent} - {1, number, percent}", 0.1, 0.2)  
label.new(bar_index - 8, close, text=s9)  
```

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

### ta.rsi() example

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

Example for ta.rsi() showing the built-in function and a Pine Script equivalent using ta.rma(). The example plots both on the same 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))  

```

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

### ta.sar() example

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

Example for ta.sar() showing the built-in function and a Pine Script equivalent. The example plots both with cross style and linewidth 3.

```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)  

```

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

### ta.rma() example

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

Example for ta.rma() showing the built-in function and a Pine Script equivalent using ta.sma() and nz(). The example plots both on the same 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))  

```

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

### strategy.convert_to_symbol() example

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

Example strategy that calculates the maximum quantity of contracts buyable with 300 euros and enters long trades every 15 bars, closing every 20 bars.

```pine
//@version=6  
strategy("`strategy.convert_to_symbol` Example", currency = currency.EUR)  
  
// Calculate the max qty we can buy using current chart's currency.
calcContracts(accountMoney) =>  
    math.floor(strategy.convert_to_symbol(accountMoney) / syminfo.pointvalue / close)  
  
// Return max qty we can buy using 300 euros
qt = calcContracts(300)  
  
// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars using our custom qty.
if bar_index % 15 == 0  
    strategy.entry("Long", strategy.long, qty = qt)  
if bar_index % 20 == 0  
    strategy.close("Long")  

```

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

### array.sort_indices() Example

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

Example usage for array.sort_indices() function.

```APIDOC
## array.sort_indices() Example

### Example
```pine
//@version=6  
indicator("array.sort_indices")  
a = array.from(5, -2, 0, 9, 1)  
sortedIndices = array.sort_indices(a) // [1, 2, 4, 0, 3]  
indexOfSmallestValue = array.get(sortedIndices, 0) // 1  
smallestValue = array.get(a, indexOfSmallestValue) // -2  
plot(smallestValue)  
```
```

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

### matrix.set() example

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

Creates a 2x3 integer matrix filled with 4, sets the element at row 0, column 1 to 3, and displays the matrix in a label.

```pine
//@version=6  
indicator("`matrix.set()` Example")  
  
// Create a 2x3 "int" matrix containing values `4`.  
m = matrix.new<int>(2, 3, 4)  
  
// Replace the value of element at row 1 and column 2 with value `3`.  
matrix.set(m, 0, 1, 3)  
  
// Display using a label.  
if barstate.islastconfirmedhistory  
    label.new(bar_index, high, str.tostring(m))  

```

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

### ta.wma() example with manual implementation

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

Example of ta.wma() and a manual Pine implementation using a loop. The manual version is much less efficient but produces the same result.

```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))  

```

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

### array.sort() Example

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

Example usage for array.sort() function.

```APIDOC
## array.sort() Example

### Example
```pine
//@version=6  
indicator("array.sort example")  
a = array.new_float(0,0)  
for i = 0 to 5  
    array.push(a, high[i])  
array.sort(a, order.descending)  
if barstate.islast  
    label.new(bar_index, close, str.tostring(a))  
```
```

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

### array.slice() Example

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

Example usage for array.slice() function.

```APIDOC
## array.slice(id, index_from, index_to)

### Example
```pine
//@version=6  
indicator("array.slice example")  
a = array.new_float(0)  
for i = 0 to 9  
    array.push(a, close[i])  
// take elements from 0 to 4  
// *note that changes in slice also modify original array  
slice = array.slice(a, 0, 5)  
plot(array.sum(a) / 10)  
plot(array.sum(slice) / 5)  
```
```
Tokens:
Raw