p loss’ substituirá ‘loss’). - trail_price(series int/float) Parâmetros opcionais ◦ nível de ativação do tracking stop loss (precisa especificar o preço) ◦ se especificado, o tracking stop loss será colocado quando o nível de preço especificado for atingido ◦ desvio especificado no parâmetro de coluna trail_offset para determinar o desvio do preço inicial do tracking stop loss ◦ medido em pontos: X pontos abaixo do nível de ativação para sair do multihead; X pontos acima do nível de ativação para sair do headless ◦ o valor padrão é ◦ NaN ◦ - trail_points(series int/float) Parâmetros opcionais:  rastrear o nível de ativação do stop loss (indicado em pontos de lucro)  se especificado, colocar um stop loss de rastreamento quando o nível de preço calculado (indicado em pontos de lucro) for atingido  especificar o deslocamento do preço inicial do stop loss de rastreamento no parâmetro de coluna trail_offset (indicado em pontos de cálculo): X pontos abaixo do nível de ativação para sair de um multihead; X pontos acima do nível de ativação para sair de um zerohead  o valor padrão é NaN - trail_offset(series int/float) parâmetros opcionais. Tracking stop loss activation level ((expresso em pontos). O desvio em pontos é usado para determinar o preço inicial do tracking stop loss: X pontos abaixo do ‘trail_price’ ou ‘trail_points’ para sair do multi-cabeça; X pontos acima do ‘trail_price’ ou ‘trail_points’ para sair do cabeça vazia. - oca_name(series string) Parâmetros selecionáveis. Nome do grupo OCA (oca_type = strategy.oca.reduce) Objetivo de ganho, stop loss / stop loss. Se o nome não for especificado, ele será gerado automaticamente.Nota: O FMZ não suporta este parâmetro. - comment(series string) Parâmetros selecionáveis。 Outras instruções da encomenda。 - when(series bool) um parâmetro selecionável. A condição da ordem. Se for “true”, a ordem é colocada. Se for “false”, nada acontece. - alert_message(series string) Um parâmetro opcional quando o símbolo {{strategy.order.alert_message}} é usado no campo de mensagens de alerta da caixa de diálogo de criação de alerta.

strategy.cancel

Esta é uma ordem de cancelamento/desativação de todos os listados pré-encomendados com o nome de referência, gerada pelas funções: strategy.order, strategy.entry e strategy.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

parâmetro

• id(series string) Parâmetro obrigatório ◦ Identificação de pedido ◦ Localização do identificador para cancelar um pedido ◦
• when(series bool) opcional. Anula uma ordem de acordo com a ID. Se for “true”, a ordem será cancelada. O valor padrão é “true”.

strategy.cancel_all

Esta é uma função de cancelamento/desativação de todas as ordens de lista pré-estabelecidas, geradas pelas funções: strategy.order, strategy.entry e strategy.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

parâmetro

• when(series bool) opcional ≠ cancelar todas as condições das ordens ≠ cancelar todas as ordens ativas se a condição for verdadeira ≠ o valor padrão é true

strategy.order

Esta é a ordem da ordem seguinte. Se uma ordem com o mesmo ID já estiver pendurada, a ordem pode ser modificada. Se não houver uma ordem com o ID especificado, uma nova ordem será emitida. Para cancelar a ordem, deve-se usar a ordem strategy.cancel ou strategy.cancel_all. Em comparação com a função strategy.entry, a função strategy.order não é afetada pela forma de pirâmide. Se os parâmetros da barra de restrição e da barra de suspensão são ambos NaN, o tipo de ordem é uma 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

parâmetro

• id(series string) Parâmetros necessários 。 Identificador de pedido 。 Pode cancelar ou modificar o pedido por referência ao seu identificador 。
• direction(strategy_direction) Um parâmetro necessário. Direção da ordem: ‘strategy.long’ para comprar, ‘strategy.short’ para vender ‬
• qty(series int/float) Parâmetros selecionáveis. Contratos/número de ações/horas/número de unidades negociadas. O valor predefinido é ‘NaN’
• limit(series int/float) Parâmetros selecionáveis. Preço limite do pedido. Se especificado, o tipo de pedido é “limit” ou “stop-limit”. Outros tipos de pedido são “NaN”.
• stop(series int/float) Parâmetros opcionais ◦ Preço de stop-loss ◦ Tipo de ordem “stop” ou “stop-limit” se especificado ◦ Outros tipos de ordem “NaN” ◦
• oca_name(series string) Parâmetros opcionais ◦ O pedido pertence ao nome do grupo OCA ◦ Se o pedido não pertence a nenhum grupo OCA, deve haver um espaço ◦Nota: O FMZ não suporta este parâmetro.
• oca_type(input string) opcional. O tipo de grupo de ordens OCA. Os valores permitidos são: strategy.oca.none - o pedido não deve pertencer a nenhum grupo de OCA específico; strategy.oca.cancel - o pedido deve pertencer ao grupo de OCA, uma vez que o pedido é fechado, todos os outros pedidos do mesmo grupo serão cancelados; strategy.oca.reduce - o pedido deve pertencer ao grupo de OCA, se X número de contratos de pedidos foi colocado, o número de outros contratos de pedidos do mesmo grupo de OCA é reduzido por X.Nota: O FMZ não suporta este parâmetro.
• comment(series string) Parâmetros selecionáveis。 Outras instruções da encomenda。
• when(series bool) um parâmetro selecionável. A condição da ordem. Se for “true”, a ordem é colocada. Se for “false”, nada acontece.
• alert_message(series string) Um parâmetro opcional quando o símbolo {{strategy.order.alert_message}} é usado no campo de mensagens de alerta da caixa de diálogo de criação de alerta.

strategy.opentrades.entry_bar_index

Bar_index que retorna a entrada de uma posição não liquidada.

strategy.opentrades.entry_bar_index(trade_num)

Esperar 10 K e fechar 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")

parâmetro

• trade_num(series int) Número de transação para transações sem equilíbrio. O número da primeira transação é zero.

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

strategy.opentrades.entry_id

ID de retorno de entrada em transações não liquidadas.

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

Devolver valores ID de retorno de entrada em transações não liquidadas.

parâmetro

• trade_num(series int) Número de transação para transações sem equilíbrio. O número da primeira transação é zero.

Nota: Se trade_num não estiver no intervalo, a função retorna na:0 para strategy.opentrades-1。

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

strategy.opentrades.entry_price

Preço de entrada de retorno de uma transação não liquidada.

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 não liquidada

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

parâmetro

• trade_num(series int) Número de transação para transações sem equilíbrio. O número da primeira transação é zero.

Veja também strategy.closedtrades.exit_price

strategy.opentrades.entry_time

Regresso ao horário UNIX de entrada em negociação de posição não equilibrada.

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

parâmetro

• trade_num(series int) Número de transação para transações sem equilíbrio. O número da primeira transação é zero.

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

strategy.opentrades.profit

Perda de retorno de transações não liquidadas. A perda é representada como negativa.

strategy.opentrades.profit(trade_num)

Retorno do lucro da última posiçã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")

Calculando o lucro de todas as transações não liquidadas

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

parâmetro

• trade_num(series int) Número de transação para transações sem equilíbrio. O número da primeira transação é zero.

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

strategy.opentrades.size

Retorna a direção de negociação e o número de contratos em negociação de posição não liquidada. Se o valor for > 0, a posição de mercado é a posição de mais de um. Se o valor for < 0, a posição de mercado é a posição de cabeça vazia.

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

Calculação da percentagem de lucro médio de transações não liquidadas

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)

parâmetro

• trade_num(series int) Número de transação para transações sem equilíbrio. O número da primeira transação é zero.

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

strategy.closedtrades.entry_bar_index

Retorna a entrada bar_index que foi liquidada.

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

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

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

strategy.closedtrades.exit_price

Retornar ao preço de saída de uma transação liquidada.

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 de lucro médio de todas as transações liquidadas

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)

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

Veja também strategy.closedtrades.entry_price

strategy.closedtrades.exit_bar_index

Retorna a bar_index que foi excluída da transação.

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

Calcule 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())

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

Veja também bar_index

strategy.closedtrades.entry_id

A entrada de um retorno para uma transação em equilíbrio.

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

Devolver valores A entrada de um retorno para uma transação em equilíbrio.

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

Nota: Se trade_num não estiver no intervalo, a função retorna na:0 para strategy.closedtrades-1。

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

strategy.closedtrades.entry_price

O preço de entrada de um retorno de uma transação equilibrada.

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 de lucro médio de todas as transações liquidadas

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)

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

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

strategy.closedtrades.entry_time

Retornar ao horário de entrada do UNIX em que a transação foi liquidada.

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

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

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

strategy.closedtrades.profit

Perda de retorno de transações liquidadas. Perda expressa em negativo.

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

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

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

strategy.closedtrades.size

Retorna a direção de negociação e o número de contratos em negociações em posição equilibrada. Se o valor for > 0, a posição de mercado é a posição de mercado. Se o valor for < 0, a posição de mercado é a posição de mercado.

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

Calculação da percentagem de lucro médio de uma transação em posição de equilíbrio

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)

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

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

strategy.closedtrades.exit_time

Retornar a hora do UNIX de saída de uma transação equilibrada.

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

X segundos para reabrir transações em equilibrado

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)

parâmetro

• trade_num(series int) Número de transação que foi liquidado. O número da primeira transação é zero.

Veja também strategy.closedtrades.entry_time

strategy.risk.allow_entry_in

Esta função pode ser usada para especificar em que direção do mercado a estratégia. entrada é permitida.

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)

parâmetro

• value(simple string) Direção permitida. Valores possíveis:strategy.direction.all、strategy.direction.long、strategy.direction.short

strategy.risk.max_position_size

O objetivo desta regra é determinar o valor máximo de uma posição de mercado. A regra afeta as seguintes funções:strategy.entryO número de entradas de caixa pode ser reduzido (se necessário) para o número de contratos / ações / mãos / unidades, de modo que o valor total da posição não exceda o valor indicado em ‘strategy.risk.max_position_size’. Se a quantidade mínima 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

parâmetro

• contracts(simple int/float) Parâmetros necessários. Número máximo de contratos/ações/manos/unidades da posição.

math

math.abs

Se…number >= 0，numberO valor absoluto é numberCaso contrário,number。

math.abs(number) 

Devolver valores numberValor absoluto de ≠

math.acos

A função acos retorna a inversão de um número ((expresso em arco), como cos ((acos ((y)) = y dentro de y.[-1, 1]。

math.acos(angle)

Devolver valores Reversão de resonancia. Se y for fora do alcance[-1,1], o ângulo de retorno está em[0,Pi] ou na.

math.random

Retorna um valor pseudo-aleatório. Esta função irá gerar uma sequência de valores diferente para cada script executado. Usar o mesmo valor para o parâmetro seed selecionado irá gerar uma sequência repetível.

math.random(min, max, seed)

Devolver valores Um valor aleatório.

parâmetro

• min(series int/float) O limite inferior do intervalo de valores aleatórios. O valor não está incluído no intervalo. O valor padrão é 0
• max(series int/float) Limite superior de um intervalo de valores aleatórios. O valor não está incluído no intervalo. O valor padrão é 1
• seed(input int) opcional. Quando o mesmo seed é usado, é permitido que a função seja chamada de forma contínua para produzir um conjunto de valores repetíveis.

math.asin

A função asin retorna a antítese de um número ((expresso em arco), a antítese ((asin ((y)) = y dentro de y[-1, 1]。

math.asin(angle) 

Devolver valores O valor de antossíntese.[-1,1], o ângulo de retorno está em[-Pi / 2, Pi / 2] ou na escala de na.

math.atan

A função atan retorna o interseção inversa do número ((expresso em arco), tan (((atan ((y)) = qualquer y ∈ y.

math.atan(angle) 

Devolver valores Cancelamento inverso; ângulo de retorno em[-Pi / 2, Pi / 2] no âmbito de .

math.ceil

A função inteira ascendente retorna o menor número inteiro maior que ou igual ao valor de seu argumento (o mais próximo de infinito negativo).

math.ceil(number)

Devolver valores Menor ou igual ao menor inteiro de um dado número

Veja também math.floor math.round

math.cos

O ângulo de retorno da função cos é o ângulo de um triângulo.

math.cos(angle) 

Devolver valores A corda triangular do canto.

parâmetro

• angle(series int/float) ângulo, em arco

math.exp

numberA função exp de e é de e.numberExtremo, onde e é o número de Euler.

math.exp(number) 

Devolver valores Um valor de e, que é .numberO que é isso?

Veja também math.pow

math.floor

math.floor(number) 

Devolver valores Menor ou igual ao maior inteiro de um dado número.

Veja também math.ceil math.round

math.log

Qualquer um.numberO natural de > 0 é o único y, de modo que e^y = number。

math.log(number)

Devolver valores numberArgonímetros naturais de .

Veja também math.log10

math.log10

numberO padrão comum (ou baseado em 10) é que você tem que elevar 10 para obter o número de pi.number。10^y = number。

math.log10(number)

Devolver valores numberA base de 10 para o logarítmo ≠ 2.

Veja também math.log

math.pow

Funções de matriz

math.pow(base, exponent)

Exemplo

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

Devolver valores baseAumentar paraexponentSebaseÉ uma série, calculada por elementos.

parâmetro

• base(series int/float) Especifica a base a ser usada.
• exponent(series int/float) Indicar o índice.

Veja também math.sqrt math.exp

math.sign

Se o número de algarismos for zero, o símbolo (signum) do número de algarismos é zero, se o número de algarismos for maior que 0, é 1,0, se o número de algarismos for menor que 0, é -1,0.

math.sign(number)

Devolver valores Logotipo do parâmetro

math.sin

A função cosine retorna a cosine de um ângulo.

math.sin(angle)

Devolver valores Sinônimos de triângulo angular.

parâmetro

• angle(series int/float) ângulo, em arco

math.sqrt

Qualquer um.numberA raiz quadrada de >=0 é a única vez em que y >=0 faz y^2 = number。

math.sqrt(number)

Devolver valores numberA raiz quadrada de .

Veja também math.pow

math.tan

A função tan retorna o ângulo do triângulo perpendicular.

math.tan(angle)

Devolver valores O triângulo dos cantos é perpendicular.

parâmetro

• angle(series int/float) ângulo, em arco

math.round

Regressar.numberSe for usado o valor de um número inteiro, o quadrado é inserido no número inteiro mais próximo e inteiro para cima. Se for usado o valor de um número inteiro, o quadrado é inserido no número inteiro mais próximo e inteiro para cima.precisionO parâmetro retorna um valor de ponto flutuante de um quadrado de cinco dígitos menores.

math.round(number) 

math.round(number, precision) 

Devolver valores numberO valor de um quadrado de cinco para o número inteiro mais próximo, ou de acordo com a precisão.

parâmetro

• number(series int/float) Quadrar o valor de inserção de cinco pontos.
• precision(series int) Parâmetros selecionáveis。numberSerão quadrados os dígitos menores. Quando não for fornecido o parâmetro, será quadrado o número inteiro mais próximo.

Nota: Observe que, para um valor ‘na’, a função retorna ‘na’ .

Veja também math.ceil math.floor

math.max

Retorna o maior de vários valores.

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

Exemplo

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

Devolver valores O maior de vários valores dados.

Veja também math.min

math.min

Retorna o menor de vários valores.

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

Exemplo

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

Devolver valores O menor de vários valores dados.

Veja também math.max

math.avg

Calcule a média de todas as séries ((elementos correspondentes) }}.

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

Devolver valores Média

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

math.round_to_mintick

Retorna o valor do mintick que foi circunscrito à mercadoria, ou seja, pode ser dividido pelo valor mais próximo de siminfo.mintick, sem nenhum resto, e arredondado para cima.

math.round_to_mintick(number) 

Devolver valores number“Quatro rodadas e cinco entradas para a precisão do tick”.

parâmetro

• number(series int/float) Quadrar o valor de inserção de cinco pontos.

Veja também math.ceil math.floor

math.sum

A função sum retorna o conjunto deslizante do último valor de y em x.

math.sum(source, length)

Devolver valores lengthA linha K retornasourceResumo

parâmetro

• source(series int/float) Valor da série a ser executado。
• length(series int) K número de linhas (longitude).

Veja também ta.cum for

math.todegrees

De um ângulo em unidades de arco, retorne o ângulo de equivalência aproximada em unidades de medida.

math.todegrees(radians) 

Devolver valores O valor de ângulo é medido em unidades.

parâmetro

• radians(series int/float) ângulo em arco.

math.toradians

De ângulo em unidades de medida, retorne o ângulo de aproximação equivalente em unidades de arco.

math.toradians(degrees) 

Devolver valores O valor do ângulo em unidades de arco.

parâmetro

• degrees(series int/float) ângulo medido em unidades.

others

fixnan

Substitua o valor NaN pelo valor não-NaN anterior para a série dada.

fixnan(source) 

Devolver valores Uma série sem intervalos.

parâmetro

• source (series int/float/bool/color)

Veja também na nz

nz

Substitua o valor de NaN por zero (ou um número especificado) na série.

nz(source, replacement) 

nz(source)

Exemplo

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

Devolver valores sourceO valor, se não fornaSesourceO valor denaEntão, se você usar 1, ele vai voltar para 0 e se você usar 1, ele vai voltar para 1.replacementParâmetros

parâmetro

• source(series int/float/bool/color) Valor da série a ser executada。
• replacement(series int/float/bool/color) substitui o valor de todos os thresholds da série de thresholds da fonte de thresholds.

Veja também na fixnan

na

NaN é o valor de teste.

na(x)

Devolver valores Se x não for um número válido, então é verdadeiro (x é NaN) ou é falso (false).

Veja também fixnan nz

int

Converter na ou interromper o valor do float para int ≠

int(x) 

Devolver valores Converte o valor do parâmetro para int.

Veja também float bool color string

float

Configure na como flutuante.

float(x) 

Devolver valores Converte para o valor do parâmetro float.

Veja também int bool color string

alert

Alerta de eventos quando chamada durante a linha K em tempo real, e anteriormente criou alertas baseados em eventos da função de alerta como indicador ou estratégia por meio da caixa de diálogo de criação de alertas.

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)

parâmetro

• message(series string) Mensagem enviada quando o alerta é acionado.
• freq(input string) Frequência de ação。 os valores possíveis são: alert.freq_all (todas as funções chamam um alerta de ação), alert.freq_once_per_bar (a primeira função na linha K chama um alerta de ação), alert.freq_once_per_bar_close (a ação é acionada apenas quando ocorre uma ação na última versão do script da linha K em tempo real, e o alerta é acionado quando ela é desligada).

Nota: O Centro de Ajuda explica como criar este tipo de alerta. Ao contrário da alertcondition, a chamada de alert não serve como um mapa adicional. As chamadas de funções podem ser globais ou locais. A chamada de função não mostra nada no gráfico. O parâmetro freq afeta apenas a frequência de acionamento em que esta função é chamada.

Veja também alertcondition

alertcondition

Criação de condições de alerta, disponível na caixa de diálogo Criação de alertas. Observe que a alertcondition não cria alertas, mas apenas fornece mais opções na caixa de diálogo Criação de alertas. Além disso, o efeito alertcondition não é visível no gráfico.

alertcondition(condition, title, message)

Exemplo

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

parâmetro

• condition(series bool) A série de valores de bool para o alerta. True significa que o alerta foi acionado e false significa que não foi acionado.
• title(const string) Título da condição de alerta. Parâmetros opcionais.
• message(const string) Display de mensagem quando o alerta é acionado.

Nota: Observe que, em Pine v4, a chamada de condição de alerta gera um gráfico adicional. Todas essas chamadas são levadas em consideração quando calculamos o número de séries de saída de cada script.

Veja também alert

indicator

Para a compatibilidade.Trading ViewO código de estratégia não precisa ser chamado.

Veja também strategy

time

A função time retorna o tempo UNIX da linha K atual do intervalo de tempo especificado e do tempo de transação, retornando NaN se o ponto de tempo não estiver no tempo de transação. Nota: FMZ não é suportadosessionParâmetros

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, você pode especificar não apenas a hora e o minuto, mas também o dia da semana. Se não for especificada uma data, considere que o horário de negociação foi definido como sendo de domingo (1) a sábado (7), ou seja, R\( 1100-2000 é o mesmo que R\) 1100-1200:1234567. Você pode alterá-lo especificando a data. Por exemplo, para mercadorias que são negociadas 7 dias por semana e 24 horas por dia, o seguinte script não será colorido para os sábados e domingos:

Exemplo

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

Um.sessionOs parâmetros podem conter vários períodos de negociação diferentes, separados por vírgulas. Por exemplo, o seguinte script irá destacar o gráfico de linha K de 10:00 a 11:00 e de 14:00 a 15:00 (apenas dias úteis):

Exemplo

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

Devolver valores Tempo Unix.

parâmetro

• timeframe(simple string) Período de tempo。 A string em branco é interpretada como o período de tempo atual do gráfico。
• session(simple string) Especificação de tempo de transação。 Parâmetros opcionais, usando o tempo de transação de mercadorias de forma padrão。 Strings vazias são interpretadas como o tempo de transação de mercadorias。 FMZ não é suportado。
• timezone (simple string) sessionO parâmetro fuso horário ◦ só pode ser usado quando o fuso horário de uma sessão é especificado ◦ é opcional ◦ o valor padrão é syminfo.timezone ◦ pode ser especificado com a representação GMT ◦ (por exemplo, o fuso horário GMT-5) ou o nome do banco de dados de fuso horário da IANA ◦ (por exemplo, o fuso horário America/New_York) ◦

Nota: O tempo UNIX é o número de milissegundos que se passou desde 1 de janeiro de 1970 UTC 00:00:00 .

year

year(time)

year(time, timezone)

Devolver valores O ano em que o tempo do UNIX é fornecido (zona horária de troca) .

parâmetro

• time(series int) Tempo de Unix em milissegundos.
• timezone(series string) Parâmetros opcionais ◦ fuso horário ◦

Nota: O tempo UNIX é o número de milissegundos desde 1 de janeiro de 1970 UTC 00:00:00. Por padrão, o fuso horário é siminfo.timezone. Você pode usar o timestamp para verificar os possíveis valores. Observe que esta função retorna o ano de acordo com o horário de abertura da linha K. Para o horário de negociação durante a noite (por exemplo, o horário de negociação do EURUSD na segunda-feira começa às 17h00 UTC-4 no domingo), o valor pode ser menor que o ano do dia de negociação.

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

month

month(time)

month(time, timezone)

Devolver valores Os meses que fornecem o tempo do UNIX ((zona horária de troca))

parâmetro

• time(series int) Tempo de Unix em milissegundos.
• timezone(series string) Parâmetros opcionais ◦ fuso horário ◦

Nota: O tempo UNIX é o número de milissegundos desde 1 de janeiro de 1970 UTC 00:00:00. Por padrão, o fuso horário é siminfo.timezone. Você pode usar o timestamp para verificar os possíveis valores. Observe que esta função retorna o mês de acordo com o horário de abertura da linha K. Para o período de negociação noturno (por exemplo, o período de negociação do EURUSD na segunda-feira começa às 17:00 UTC-4 no domingo), o valor pode ser inferior a 1 do mês do dia de negociação.

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

hour

hour(time)

hour(time, timezone)

Devolver valores Hora de fornecimento do tempo UNIX ((fuso horário de troca) }}.

parâmetro

• time(series int) Tempo de Unix em milissegundos.
• timezone(series string) Parâmetros opcionais ◦ fuso horário ◦

Nota: O tempo UNIX é o número de milissegundos desde 1 de janeiro de 1970 UTC 00:00:00. Por padrão, o fuso horário é siminfo.timezone. Você pode usar o timestamp para verificar os possíveis valores.

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

minute

minute(time)

minute(time, timezone)

Devolver valores Minutos fornecidos no tempo UNIX ((zona horária de troca) }}.

parâmetro

• time(series int) Tempo de Unix em milissegundos.
• timezone(series string) Parâmetros opcionais ◦ fuso horário ◦

Nota: O tempo UNIX é o número de milissegundos desde 1 de janeiro de 1970 UTC 00:00:00. Por padrão, o fuso horário é siminfo.timezone. Você pode usar o timestamp para verificar os possíveis valores.

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

second

second(time)

second(time, timezone)

Devolver valores Aprovando o número de segundos do tempo do UNIX ((intercâmbio de fusos horários) }}.

parâmetro

• time(series int) Tempo de Unix em milissegundos.
• timezone(series string) Parâmetros opcionais ◦ fuso horário ◦

Nota: O tempo UNIX é o número de milissegundos desde 1 de janeiro de 1970 UTC 00:00:00. Por padrão, o fuso horário é siminfo.timezone. Você pode usar o timestamp para verificar os possíveis valores.

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

weekofyear

weekofyear(time)

weekofyear(time, timezone)

Devolver valores Aprovando o ciclo de tempo do UNIX ((intercâmbio de fusos horários) }}.

parâmetro

• time(series int) Tempo de Unix em milissegundos.
• timezone(series string) Parâmetros opcionais ◦ fuso horário ◦

Nota: O tempo UNIX é o número de milissegundos desde 1 de janeiro de 1970 UTC 00:00:00. Por padrão, o fuso horário é siminfo.timezone. Você pode usar o timestamp para verificar os possíveis valores. Observe que a função retorna a semana de acordo com o horário de abertura da linha K. Para o horário de negociação durante a noite (por exemplo, EURUSD, cujo horário de negociação de segunda-feira começa às 17:00 de domingo), o valor pode ser menor do que o horário de negociação do dia.

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

dayofweek

dayofweek(time)

dayofweek(time, timezone)

Devolver valores A data da semana que fornece o tempo do UNIX ((zona horária de troca) }}.

parâmetro

• time(series int) Tempo de Unix em milissegundos.
• timezone(series string) Parâmetros opcionais ◦ fuso horário ◦

Nota: Observe que esta função retorna a data de acordo com o horário de abertura da linha K. Para o horário de negociação da noite (por exemplo, o horário de negociação do EURUSD na segunda-feira começa às 17:00 de domingo), o valor pode ser menor do que a data do dia de negociação. O tempo UNIX é o número de milissegundos desde 1 de janeiro de 1970 UTC 00:00:00. Por padrão, o fuso horário é siminfo.timezone. Você pode usar o timestamp para verificar os possíveis valores.

Veja também time dayofmonth

dayofmonth

dayofmonth(time)

dayofmonth(time, timezone)

Devolver valores A data do mês que fornece o tempo do UNIX ((zona horária de intercâmbio) }}.

parâmetro

• time(series int) Tempo de Unix em milissegundos.
• timezone(series string) Parâmetros opcionais ◦ fuso horário ◦

Nota: O tempo UNIX é o número de milissegundos desde 1 de janeiro de 1970 UTC 00:00:00. Por padrão, o fuso horário é siminfo.timezone. Você pode usar o timestamp para verificar os possíveis valores. Observe que esta função retorna a data de acordo com o horário de abertura da linha K. Para o horário de negociação durante a noite (por exemplo, o horário de negociação do EURUSD na segunda-feira começa às 17:00 UTC-4 no domingo), este valor pode ser menor do que a data do dia de negociação.

Veja também time dayofweek

timestamp

A função de barra de tempo retorna a data e hora especificadas para o tempo do UNIX.

timestamp(dateString)

”` timestamp(year, month, day, hour, minute,