FMZ PINE Script Doc

Valor t é NaN.

• trail_price(série int/float) Um argumento opcional. Nível de ativação do trailing stop (requer um preço específico). Se for especificado, uma ordem de trailing stop será colocada quando o nível de preço especificado for atingido. O offset (em ticks) para determinar o preço inicial da ordem de trailing stop é especificado no argumento trail_offset: X ticks inferior ao nível de ativação para sair de posição longa; X ticks superior ao nível de ativação para sair de posição curta. O valor padrão é NaN.
• trail_points(série int/float) Um argumento opcional. Nível de ativação do trailing stop (lucro especificado em ticks). Se for especificado, uma ordem de trailing stop será colocada quando o nível de preço calculado (montante especificado de lucro) for atingido. O offset (em ticks) para determinar o preço inicial da ordem de trailing stop é especificado no argumento trail_offset: X ticks inferior ao nível de ativação para sair de posição longa; X ticks superior ao nível de ativação para sair de posição curta. O valor padrão é NaN.
• trail_offset(série int/float) Um argumento opcional. Preço de trail stop (especificado em ticks). O deslocamento em ticks para determinar o preço inicial da ordem de trail stop: X ticks inferior a trail_price ou trail_points para sair de posição longa; X ticks superior a trail_price ou trail_points para sair de posição curta. O valor padrão é NaN.
• oca_name(string de série) Um argumento opcional. Nome do grupo OCA (oca_type = strategy.oca.reduce) ao qual pertencem o objetivo de lucro, o stop loss / as ordens de stop trailing. Se o nome não for especificado, ele será gerado automaticamente.Observe-se que a FMZ não apoia este argumento.
• commentUm argumento opcional, instruções adicionais para a ordem.
• when(série bool) Um argumento opcional. Condição da ordem. A ordem é colocada se a condição for true. Se a condição for false, nada acontece (a ordem colocada anteriormente com o mesmo ID não é cancelada). Valor padrão é true.
• alert_message(serie string) Um argumento opcional quando se usa o marcador de espaço {{strategy.order.alert_message}} no campo Message da caixa de diálogo Create Alert.

strategy.cancel

Trata-se de um comando para cancelar/desativar ordens pendentes, referenciando os seus nomes, que foram gerados pelas funções: strategy.order, strategy.entry estrategy.exit.

strategy.cancel(id, when) 

Exemplo

strategy(title = "simple order cancellation example")
conditionForBuy = open > high[1]
strategy.entry("long", strategy.long, 1, limit = low, when = conditionForBuy) // enter long using limit order at low price of current bar if conditionForBuy is true
strategy.cancel("long", when = not conditionForBuy) // cancel the entry order with name "long" if conditionForBuy is false

Argumentos

• id(serie string) Um argumento necessário. O identificador da ordem. É possível cancelar uma ordem referenciando seu identificador.
• when(série bool) Um argumento opcional. Condição para cancelar uma ordem com ID especificado. Se a condição for true, então a ordem com ID especificado será cancelada. Valor padrão é true.

estratégia.cancelar_todos

Trata-se de um comando para cancelar/desativar todas as ordens pendentes, que foram geradas pelas funções: strategy.order, strategy.entry estrategy.exit.

strategy.cancel_all(when) 

Exemplo

strategy(title = "simple all orders cancellation example")
conditionForBuy1 = open > high[1]
strategy.entry("long entry 1", strategy.long, 1, limit = low, when = conditionForBuy1) // enter long by limit if conditionForBuy1 is true
conditionForBuy2 = conditionForBuy1 and open[1] > high[2]
strategy.entry("long entry 2", strategy.long, 1, limit = ta.lowest(low, 2), when = conditionForBuy2) // enter long by limit if conditionForBuy2 is true
conditionForStopTrading = open < ta.lowest(low, 2)
strategy.cancel_all(conditionForStopTrading) // cancel both limit orders if the conditon conditionForStopTrading is true

Argumentos

• when(série bool) Um argumento opcional. Condição para cancelar todas as ordens. Se a condição for verdadeira, todas as ordens ativas serão canceladas. O valor padrão é true.

strategy.order

É um comando para colocar uma ordem. Se uma ordem com o mesmo ID já estiver pendente, é possível modificar a ordem. Se não houver uma ordem com a ID especificada, uma nova ordem é colocada. Para desativar a ordem, o comando strategy.cancel ou strategy.cancel_all deve ser usado. Em comparação com a função strategy.entry, a função strategy.order não é afetada pela piramidagem. Se os parâmetros limit e stop forem NaN, o tipo de ordem é a ordem de mercado.

strategy.order(id, direction, qty, limit, stop, oca_name, oca_type, comment, when, alert_message)

Exemplo

strategy(title = "simple strategy order example")
strategy.order("buy", strategy.long, 1, when = open > high[1]) // buy by market if current open great then previous high
strategy.order("sell", strategy.short, 1, when = open < low[1]) // sell by market if current open less then previous low

Argumentos

• id(serie string) Um parâmetro necessário. O identificador da ordem. É possível cancelar ou modificar uma ordem referenciando seu identificador.
• direction(strategy_direction) Um parâmetro necessário. Direção da ordem: strategy.long é para comprar, strategy.short é para vender.
• qty(série int/float) Um parâmetro opcional. Número de contratos/acções/lotes/unidades a negociar. O valor por defeito é NaN.
• limit(série int/float) Um parâmetro opcional. Preço limite da ordem. Se for especificado, o tipo de ordem é limit, ou stop-limit. NaN deve ser especificado para qualquer outro tipo de ordem.
• stop(série int/float) Um parâmetro opcional. Preço de parada da ordem. Se for especificado, o tipo de ordem é stop, ou stop-limit. NaN deve ser especificado para qualquer outro tipo de ordem.
• oca_name(string de série) Um parâmetro opcional. Nome do grupo OCA ao qual a ordem pertence. Se a ordem não deve pertencer a nenhum grupo OCA específico, deve haver uma cadeia vazia.Observe-se que a FMZ não apoia este argumento.
• oca_type(string de entrada) Um parâmetro opcional. Tipo do grupo OCA. Os valores permitidos são: strategy.oca.none - a ordem não deve pertencer a nenhum grupo OCA específico; strategy.oca.cancel - a ordem deve pertencer a um grupo OCA, onde, assim que uma ordem é executada, todas as outras ordens do mesmo grupo são canceladas; strategy.oca.reduce - a ordem deve pertencer a um grupo OCA, onde, se X número de contratos de uma ordem for executada, o número de contratos para cada outra ordem do mesmo grupo OCA é diminuído em X.Observe-se que a FMZ não apoia este argumento.
• commentUm parâmetro opcional, notas adicionais sobre a ordem.
• when(série bool) Um parâmetro opcional. Condição da ordem. A ordem é colocada se a condição for true. Se a condição for false, nada acontece (a ordem colocada anteriormente com o mesmo ID não é cancelada). Valor padrão é true.
• alert_message(serie string) Um parâmetro opcional que substitui o marcador de espaço {{strategy.order.alert_message}} quando usado na caixa de diálogo Create Alerts Message.

estratégia.abertura de negociações. entrada_bar_index

Retorna o bar_index da entrada de negociação aberta.

strategy.opentrades.entry_bar_index(trade_num)

Espere por 10 bares e feche a posição.

Exemplo

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

Argumentos

• trade_num(série int) O número de transacção da primeira transacção é zero.

Veja também: strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

estratégia.abertura de negócios. entrada_id

Retorna o id da entrada de transação aberta.

strategy.opentrades.entry_id(trade_num)

Exemplo

strategy("`strategy.opentrades.entry_id` Example", overlay = true)

// We enter a long position when 14 period sma crosses over 28 period sma.
// We enter a short position when 14 period sma crosses under 28 period sma.
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))

// Strategy calls to enter a long or short position when the corresponding condition is met.
if longCondition
    strategy.entry("Long entry at bar #" + str.tostring(bar_index), strategy.long)
if shortCondition
    strategy.entry("Short entry at bar #" + str.tostring(bar_index), strategy.short)

// Display ID of the latest open position.
if barstate.islastconfirmedhistory
    runtime.log("Last opened position is " + strategy.opentrades.entry_id(strategy.opentrades - 1))

RetornoRetorna o ID da entrada de transação aberta.

Argumentos

• trade_num(série int) O número de transacção da primeira transacção é zero.

ObservaçõesA função retorna na se o trade_num não estiver no intervalo: 0 para strategy.opentrades-1.

Veja também: strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

estratégia.abertura de negociações.preço de entrada

Retorna o preço da entrada de negociação aberta.

strategy.opentrades.entry_price(trade_num)

Exemplo

strategy("strategy.closedtrades.entry_price Example 1")

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

// Return the entry price for the latest closed trade.
entryPrice = strategy.closedtrades.entry_price(strategy.closedtrades - 1)

plot(entryPrice, "Long entry price")

Calcular o preço médio da posição aberta.

Exemplo

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

// Calculate average open position price.
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())

Argumentos

• trade_num(série int) O número de transacção da primeira transacção é zero.

Veja também: strategy.closedtrades.exit_price

Estratégia.abertura.tempo de entrada

Retorna a hora UNIX da entrada de negociação aberta.

strategy.opentrades.entry_time(trade_num)

Exemplo

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

Argumentos

• trade_num(série int) O número de transacção da primeira transacção é zero.

Veja também: strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

Retorna o lucro/perda do comércio aberto.

strategy.opentrades.profit(trade_num)

Retornar o lucro da última operação aberta.

Exemplo

strategy("`strategy.opentrades.profit` Example 1", commission_type = strategy.commission.percent, commission_value = 0.1)

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

plot(strategy.opentrades.profit(strategy.opentrades - 1), "Profit of the latest open trade")

Calcule o lucro de todas as posições abertas.

Exemplo

strategy("`strategy.opentrades.profit` Example 2", pyramiding = 5)

// Strategy calls to enter 5 long positions every 2 bars.
if bar_index % 2 == 0
    strategy.entry("Long", strategy.long, qty = 5)

// Calculate open profit or loss for the open positions.
tradeOpenPL() =>
    sumProfit = 0.0
    for tradeNo = 0 to strategy.opentrades - 1
        sumProfit += strategy.opentrades.profit(tradeNo)
    result = sumProfit
    
plot(tradeOpenPL(), "Profit of all open trades")

Argumentos

• trade_num(série int) O número de transacção da primeira transacção é zero.

Veja também: strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit

strategy.opentrades.size

Retorna a direção e o número de contratos negociados no comércio aberto. Se o valor for > 0, a posição de mercado foi longa. Se o valor for < 0, a posição de mercado foi curta.

strategy.opentrades.size(trade_num)

Exemplo

strategy("`strategy.opentrades.size` Example 1")

// We calculate the max amt of shares we can buy.
amtShares = math.floor(strategy.equity / close)
// 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, qty = amtShares)
if bar_index % 20 == 0
    strategy.close("Long")

// Plot the number of contracts in the latest open trade.
plot(strategy.opentrades.size(strategy.opentrades - 1), "Amount of contracts in latest open trade")

Calcular a percentagem média de lucro das posições abertas.

Exemplo

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)

Argumentos

• trade_num(série int) O número de transacção da primeira transacção é zero.

Veja também: strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

estratégia.closedtrades.entry_bar_index

Retorna o bar_index da entrada da transação fechada.

strategy.closedtrades.entry_bar_index(trade_num)

Exemplo

strategy("strategy.closedtrades.entry_bar_index Example")
// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")
// Function that calculates the average amount of bars in a trade.
avgBarsPerTrade() =>
    sumBarsPerTrade = 0
    for tradeNo = 0 to strategy.closedtrades - 1
        // Loop through all closed trades, starting with the oldest.
        sumBarsPerTrade += strategy.closedtrades.exit_bar_index(tradeNo) - strategy.closedtrades.entry_bar_index(tradeNo) + 1
    result = nz(sumBarsPerTrade / strategy.closedtrades)
plot(avgBarsPerTrade())

Argumentos

• trade_num(série int) O número de transacção da transacção encerrada.

Veja também: strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

estratégia.closedtrades.exit_price

Retorna o preço de saída de um negócio fechado.

strategy.closedtrades.exit_price(trade_num)

Exemplo

strategy("strategy.closedtrades.exit_price Example 1")

// We are creating a long trade every 5 bars
if bar_index % 5 == 0
    strategy.entry("Long",  strategy.long)
strategy.close("Long")

// Return the exit price from the latest closed trade.
exitPrice = strategy.closedtrades.exit_price(strategy.closedtrades - 1)

plot(exitPrice, "Long exit price")

Calcular a percentagem média de lucro para todas as operações fechadas.

Exemplo

strategy("strategy.closedtrades.exit_price Example 2")

// Strategy calls to create single short and long trades.
if bar_index == last_bar_index - 15
    strategy.entry("Long Entry",  strategy.long)
else if bar_index == last_bar_index - 10
    strategy.close("Long Entry")
    strategy.entry("Short", strategy.short)
else if bar_index == last_bar_index - 5
    strategy.close("Short")

// Calculate profit for both closed trades.
profitPct = 0.0
for tradeNo = 0 to strategy.closedtrades - 1
    entryP = strategy.closedtrades.entry_price(tradeNo)
    exitP = strategy.closedtrades.exit_price(tradeNo)
    profitPct += (exitP - entryP) / entryP * strategy.closedtrades.size(tradeNo) * 100
    
// Calculate average profit percent for both closed trades.
avgProfitPct = nz(profitPct / strategy.closedtrades)

plot(avgProfitPct)

Argumentos

• trade_num(série int) Número de transacção da transacção encerrada.

Veja também: strategy.closedtrades.entry_price

estratégia.closedtrades.exit_bar_index

Retornar o bar_index da saída da transação fechada.

strategy.closedtrades.exit_bar_index(trade_num)

Exemplo

strategy("strategy.closedtrades.exit_bar_index Example 1")

// Strategy calls to place a single short trade. We enter the trade at the first bar and exit the trade at 10 bars before the last chart bar.
if bar_index == 0
    strategy.entry("Short",  strategy.short)
if bar_index == last_bar_index - 10
    strategy.close("Short")

// Calculate the amount of bars since the last closed trade.
barsSinceClosed = strategy.closedtrades > 0 ? bar_index - strategy.closedtrades.exit_bar_index(strategy.closedtrades - 1) : na

plot(barsSinceClosed, "Bars since last closed trade")

Calcular o número médio de linhas K por transação.

Exemplo

strategy("strategy.closedtrades.exit_bar_index Example 2")

// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")

// Function that calculates the average amount of bars per trade.
avgBarsPerTrade() =>
    sumBarsPerTrade = 0
    for tradeNo = 0 to strategy.closedtrades - 1
        // Loop through all closed trades, starting with the oldest.
        sumBarsPerTrade += strategy.closedtrades.exit_bar_index(tradeNo) - strategy.closedtrades.entry_bar_index(tradeNo) + 1
    result = nz(sumBarsPerTrade / strategy.closedtrades)

plot(avgBarsPerTrade())

Argumentos

• trade_num(série int) O número de transacção da transacção encerrada.

Veja também: bar_index

estratégia.closedtrades.entry_id

Retorna o id da entrada da transacção encerrada.

strategy.closedtrades.entry_id(trade_num)

Exemplo

strategy("strategy.closedtrades.entry_id Example", overlay = true)
var isOpen = false 
var openIndex = -1
// Enter a short position and close at the previous to last bar.
if not barstate.ishistory and not isOpen
    strategy.entry("Short at bar #" + str.tostring(bar_index), strategy.short)
    isOpen := true
    openIndex := bar_index
if openIndex != -1 and bar_index > openIndex + 100
    strategy.close_all()
    
// Display ID of the last entry position.
if barstate.islastconfirmedhistory
    runtime.log("Last Entry ID is: " + strategy.closedtrades.entry_id(strategy.closedtrades - 1))

RetornoRetorna o id da entrada da transacção encerrada.

Argumentos

• trade_num(série int) O número de transacção da transacção encerrada.

ObservaçõesA função retorna na se o trade_num não estiver no intervalo: 0 para strategy.closedtrades-1.

Veja também: strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

estratégia.transações fechadas.preço de entrada

Retorna o preço da entrada da transação fechada.

strategy.closedtrades.entry_price(trade_num)

Exemplo

strategy("strategy.closedtrades.entry_price Example 1")

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

// Return the entry price for the latest  entry.
entryPrice = strategy.closedtrades.entry_price(strategy.closedtrades - 1)

plot(entryPrice, "Long entry price")

Calcular a percentagem média de lucro para todas as operações fechadas.

Exemplo

strategy("strategy.closedtrades.entry_price Example 2")

// Strategy calls to create single short and long trades
if bar_index == last_bar_index - 15
    strategy.entry("Long Entry",  strategy.long)
else if bar_index == last_bar_index - 10
    strategy.close("Long Entry")
    strategy.entry("Short", strategy.short)
else if bar_index == last_bar_index - 5
    strategy.close("Short")

// Calculate profit for both closed trades.
profitPct = 0.0
for tradeNo = 0 to strategy.closedtrades - 1
    entryP = strategy.closedtrades.entry_price(tradeNo)
    exitP = strategy.closedtrades.exit_price(tradeNo)
    profitPct += (exitP - entryP) / entryP * strategy.closedtrades.size(tradeNo) * 100
    
// Calculate average profit percent for both closed trades.
avgProfitPct = nz(profitPct / strategy.closedtrades)

plot(avgProfitPct)

Argumentos

• trade_num(série int) O número de transacção da transacção encerrada.

Veja também: strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

estratégia.transações fechadas.tempo de entrada

Retorna a hora UNIX da entrada de transação fechada.

strategy.closedtrades.entry_time(trade_num)

Exemplo

strategy("strategy.closedtrades.entry_time Example", overlay = true)

// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")

// Calculate the average trade duration 
avgTradeDuration() =>
    sumTradeDuration = 0
    for i = 0 to strategy.closedtrades - 1
        sumTradeDuration += strategy.closedtrades.exit_time(i) - strategy.closedtrades.entry_time(i)
    result = nz(sumTradeDuration / strategy.closedtrades)

// Display average duration converted to seconds and formatted using 2 decimal points
if barstate.islastconfirmedhistory
    runtime.log(str.tostring(avgTradeDuration() / 1000, "#.##") + " seconds")

Argumentos

• trade_num(série int) O número de transacção da transacção encerrada.

Veja também: strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

Retorna o lucro/perda do negócio fechado.

strategy.closedtrades.profit(trade_num)

Exemplo

strategy("`strategy.closedtrades.profit` 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")

// Calculate average gross profit by adding the difference between gross profit and commission.
avgGrossProfit() =>
    sumGrossProfit = 0.0
    for tradeNo = 0 to strategy.closedtrades - 1
        sumGrossProfit += strategy.closedtrades.profit(tradeNo) - strategy.closedtrades.commission(tradeNo)
    result = nz(sumGrossProfit / strategy.closedtrades)
    
plot(avgGrossProfit(), "Average gross profit")

Argumentos

• trade_num(série int) O número de transacção da transacção encerrada.

Veja também: strategy.opentrades.profit strategy.closedtrades.commission

strategy.closedtrades.size

Retorna a direção e o número de contratos negociados na negociação fechada. Se o valor for > 0, a posição de mercado foi longa. Se o valor for < 0, a posição de mercado foi curta.

strategy.closedtrades.size(trade_num)

Exemplo

strategy("`strategy.closedtrades.size` Example 1")

// We calculate the max amt of shares we can buy.
amtShares = math.floor(strategy.equity / close)
// 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, qty = amtShares)
if bar_index % 20 == 0
    strategy.close("Long")

// Plot the number of contracts traded in the last closed trade.     
plot(strategy.closedtrades.size(strategy.closedtrades - 1), "Number of contracts traded")

Calcular a percentagem média de lucro em operações fechadas.

Exemplo

strategy("`strategy.closedtrades.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 both closed trades.
profitPct = 0.0
for tradeNo = 0 to strategy.closedtrades - 1
    entryP = strategy.closedtrades.entry_price(tradeNo)
    exitP = strategy.closedtrades.exit_price(tradeNo)
    profitPct += (exitP - entryP) / entryP * strategy.closedtrades.size(tradeNo) * 100
    
// Calculate average profit percent for both closed trades.
avgProfitPct = nz(profitPct / strategy.closedtrades)

plot(avgProfitPct)

Argumentos

• trade_num(série int) O número de transacção da transacção encerrada.

Veja também: strategy.opentrades.size strategy.position_size strategy.closedtrades strategy.opentrades

estratégia.transações fechadas.tempo de saída

Retorna a hora UNIX da saída da transação fechada.

strategy.closedtrades.exit_time(trade_num)

Exemplo

strategy("strategy.closedtrades.exit_time Example 1")

// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")

// Calculate the average trade duration. 
avgTradeDuration() =>
    sumTradeDuration = 0
    for i = 0 to strategy.closedtrades - 1
        sumTradeDuration += strategy.closedtrades.exit_time(i) - strategy.closedtrades.entry_time(i)
    result = nz(sumTradeDuration / strategy.closedtrades)

// Display average duration converted to seconds and formatted using 2 decimal points.
if barstate.islastconfirmedhistory
    label.new(bar_index, high, str.tostring(avgTradeDuration() / 1000, "#.##") + " seconds")

Reabrir operações fechadas após X segundos.

Exemplo

strategy("strategy.closedtrades.exit_time Example 2")

// Strategy calls to emulate a single long trade at the first bar.
if bar_index == 0
    strategy.entry("Long", strategy.long)

reopenPositionAfter(timeSec) =>
    if strategy.closedtrades > 0
        if time - strategy.closedtrades.exit_time(strategy.closedtrades - 1) >= timeSec * 1000
            strategy.entry("Long", strategy.long)

// Reopen last closed position after 120 sec.                
reopenPositionAfter(120)

if ta.change(strategy.opentrades)
    strategy.exit("Long", stop = low * 0.9, profit = high * 2.5)

Argumentos

• trade_num(série int) O número de transacção da transacção encerrada.

Veja também: strategy.closedtrades.entry_time

Estratégia.risco.permitir_entrada_em

Esta função pode ser utilizada para especificar em que direcção do mercado a função strategy.entry pode abrir posições.

strategy.risk.allow_entry_in(value)

Exemplo

strategy("strategy.risk.allow_entry_in")

strategy.risk.allow_entry_in(strategy.direction.long)
strategy.entry("Long", strategy.long, when = open > close)
// Instead of opening a short position with 10 contracts, this command will close long entries.
strategy.entry("Short", strategy.short, when = open < close, qty = 10)

Argumentos

• valueA direcção permitida.strategy.direction.all, strategy.direction.long, strategy.direction.short

O valor da posição em risco é o valor da posição em risco.

Esta regra tem por objectivo determinar a dimensão máxima de uma posição de mercado e afecta a seguinte função:strategy.entry. A quantidade de entrada pode ser reduzida (se necessário) a tal número de contratos/ações/lotes/unidades, de modo que o tamanho total da posição não exceda o valor especificado em strategy.risk.max_position_size. Se a quantidade mínima possível ainda violar a regra, a ordem não será colocada.

strategy.risk.max_position_size(contracts)

Exemplo

strategy("risk.max_position_size Demo", default_qty_value = 100)
strategy.risk.max_position_size(10)
strategy.entry("buy", strategy.long, when = open > close)
plot(strategy.position_size)  // max plot value will be 10

Argumentos

• contracts(simples int/float) Um parâmetro exigido. Número máximo de contratos/ações/lotes/unidades numa posição.

Matemática

math.abs

Valor absoluto denumberénumbersenumber>= 0, ou -number otherwise.

math.abs(number) 

RetornoO valor absoluto denumber.

math.acos

A função acos retorna o arcosino (em radianos) de um número tal que cos ((acos(y)) = y para y na faixa [-1, 1].

math.acos(angle)

RetornoO arco cosseno de um valor; o ângulo retornado está no intervalo [0, Pi], ou na se y estiver fora do intervalo [-1, 1].

math.random

Retorna um valor pseudo-aleatório. A função gerará uma sequência diferente de valores para cada execução de script. Usando o mesmo valor para o argumento opcional seed produzirá uma sequência repetível.

math.random(min, max, seed)

RetornoUm valor aleatório.

Argumentos

• min(série int/float) O limite inferior do intervalo de valores aleatórios. O valor não está incluído no intervalo. O padrão é 0.
• max(série int/float) O limite superior do intervalo de valores aleatórios. O valor não está incluído no intervalo. O padrão é 1.
• seed(input int) Argumento opcional. Quando a mesma semente é usada, permite que chamadas sucessivas à função produzam um conjunto repetível de valores.

math.asin

A função asin retorna o arcsino (em radianos) de um número tal que sin ((asin(y)) = y por y no intervalo [-1, 1].

math.asin(angle) 

RetornoO arcinos de um valor; o ângulo retornado está na faixa [-Pi/2, Pi/2], ou na se y estiver fora da faixa [-1, 1].

math.atan

A função atan retorna a arctangente (em radianos) de um número tal que tan ((atan ((y)) = y para qualquer y.

math.atan(angle) 

RetornoA tangente de arco de um valor; o ângulo retornado está no intervalo [-Pi/2, Pi/2].

math.ceil

A função ceiling retorna o menor (mais próximo do infinito negativo) inteiro que é maior ou igual ao argumento.

math.ceil(number)

RetornoO menor número inteiro menor ou igual ao número dado.

Veja também: math.floor math.round

math.cos

A função cos retorna o cosseno trigonométrico de um ângulo.

math.cos(angle) 

RetornoO cosseno trigonométrico de um ângulo.

Argumentos

• angle(série int/float) Ângulo, em radianos.

math.exp

A função exp denumberÉ elevado ao poder denumber, onde e é o número de Euler.

math.exp(number) 

RetornoUm valor que representa e elevado à potência denumber.

Veja também: math.pow

math.floor

math.floor(number) 

RetornoO maior número inteiro menor ou igual ao número dado.

Veja também: math.ceil math.round

math.log

Logaritmo natural de qualquernumber> 0 é o único y tal que e ^ y =number.

math.log(number)

RetornoO logaritmo natural denumber.

Veja também: math.log10

math.log10

O logaritmo comum (ou base 10) denumberé a potência a que 10 deve ser elevado para obter onumber. 10^y =number.

math.log10(number)

RetornoO logaritmo de base 10 denumber.

Veja também: math.log

math.pow

Função de potência matemática.

math.pow(base, exponent)

Exemplo

// math.pow
plot(math.pow(close, 2))

Retorno baseelevados ao poder deexponentSe...baseé uma série, é calculada por elementos.

Argumentos

• base(série int/float) Especificar a base a utilizar.
• exponent(série int/float) Especifica o expoente.

Veja também: math.sqrt math.exp

math.sign

O sinal (signum) de number é zero se number é zero, 1.0 se number é maior que zero, -1.0 se number é menor que zero.

math.sign(number)

RetornoO sinal da discussão.

math.sin

A função sin retorna o seno trigonométrico de um ângulo.

math.sin(angle)

RetornoO seno trigonométrico de um ângulo.

Argumentos

• angle(série int/float) Ângulo, em radianos.

math.sqrt

Raiz quadrada de qualquernumber>= 0 é o único y >= 0 tal que y ^ 2 =number.

math.sqrt(number)

RetornoA raiz quadrada denumber.

Veja também: math.pow

math.tan

A função tan retorna a tangente trigonométrica de um ângulo.

math.tan(angle)

RetornoA tangente trigonométrica de um ângulo.

Argumentos

• angle(série int/float) Ângulo, em radianos.

math.round

Retorna o valor denumberse o valor de um número inteiro é redondado para o número inteiro mais próximo, com os laços redondados para cima.precisionO parâmetro utilizado, retorna um valor de flutuação arredondado para esse número de casas decimais.

math.round(number) 

math.round(number, precision) 

RetornoO valor denumberArredondado para o número inteiro mais próximo, ou de acordo com a precisão.

Argumentos

• number(série int/float) O valor a arredondar.
• precision(série int) Argumento opcional.numberQuando nenhum argumento é fornecido, o arredondamento é para o número inteiro mais próximo.

ObservaçõesObserve que para os valores na a função retorna na.

Veja também: math.ceil math.floor

math.max

Retorna o maior dos valores múltiplos.

math.max(number0, number1, ...) 

Exemplo

// math.max
plot(math.max(close, open))
plot(math.max(close, math.max(open, 42)))

RetornoO maior de múltiplos valores dados.

Veja também: math.min

math.min

Retorna o menor dos valores múltiplos.

math.min(number0, number1, ...) 

Exemplo

// math.min
plot(math.min(close, open))
plot(math.min(close, math.min(open, 42)))

RetornoO menor dos múltiplos valores dados.

Veja também: math.max

math.avg

Calcula a média de todas as séries dadas (por elementos).

math.avg(number0, number1, ...)

Retorno Average.

Veja também: math.sum ta.cum ta.sma

matemática.redonda_para_mintick

Retorna o valor arredondado para o mintick do símbolo, ou seja, o valor mais próximo que pode ser dividido por syminfo.mintick, sem o restante, com ligações arredondadas para cima.

math.round_to_mintick(number) 

RetornoOnumberArredondado para a precisão do tick.

Argumentos

• number(série int/float) O valor a arredondar.

Veja também: math.ceil math.floor

math.sum

A função soma retorna a soma deslizante dos últimos valores y de x.

math.sum(source, length)

RetornoTotal desourceparalengthAs grades de volta.

Argumentos

• source(série int/float) Série de valores a processar.
• length(série int) Número de barras ( comprimento).

Veja também: ta.cum for

math.todegrees

Retorna um ângulo aproximadamente equivalente em graus a partir de um ângulo medido em radianos.

math.todegrees(radians) 

RetornoO valor do ângulo em graus.

Argumentos

• radians(série int/float) Ângulo em radianos.

math.toradians

Retorna um ângulo aproximadamente equivalente em radianos a partir de um ângulo medido em graus.

math.toradians(degrees) 

RetornoO valor do ângulo em radianos.

Argumentos

• degrees(série int/float) Ângulo em graus.

outros

fixnão

Para uma série dada, substitui os valores NaN pelo valor anterior não NaN mais próximo.

fixnan(source) 

RetornoSérie sem lacunas.

Argumentos

• source(série int/float/bool/color)

Veja também: na nz

N.Z.

Substitui os valores NaN por zeros (ou valor dado) numa série.

nz(source, replacement) 

nz(source)

Exemplo

// nz
plot(nz(ta.sma(close, 100)))

RetornoO valor desourceSe não forna. Se o valor desourceéna, retorna zero, ou oreplacementargumento quando um é usado.

Argumentos

• source(série int/float/bool/color) Série de valores a processar.
• replacement(série int/float/bool/color) Valor que substituirá todos os valores na nosource series.

Veja também: na fixnan

Não

Valor de ensaio se for um NaN.

na(x)

Retornoverdadeiro se x não for um número válido (x é NaN), caso contrário falso.

Veja também: fixnan nz

int

Transfere ou trunca o valor de flutuação para int.

int(x) 

RetornoO valor do argumento depois de ser lançado para int.

Veja também: float bool color string

flutuante

Não pode flutuar.

float(x) 

RetornoO valor do argumento após o lançamento para flutuar.

Veja também: int bool color string

alerta

Ativa um evento de alerta quando chamado durante a barra de tempo real e um alerta baseado em eventos da função de alerta foi criado anteriormente para o indicador ou estratégia através da caixa de diálogo Criar alerta.

alert(message, freq)

Exemplo

// alert() example
ma = ta.sma(close, 14)
xUp = ta.crossover(close, ma)
if xUp
    // Trigger the alert the first time a cross occurs during the real-time bar.
    alert("Price (" + str.tostring(close) + ") crossed over MA (" + str.tostring(ma) +  ").", alert.freq_once_per_bar)
plot(ma)
plotchar(xUp, "xUp", "▲", location.top, size = size.tiny)

Argumentos

• messageMensagem enviada quando o alerta é acionado.
• freq(string de entrada) A frequência de acionamento. Os valores possíveis são: alert.freq_all (todas as chamadas de função acionam o alerta), alert.freq_once_per_bar (a primeira chamada de função durante a barra aciona o alerta), alert.freq_once_per_bar_close (a chamada de função aciona o alerta apenas quando ocorre durante a última iteração de script da barra em tempo real, quando ela fecha).

ObservaçõesO Centro de Ajuda explica como criar tais alertas. Ao contrário da condição de alerta, as chamadas de alerta NÃO contam como uma parcela adicional. As chamadas de função podem ser localizadas em escopo global e local. As chamadas de funções não mostram nada no gráfico. O argumento freq afeta apenas a frequência de acionamento da chamada de função onde é usado.

Veja também: alertcondition

Condição de alerta

Criar condição de alerta, que está disponível na caixa de diálogo Criar alerta. Por favor, note, que alertcondition NÃO cria um alerta, ele apenas lhe dá mais opções na caixa de diálogo Criar alerta. Além disso, o efeito alertcondition é invisível no gráfico.

alertcondition(condition, title, message)

Exemplo

// alertcondition
alertcondition(close >= open, title='Alert on Green Bar', message='Green Bar!')

Argumentos

• condition(série bool) Série de valores booleanos que é usado para alerta. valores verdadeiros significam alarme fogo, falso - nenhum alerta. argumento necessário.
• title(const string) Título da condição de alerta.
• message(const string) Mensagem a exibir quando o alarme disparar.

ObservaçõesPor favor, note que no Pine Script v4/v5 uma chamada alertcondition gera um gráfico adicional. Todas essas chamadas são levadas em conta quando calculamos o número de séries de saída por script.

Veja também: alert

Indicador

A fim de ser compatível com oTrading ViewCódigo de estratégia, não é realmente necessário ser chamado.

Veja também: strategy

tempo

A função tempo retorna a hora UNIX da barra atual para o período de tempo e sessão especificados ou NaN se o ponto de tempo estiver fora de sessão.session arguments.

time(timeframe, session, timezone)

time(timeframe, session)

time(timeframe)

Exemplo

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

Ao configurar uma sessão, pode especificar não só as horas e minutos, mas também os dias da semana que serão incluídos nessa sessão. Se os dias não forem especificados, considera-se que a sessão foi fixada de domingo (1) a sábado (7), ou seja, 1100-2000 é igual a 1100-1200:1234567. Você pode alterar isso especificando os dias. Por exemplo, em um símbolo que é negociado sete dias por semana com a sessão de negociação de 24 horas, o seguinte script não colorirá sábados e domingos:

Exemplo

// Time
t1 = time(timeframe.period, "0000-0000:23456")
bgcolor(t1 ? color.new(color.blue, 90) : na)

Um.sessionO argumento pode incluir várias sessões diferentes, separadas por vírgulas. Por exemplo, o seguinte script irá destacar as barras de 10:00 a 11:00 e de 14:00 a 15:00 (somente dias úteis):

Exemplo

// Time
t1 = time(timeframe.period, "1000-1100,1400-1500:23456")
bgcolor(t1 ? color.new(color.blue, 90) : na)

RetornoTempo UNIX.

Argumentos

• timeframeUma cadeia vazia é interpretada como o quadro de tempo atual do gráfico.
• session(string simples) Especificação de sessão. Argumento opcional, sessão do símbolo é usado por padrão. Uma cadeia vazia é interpretada como a sessão do símbolo. FMZ não suporta isso.
• timezone(corrente simples) Fuso horário dosessionO nome do timezone pode ser especificado na notação GMT (por exemplo, GMT-5) ou como um nome de banco de dados do fuso horário da IANA (por exemplo, America/New_York).

ObservaçõesO tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970.

ano

year(time)

year(time, timezone)

RetornoAno (em fusão horária de troca) para o tempo UNIX fornecido.

Argumentos

• time(série int) tempo UNIX em milissegundos.
• timezoneUm argumento opcional.

ReacçõesO tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970. Observe que esta função retorna o ano com base na hora em que as barras estão abertas.

Veja também: year time month dayofmonth dayofweek hour minute second

mês

month(time)

month(time, timezone)

RetornoMês (no fuso horário de troca) para o tempo UNIX fornecido.

Argumentos

• time(série int) tempo UNIX em milissegundos.
• timezoneUm argumento opcional.

ObservaçõesO tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970. Observe que esta função retorna o mês com base na hora em que as barras estão abertas.

Veja também: month time year dayofmonth dayofweek hour minute second

Horário

hour(time)

hour(time, timezone)

RetornoHora (em fusão horária de troca) para o tempo UNIX fornecido.

Argumentos

• time(série int) tempo UNIX em milissegundos.
• timezoneUm parâmetro opcional.

ObservaçõesO tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970.

Veja também: hour time year month dayofmonth dayofweek minute second

Minuto

minute(time)

minute(time, timezone)

RetornoMinuto (em fusão horária de troca) para o tempo UNIX fornecido.

Argumentos

• time(série int) tempo UNIX em milissegundos.
• timezoneUm argumento opcional.

ObservaçõesO tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970.

Veja também: minute time year month dayofmonth dayofweek hour second

Segundo

second(time)

second(time, timezone)

RetornoSegundo (em fuso horário de troca) para o tempo UNIX fornecido.

Argumentos

• time(série int) tempo UNIX em milissegundos.
• timezoneUm parâmetro opcional.

ObservaçõesO tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970.

Veja também: second time year month dayofmonth dayofweek hour minute

Semana-ano

weekofyear(time)

weekofyear(time, timezone)

RetornoSemana do ano (no fuso horário de troca) para o tempo UNIX fornecido.

Argumentos

• time(série int) tempo UNIX em milissegundos.
• timezoneUm parâmetro opcional.

ObservaçõesO tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970. Observe que esta função retorna a semana com base na hora em que as barras estão abertas.

Veja também: weekofyear time year month dayofmonth dayofweek hour minute second

dia/semana

dayofweek(time)

dayofweek(time, timezone)

RetornoDia da semana (no fuso horário de troca) para o tempo UNIX fornecido.

Argumentos

• time(série int) tempo UNIX em milissegundos.
• timezoneUm parâmetro opcional.

ObservaçõesObserve que esta função retorna o dia com base na hora em que as barras estão abertas. O tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970.

Veja também: time dayofmonth

dia do mês

dayofmonth(time)

dayofmonth(time, timezone)

RetornoDia do mês (no fuso horário de troca) para o tempo UNIX fornecido.

Argumentos

• time(série int) tempo unix em milissegundos.
• timezoneUm parâmetro opcional.

ObservaçõesO tempo UNIX é o número de milissegundos que se passaram desde 00:00:00 UTC, 1 de janeiro de 1970. Observe que esta função retorna o dia com base na hora em que as barras estão abertas. Para sessões durante a noite (por exemplo, EURUSD, onde a sessão de segunda-feira começa no domingo, 17:00 UTC-4), este valor pode ser inferior a 1 do dia do dia de negociação.

Veja também: time dayofweek

Marca de data e hora

A função timestamp retorna o tempo UNIX da data e hora especificadas.

timestamp(dateString)

timestamp(year, month, day, hour, minute, second)

timestamp(timezone, year, month, day, hour, minute, second)

Exemplo

// timestamp
plot(timestamp(2016, 01, 19, 09, 30), linewidth=3, color=color.green)
plot(timestamp(syminfo.timezone, 2016, 01, 19, 09, 30), color=color.blue)
plot(timestamp(2016, 01, 19, 09, 30), color=color.yellow)
plot(timestamp("GMT+6", 2016, 01, 19, 09, 30))
plot(timestamp(2019, 06, 19, 09, 30, 15), color=color.lime)
plot(timestamp("GMT+3", 2019, 06, 19, 09, 30, 15), color=color.fuchsia)
plot(timestamp("Feb 01 2020 22:10:05"))
plot(timestamp("2011-10-10T14:48:00"))

Mais.