FMZ PINE Script documentação

Retorno de valorO número médio dos elementos da matriz.

Parâmetros

• id(int[]/float[]) Objeto de matriz.

Até logo. array.avg array.variance array.min

array.mode

Esta função retorna o padrão dos elementos da matriz. Retorna o valor mínimo se houver vários valores com a mesma frequência.

array.mode(id)

Exemplos

// array.mode example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.mode(a))

Retorno de valorPadrão dos elementos da matriz.

Parâmetros

• id(int[]/float[]) Objeto de matriz.

Até logo. array.new_float array.avg array.variance array.min

array.percentil_linear_interpolação

Retorna uma percentagem específica (percentagem) do valor da matriz menor ou igual a seu valor, usando inserções lineares.

array.percentile_linear_interpolation(id, percentage) 

Parâmetros

• id(int[]/float[]) Objeto de matriz.
• percentage(series int/float) deve ser igual ou menor que a percentagem do valor do valor devolvido.

NotasEm estatística, a percentagem é a percentagem de itens de classificação que aparecem em uma determinada pontuação ou abaixo de uma determinada pontuação. Esta medida mostra a percentagem de frações na distribuição de frequência padrão abaixo da pontuação percentual que você está medindo.

Até logo. array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.percentile_nearest_rank

Retorna o valor de uma matriz de porcentagem especificada que é menor ou igual a ela usando o método de classificação mais recente.

array.percentile_nearest_rank(id, percentage) 

Parâmetros

• id(int[]/float[]) Objeto de matriz.
• percentage(series int/float) deve ser igual ou menor que a percentagem do valor do valor devolvido.

NotasEm estatística, uma percentagem é a percentagem de itens de classificação que aparecem em um determinado escalão ou abaixo de um determinado escalão. Esta medida mostra o percentual de frações na distribuição de frequência padrão abaixo do escalão percentual que você está medindo.

Até logo. array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.percentrank

Retorna o ranking percentual do valor médio da matriz.

array.percentrank(id, index) 

Parâmetros

• id(int[]/float[]) Objeto de matriz.
• index(series int) calcula o valor de sua classificação porcentorial.

NotasA classificação porcentagem é a porcentagem de quantos elementos da matriz são menores ou iguais ao valor de referência.

Até logo. array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.range

A função retorna a diferença entre o valor mínimo e o valor máximo de um conjunto dado.

array.range(id) 

Exemplos

// array.range example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.range(a))

Retorno de valorA diferença entre o valor mínimo e o valor máximo de um conjunto.

Parâmetros

• id(int[]/float[]) Objeto de matriz.

Até logo. array.new_float array.min array.max array.sum

array.remove

A função altera o conteúdo da matriz removendo elementos com índices especificados.

array.remove(id, index)

Exemplos

// array.remove example
a = array.new_float(5,high)
removedEl = array.remove(a, 0)
plot(array.size(a))
plot(removedEl)

Retorno de valorO valor do elemento que foi removido.

Parâmetros

• id(any array type) Objeto de matriz.
• index(series int) Índice do elemento a ser removido.

Até logo. array.new_float array.set array.push array.insert array.pop array.shift

array.reverse

Esta função inverte a matriz. O primeiro elemento da matriz se torna o último e o último elemento da matriz se torna o primeiro.

array.reverse(id)

Exemplos

// array.reverse example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.get(a, 0))
array.reverse(a)
plot(array.get(a, 0))

Parâmetros

• id(any array type) Objeto de matriz.

Até logo. array.new_float array.sort array.push array.set array.avg

array.from

A função usa um número variável de parâmetros de um dos seguintes tipos: int, float, boolean, string, line, color, linefill, e retorna uma matriz do tipo correspondente.

array.from(arg0, arg1, ...)

Exemplos

// array.from_example
arr = array.from("Hello", "World!") // arr (string[]) will contain 2 elements: {Hello}, {World!}.
plot(close)

Retorno de valorO valor dos elementos da matriz.

Parâmetros

• arg0, arg1, ...(series int/float/bool/color/string/line/linefill) Parâmetros de conjunto.

array.new

A função cria um novo<type>Objetos de matrizes de elementos.

array.new(size, initial_value)

Exemplos

// array.new<string> example
a = array.new<string>(1, "Hello, World!")
runtime.log(array.get(a, 0))

Exemplos

// array.new<color> example
a = array.new<color>()
array.push(a, color.red)
array.push(a, color.green)
plot(close, color = array.get(a, close > open ? 1 : 0))

Exemplos

// array.new<float> example
length = 5
var a = array.new<float>(length, close)
if array.size(a) == length
  array.remove(a, 0)
  array.push(a, close)
plot(array.sum(a) / length, "SMA")

Exemplos

// array.new<line> example
// draw last 15 lines
var a = array.new<line>()
array.push(a, line.new(bar_index - 1, close[1], bar_index, close))
if array.size(a) > 15
    ln = array.shift(a)
    line.delete(ln)

Retorno de valorA função ID de um objeto de matriz pode ser usada em conjunto com outras matrizes.

Parâmetros

• sizeO tamanho inicial da sequência (series int) é "0".
• initial_value(series ) O valor inicial de todos os elementos da série↑ opcional↑ o valor padrão é na↑

NotasO índice da matriz começa em 0. Se você quiser inicializar uma matriz e especificar todos os seus elementos ao mesmo tempo, use a função array.from.

Até logo. array.from array.push array.get array.size array.remove array.shift array.sum

array.new_bool

Esta função cria um novo objeto de matriz composto por elementos do tipo boolean.

array.new_bool(size, initial_value)

Exemplos

// array.new_bool example
length = 5
a = array.new_bool(length, close > open)
plot(array.get(a, 0) ? close : open)

Retorno de valorA função ID de um objeto de matriz pode ser usada em conjunto com outras matrizes.

Parâmetros

• sizeO tamanho inicial da sequência (series int) é "0".
• initial_value(series bool) O valor inicial de todos os elementos da série↑ opcional↑ o valor padrão é na↑

NotasO índice da matriz começa em 0.

Até logo. array.new_float array.get array.slice array.sort

array.new_float

Esta função cria um novo objeto de matriz de elementos flutuantes.

array.new_float(size, initial_value)

Exemplos

// array.new_float example
length = 5
a = array.new_float(length, close)
plot(array.sum(a) / length)

Retorno de valorA função ID de um objeto de matriz pode ser usada em conjunto com outras matrizes.

Parâmetros

• sizeO tamanho inicial da sequência (series int) é "0".
• initial_value(series int/float) O valor inicial de todos os elementos da série. Opcional.

NotasO índice da matriz começa em 0.

Até logo. array.new_bool array.get array.slice array.sort

array.new_int

A função cria um novo objeto de matriz composto por elementos do tipo int.

array.new_int(size, initial_value)

Exemplos

// array.new_int example
length = 5
a = array.new_int(length, int(close))
plot(array.sum(a) / length)

Retorno de valorA função ID de um objeto de matriz pode ser usada em conjunto com outras matrizes.

Parâmetros

• sizeO tamanho inicial da sequência (series int) é "0".
• initial_value(series int) O valor inicial de todos os elementos da série↑ opcional↑ o valor padrão é na↑

NotasO índice da matriz começa em 0.

Até logo. array.new_float array.get array.slice array.sort

array.new_string

A função cria um novo objeto de matriz com um elemento de tipo de string.

array.new_string(size, initial_value)

Exemplos

// array.new_string example
length = 5
a = array.new_string(length, "text")
runtime.log(array.get(a, 0))

Retorno de valorA função ID de um objeto de matriz pode ser usada em conjunto com outras matrizes.

Parâmetros

• sizeO tamanho inicial da sequência (series int) é "0".
• initial_value(series string) O valor inicial de todos os elementos da série↑ opcional↑ o valor padrão é na↑

NotasO índice da matriz começa em 0.

Até logo. array.new_float array.get array.slice

array.get

A função retorna o valor do elemento indicado no endereço do índice.

array.get(id, index)

Exemplos

// array.get example
a = array.new_float(0)
for i = 0 to 9
  array.push(a, close[i] - open[i])
plot(array.get(a, 9))

Retorno de valorO valor dos elementos da matriz.

Parâmetros

• id(any array type) Objeto de matriz.
• index(series int) é o índice de um elemento para retornar seu valor.

Até logo. array.new_float array.set array.slice array.sort

array.push

A função adiciona um valor à matriz.

array.push(id, value)

Exemplos

// array.push example
a = array.new_float(5, 0)
array.push(a, open)
plot(array.get(a, 5))

Parâmetros

• id(any array type) Objeto de matriz.
• value (series <type of the array's elements>) é adicionado ao valor do elemento no final da matriz.

Até logo. array.new_float array.set array.insert array.remove array.pop array.unshift

array.set

A função define o valor do elemento como o índice indicado.

array.set(id, index, value) 

Exemplos

// array.set example
a = array.new_float(10)
for i = 0 to 9
  array.set(a, i, close[i])
plot(array.sum(a) / 10)

Parâmetros

• id(any array type) Objeto de matriz.
• index(series int) para alterar o índice do elemento.
• value (series <type of the array's elements>) O novo valor a ser definido.

Até logo. array.new_float array.get array.slice

array.sum

A função retorna a soma dos elementos da matriz.

array.sum(id) 

Exemplos

// array.sum example
a = array.new_float(0)
for i = 0 to 9
  array.push(a, close[i])
plot(array.sum(a))

Retorno de valorA soma dos elementos da matriz.

Parâmetros

• id(int[]/float[]) Objeto de matriz.

Até logo. array.new_float array.max array.min

array.avg

A função retorna o valor médio dos elementos da matriz.

array.avg(id)

Exemplos

// array.avg example
a = array.new_float(0)
for i = 0 to 9
  array.push(a, close[i])
plot(array.avg(a))

Retorno de valorO valor médio dos elementos da matriz.

Parâmetros

• id(int[]/float[]) Objeto de matriz.

Até logo. array.new_float array.max array.min array.stdev

array.indexof

Esta função retorna o índice em que o valor apareceu pela primeira vez. Se o valor não for encontrado, retorna -1.

array.indexof(id, value)

Exemplos

// array.indexof example
a = array.new_float(5,high)
index = array.indexof(a, high)
plot(index)

Retorno de valorO índice do elemento.

Parâmetros

• id(any array type) Objeto de matriz.
• value (series <type of the array's elements>) Valor a ser pesquisado em uma matriz.

Até logo. array.lastindexof array.get array.lastindexof array.remove array.insert

Estratégia

EmstrategyEm funções embutidas relacionadas, o número de pontos de stop loss e stop loss é definido como o múltiplo de um salto de preço; por exemplo:strategy.exitFunçõesprofit、lossParâmetros pontuados para parar, parar, parâmetrosprofitConfigurar para 10, ou seja, um salto de preço multiplicado por 10 como diferença de preço de parada, um salto de preço é a variável embutidasyminfo.mintick。

Estratégia

A função define várias propriedades de política. Atenção, a transmissão é apenas de apoio.title，shorttitle，overlay，pyramiding，default_qty_type，default_qty_valueParâmetros, outros parâmetros podem ser definidos através dos parâmetros da interface da política da linguagem PINE.

strategy(title, shorttitle, overlay, format, precision, scale, pyramiding, calc_on_order_fills, calc_on_every_tick, max_bars_back, backtest_fill_limits_assumption, default_qty_type, default_qty_value, initial_capital, currency, slippage, commission_type, commission_value, process_orders_on_close, close_entries_rule, margin_long, margin_short, explicit_plot_zorder, max_lines_count, max_labels_count, max_boxes_count, risk_free_rate) 

Exemplos

strategy("Strategy", overlay = true)

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

Parâmetros

• title(const string) Trata-se do título do indicador visto no plugin indicador/estratégia. Parâmetros são necessários.
• shorttitle(const string) O indicador que você vê no exemplo do gráfico será o título curto. O parâmetro é opcional.
• overlay(const bool) Se for true, o indicador será adicionado como uma camada de sobreposição da série principal. Se for false - ele será adicionado a uma janela de gráfico separada.
• format(const string) Os tipos possíveis de valores de indicadores formatados no eixo de preços são: format.inherit、format.price、format.volume、format.inherit por defeito。
• precision(const int) O número de dígitos após o ponto flutuante do valor do indicador no eixo de preços. Deve ser um inteiro não negativo e não maior que 16. Se omitido, o formato da série pai é usado. Se o formato for format.inherit e esse parâmetro for definido, o formato se torna format.price.
• scale(scale_type) O indicador deve seguir os coordenados de preço. Os valores possíveis são: scale.right, scale.left, scale.none. O valor scale.none só pode ser usado em conjunto com a configuração de overlay = true.
• pyramiding(const int) A quantidade máxima permitida na mesma direção. Se esse valor for 0, apenas uma ordem de entrada pode ser aberta na mesma direção e qualquer outra ordem de entrada será rejeitada.
• calc_on_order_fills(const bool) extra computação de ordens intrabar. Se o parâmetro for definido como true, a política recalcula (não somente ao fechar a linha k) uma vez que a linha K está cheia após a ordem.
• calc_on_every_tick(const bool) extra cálculo da política intrabar. Se o parâmetro for true, a política calculará cada ponto em tempo real, sem fechar a linha k. O parâmetro não afeta o cálculo da política de dados históricos.
• max_bars_back(const int) é o valor máximo de barra que pode ser usado para a política de referência histórica. Se o código do script referir os dados históricos de uma variável (se usar o operador de barra [] '), este parâmetro será aplicado a cada variável embutida ou variável do usuário no script. O tamanho da área de reserva variável no script do pin é geralmente detectado automaticamente. No entanto, em alguns casos, isso é impossível, e é por isso que o parâmetro permite que o usuário defina manualmente o valor abaixo.
• backtest_fill_limits_assumption(const int) A pressuposição de execução do limite de preço. O limite de preço só é negociado na barra interna quando o preço do mercado excede o número de ticks especificados no nível do limite de preço.
• default_qty_type(const string) é definido paraqtyO valor do parâmetro é o conteúdo expresso na função estrategy.entry ou estrategy.order. Os valores possíveis são: estrategy.fixed representa contrato/ações/número de mãos, estrategy.cash indica a quantidade de moeda, ou estrategy.percent_of_equity indica a percentagem de direitos disponíveis.
• default_qty_value(const int/float) O número de transações padrão das funções strategy.entry ou strategy.order, cuja unidade é determinada por um parâmetro usado em conjunto com o parâmetro default_qty_type, quando seus parâmetros qty não são definidos.
• currency(const string) A moeda de conta desta política. Opcional. O valor padrão é a moeda do produto no gráfico. Os valores possíveis são: currency.NONE, currency.USD, currency.EUR, currency.AUD, currency.GBP, currency.NZD, currency.CAD, currency.CHF, currency.HKD, currency.JPY, currency.NOK, currency.SEK, currency.SGD, currency.TRY, currency.ZAR, currency.BTC, currency.ETH, currency.MYR, currency.KRW.
• slippage(const int) com o tick como unidade de oferta, o slider é aumentado/subtraído do preço de transação do pedido de compra/venda ou do pedido de stop-loss. Se o mintick = 0.01 e o slider = 5, o slider total será 5 * 0.01 = 0.05.
• commission_type(const string) Tipos de comissões de cada ordem. Os valores permitidos são: strategy.commission.percent (percentagem do volume de dinheiro da ordem), strategy.commission.cash_per_contract (indicando o valor em moeda de conta por contrato), strategy.commission.cash_per_order (indicando o valor em moeda de conta por ordem).
• commission_value(const int/float) O valor da comissão da ordem. Dependendo do tipo escolhido (tipo de comissão) inclui uma percentagem ou um valor.
• process_orders_on_close(const bool) quando definido como um botão real, outras tentativas de gerar ordens de execução são feitas após o fechamento do gráfico e o cálculo da estratégia. Se os pedidos forem ordens de preço de mercado, o simulador de corretores executá-los-á antes da próxima abertura do gráfico. Se os pedidos forem preços limitados, os pedidos só serão executados quando as condições de preço forem atendidas.
• close_entries_rule(const string) Determina a ordem em que a ordem é fechada. O valor permitido é: FIFO ou ANY. FIFO significa que o primeiro negócio deve ser fechado quando vários negócios estão abertos. Esta regra se aplica a ações, futuros e FX (regra 2-43b da NFA).
• max_lines_count(const int) Mostra o número de gráficos de linhas recentes. O valor padrão é 50, o valor máximo permitido é 500.
• max_labels_count(const int) Mostra o número de imagens de etiquetas recentes. O valor padrão é 50, o valor máximo permitido é 500.
• max_boxes_count(const int) O número de desenhos da última caixa exibida. O valor padrão é 50, o valor máximo permitido é 500.
• margin_long(const int/float) A taxa de garantia é a percentagem do preço de compra de um título que deve ser coberto com dinheiro ou garantia. Deve ser não negativo. Opcional. O valor padrão é 100.
• margin_short(const int/float) A taxa de garantia é a percentagem do preço de compra de um título que deve ser coberto com dinheiro ou garantia. Deve ser não negativo. Opcional. O valor padrão é 100.
• explicit_plot_zorder(const bool) Especifica a ordem de representação de gráficos, preenchimentos e linhas horizontais de indicadores. Se for verdade, os gráficos são desenhados de acordo com a ordem em que aparecem no código do indicador, com cada gráfico mais novo sendo desenhado em cima do gráfico anterior. Isso é válido apenas para as funções plot * ((), fill ehline.
• initial_capital(const int/float) A quantidade de dinheiro inicialmente utilizada para negociações estratégicas é representada pela moeda definida na caixa de moeda de barras.
• risk_free_rate(const int/float) O retorno sem risco é a variação anual em percentagem do valor de um investimento com o menor risco ou zero, usado para calcular o rácio Sharpe e Sortino.

NotasCada script de estratégia deve ter uma chamada de estratégia. O código do PineScript com o parâmetro calc_on_every_tick = true pode fazer cálculos diferentes para registros históricos e dados em tempo real. Quando se usa um gráfico de tipo não padrão como base para a estratégia, é necessário saber que os resultados serão diferentes. Os pedidos serão executados no preço do gráfico (e.g. para Heikin Ashi, o preço de Heikin Ashi será usado como uma média, não como um verdadeiro preço de mercado). Portanto, é altamente recomendável que use o tipo de gráfico padrão em sua estratégia.

Até logo. indicator

strategy.entry

Este é um comando de entrada no mercado. Se uma ordem com o mesmo ID já está pendurada, você pode modificar a ordem. Se não tiver um ID especificado, uma nova ordem será emitida. Para cancelar a instrução de entrada, use o comando estrategy.cancel ou estrategy.cancel_all. Em comparação com a função estrategy.order, a função estrategy.entry é influenciada pela pirâmide e pode reverter corretamente a posição do mercado.

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

Exemplos

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

Parâmetros

• id(series string) Parâmetros necessários.
• direction(strategy_direction) Um parâmetro necessário. Direção de posicionamento do mercado:'strategy.long' para multi-cabeça,'strategy.short' para vazio.
• qty(series int/float) Parâmetros opcionais↑ contrato/número de ações/quantidade de mãos/quantidade de unidades negociadas↑ valor predefinido de NaN NaN↑
• limit(series int/float) Opções de parâmetros. O valor limite da ordem. Se for especificado, o tipo de ordem é "limit" ou "stop-limit"; outros tipos de ordem são "NaN".
• stop(series int/float) Opções de parâmetros. O preço de stop-loss da ordem. Se for especificado, o tipo de ordem é "stop" ou "stop-limit"; outros tipos de ordem são "NaN".
• oca_name(series string) Parâmetros opcionais. A ordem pertence ao nome do grupo OCA. Se a ordem não pertence a nenhum grupo OCA, deve haver um caracter em branco.Nota: FMZ não suporta este parâmetro.
• oca_type(input string) Parâmetros opcionais. Tipo de grupo de pedidos OCA. Valores permitidos: strategy.oca.none - os pedidos não devem pertencer a nenhum grupo de pedidos OCA específico; strategy.oca.cancel - os pedidos devem pertencer ao grupo de pedidos OCA e, uma vez que o pedido é transacionado, todos os outros pedidos do mesmo grupo serão cancelados; strategy.oca.reduce - os pedidos devem pertencer ao grupo de pedidos OCA, se X número de contratos de pedidos tiver sido colocado, o número de outros pedidos do mesmo grupo de pedidos OCA será reduzido X.Nota: FMZ não suporta este parâmetro.
• comment(series string) Parâmetros opcionais.
• when(series bool) Opções de parâmetros. Status 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 na barra de mensagens da barra de alertas da caixa de diálogo da barra de alertas.

strategy.close

Este é um comando para uma ordem de saída com um ID especificado. Se houver várias ordens de entrada com o mesmo ID, todas elas sairão ao mesmo tempo. Se a ordem não tiver o ID especificado no momento do início, a ordem não será executada.

strategy.close(id, when, comment, qty, qty_percent, alert_message) 

Exemplos

strategy("closeEntry Demo", overlay=false)
strategy.entry("buy", strategy.long, when = open > close)
strategy.close("buy", when = open < close, qty_percent = 50, comment = "close buy entry for 50%")
plot(strategy.position_size)

Parâmetros

• id(series string) Parâmetros necessários.
• when(series bool) Parâmetros opcionais. Condições do comando.
• qty(series int/float) Parâmetros opcionais↑ número de contratos/quantidade de ações/quantidade de mãos/unidades para sair do negócio↑ valor padrão: NaN↑
• qty_percent(series int/float) define a percentagem de equilíbrio ((0-100)). A sua prioridade é inferior à prioridade do parâmetro qty. Opcional. O valor padrão é 100.
• comment(series string) Parâmetros opcionais.
• alert_message(series string) Um parâmetro opcional quando o símbolo {{strategy.order.alert_message}} é usado na barra de mensagens da barra de alertas da caixa de diálogo da barra de alertas.

estratégia.fechar_todos

A partir de agora, o mercado está em uma posição de baixa e o mercado está em uma posição de baixa.

strategy.close_all(when, comment, alert_message) 

Exemplos

strategy("closeAll Demo", overlay=false)
strategy.entry("buy", strategy.long, when = open > close)
strategy.close_all(when = open < close, comment = "close all entries")
plot(strategy.position_size)

Parâmetros

• when(series bool) Parâmetros opcionais. Condições do comando.
• comment(series string) Parâmetros opcionais.
• alert_message(series string) Um parâmetro opcional quando o símbolo {{strategy.order.alert_message}} é usado na barra de mensagens da barra de alertas da caixa de diálogo da barra de alertas.

strategy.exit

Esta é uma ordem de saída que especifica uma entrada ou uma posição de mercado inteira. Se uma ordem com o mesmo ID já estiver pendurada, a ordem pode ser modificada. Se uma ordem de entrada não for executada, mas uma ordem de saída for apresentada, a ordem de saída será suspensa até que a ordem de saída seja colocada após a transação da ordem de entrada. Para interromper uma ordem de saída, o comando estrategy.cancel ou estrategy.cancel_all deve ser usado.应该多次调用命令strategy.exitSe você usar o stop loss e o track stop loss, cujo tipo de ordem é o stop stop, apenas um deles será colocado (será o primeiro a ser transacionado). Se todos os seguintes parâmetros: stop profit, stop limit, stop loss, stop trail, stop trail_points, stop trail_offset forem NaN, a ordem falhará. Para usar a ordem de saída do mercado, use o comando strategy.close ou strategy.close_all.

strategy.exit(id, from_entry, qty, qty_percent, profit, limit, loss, stop, trail_price, trail_points, trail_offset, oca_name, comment, when, alert_message) 

Exemplos

strategy(title = "simple strategy exit example")
strategy.entry("long", strategy.long, 1, when = open > high[1]) // enter long by market if current open great then previous high
strategy.exit("exit", "long", profit = 10, loss = 5) // generate full exit bracket (profit 10 points, loss 5 points per contract) from entry with name "long"

Parâmetros

• id(series string) Parâmetros necessários.
• from_entry(series string) Parâmetros selecionáveis↑ para especificar o identificador de entrada e saída de instruções↑ para sair de todas as posições, deve-se usar uma string vazia↑ o valor padrão é uma string vazia↑
• qty(series int/float) Parâmetros opcionais↑ número de contratos/quantidade de ações/quantidade de mãos/unidades para sair do negócio↑ valor padrão: NaN↑
• qty_percent(series int/float) define a percentagem de equilíbrio ((0-100)). A sua prioridade é inferior à prioridade do parâmetro qty. Opcional. O valor padrão é 100.
• profit(series int/float) Parâmetros opcionais; Objetivo de lucro (indicado em pontos); Se for especificado, quando o lucro especificado (indicado em pontos) for atingido, a ordem de saída da posição de mercado é a ordem de limite; o valor padrão é NaN NaN.
• limit(series int/float) Parâmetros opcionais. Objetivo de lucro (preço necessário) Se for especificado, saia do mercado no preço especificado (ou melhor). A prioridade do parâmetro é maior do que a prioridade do parâmetro de lucro (se não for o valor de lucro, o valor de lucro é substituído pelo valor de lucro).
• loss(series int/float) Parâmetro opcional↑ Stop Loss (indicado com ponto)↑ Se for especificado, quando o valor de prejuízo especificado (indicado com ponto) for atingido, saia da posição de mercado com um stop loss. O valor padrão é NaN↑
• stop(series int/float) Parâmetro opcional.  Parâmetro de stop loss (preço necessário)  Se for especificado, sair da posição no preço especificado (ou pior).  Parâmetro de prioridade do stop loss para o float superior ao parâmetro de prioridade do float para o float para o float.  Parâmetro de prioridade do float para o float para o float.
• trail_price(series int/float) Parâmetros opcionais. Nível de ativação de stop-loss de rastreamento (preço necessário) Se for especificado, a lista de stop-loss de rastreamento será colocada quando o nível de preço especificado for atingido. No parâmetro da barra de rastreamento int/float, especifique o desvio usado para determinar o preço inicial da barra de rastreamento de stop-loss (em ponto): X ponto abaixo do nível de ativação para sair de várias cabeças; X ponto acima do nível de ativação para sair de uma cavidade.
• trail_points(series int/float) Parâmetros opcionais: ∞ nível de ativação de stop loss (indicado por pontos de lucro) ∞ se especificado, quando atingido o nível de preço calculado (indicado pelo montante de lucro), a ordem de stop loss será colocada ∞ no parâmetro de ordem de desvio da ordem de stop loss (indicado por pontos de desvio) no parâmetro de ordem de trail_offset (indicado por pontos): ∞ ponto abaixo do nível de ativação para sair de várias cabeças; ∞ ponto acima do nível de ativação para sair de um espaço vazio ∞ o valor padrão é ∞ NaN ∞).
• trail_offset(series int/float) Parâmetros opcionais. Nível de ativação de stop loss de rastreamento (indicado em pontos). O desvio em pontos é usado para determinar o preço inicial da ordem de stop loss de rastreamento: X ponto abaixo do trail_price pad ou trail_points pad para sair de vários pontos; X ponto acima do trail_price pad ou trail_points pad para sair de um espaço vazio.
• oca_name(series string) Parâmetros opcionais. Nome do grupo OCA (oca_type = strategy.oca.reduce) Objetivo de ganho, stop/track stop. Se não for especificado, o nome será gerado automaticamente.Nota: FMZ não suporta este parâmetro.
• comment(series string) Parâmetros opcionais.
• when(series bool) Opções de parâmetros. Status 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 na barra de mensagens da barra de alertas da caixa de diálogo da barra de alertas.

strategy.cancel

Este é um nome de referência para cancelar / desativar todos os comandos de prelocação, gerado pelas seguintes funções: estrategy.order, strategy.entry andstrategy.exit。

strategy.cancel(id, when) 

Exemplos

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âmetros

• id(series string) Parâmetros obrigatórios↑ símbolo de ordem↑ localização do símbolo para cancelar um pedido↑
• when(series bool) Opções de parâmetros. Cancelar uma ordem com base no ID. Se for "true", a ordem será cancelada. O valor padrão é "true".

estratégia.cancelar_todos

这是取消/停用所有预挂单命令，由以下功能生成：strategy.order，strategy.entry和strategy.exit。

strategy.cancel_all(when) 

Exemplos

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âmetros

• when(series bool) Opções de opção↑ Cancelar todas as condições de ordem↑ Cancelar todas as ordens de atividade se a condição for verdadeira↑ Default: true↑

strategy.order

Este é o comando da ordem seguinte. Se uma ordem com o mesmo ID já estiver pendurada, você pode modificar a ordem. Se uma ordem com o mesmo ID não for especificada, uma nova ordem será emitida. Para parar a ordem, você deve usar o comando estrategy.cancel ou estrategy.cancel_all. Comparado com a função estrategy.entry, a função estrategy.order não é afetada pelo formato de pirâmide.

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

Exemplos

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âmetros

• id(series string) Parâmetros necessários.
• 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 opcionais↑ contrato/número de ações/quantidade de mãos/quantidade de unidades negociadas↑ valor predefinido de NaN NaN↑
• limit(series int/float) Opções de parâmetros. O valor limite da ordem. Se for especificado, o tipo de ordem é "limit" ou "stop-limit"; outros tipos de ordem são "NaN".
• stop(series int/float) Opções de parâmetros. O preço de stop-loss da ordem. Se for especificado, o tipo de ordem é "stop" ou "stop-limit"; outros tipos de ordem são "NaN".
• oca_name(series string) Parâmetros opcionais. A ordem pertence ao nome do grupo OCA. Se a ordem não pertence a nenhum grupo OCA, deve haver um caracter em branco.Nota: FMZ não suporta este parâmetro.
• oca_type(input string) Parâmetros opcionais. Tipo de grupo de pedidos OCA. Valores permitidos: strategy.oca.none - os pedidos não devem pertencer a nenhum grupo de pedidos OCA específico; strategy.oca.cancel - os pedidos devem pertencer ao grupo de pedidos OCA e, uma vez que o pedido é transacionado, todos os outros pedidos do mesmo grupo serão cancelados; strategy.oca.reduce - os pedidos devem pertencer ao grupo de pedidos OCA, se X número de contratos de pedidos tiver sido colocado, o número de outros pedidos do mesmo grupo de pedidos OCA será reduzido X.Nota: FMZ não suporta este parâmetro.
• comment(series string) Parâmetros opcionais.
• when(series bool) Opções de parâmetros. Status 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 na barra de mensagens da barra de alertas da caixa de diálogo da barra de alertas.

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

Retorna o bar_index para entrada de transações sem liquidação.

strategy.opentrades.entry_bar_index(trade_num)

Espere 10 linhas K e leve

Exemplos

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âmetros

• trade_num(series int) Número de transações não liquidadas. O número da primeira transação é zero.

Até logo. strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

estratégia.abertura de negócios. entrada_id

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

strategy.opentrades.entry_id(trade_num)

Exemplos

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

Retorno de valorRetorna o ID de entrada de transações não liquidadas.

Parâmetros

• trade_num(series int) Número de transações não liquidadas. O número da primeira transação é zero.

NotasSe o trade_num não estiver no intervalo, a função retornará na:0 para strategy.opentrades−1.

Até logo. strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

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

O preço de entrada é o preço de entrada de uma transação que não foi liquidada.

strategy.opentrades.entry_price(trade_num)

Exemplos

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

Cálculo do preço médio não equilibrado

Exemplos

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âmetros

• trade_num(series int) Número de transações não liquidadas. O número da primeira transação é zero.

Até logo. strategy.closedtrades.exit_price

Estratégia.abertura.tempo de entrada

Retorna o tempo de entrada do UNIX sem liquidação.

strategy.opentrades.entry_time(trade_num)

Exemplos

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âmetros

• trade_num(series int) Número de transações não liquidadas. O número da primeira transação é zero.

Até logo. strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

Retorna os ganhos e prejuízos dos negócios não liquidados. Os prejuízos são indicados como negativos.

strategy.opentrades.profit(trade_num)

Retorno do lucro da última negociação

Exemplos

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

Calcular os lucros de todas as transações não liquidadas

Exemplos

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âmetros

• trade_num(series int) Número de transações não liquidadas. O número da primeira transação é zero.

Até logo. 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ções não liquidadas. Se esse valor for > 0, a posição de mercado é multi-headed. Se esse valor for < 0, a posição de mercado é em branco.

strategy.opentrades.size(trade_num)

Exemplos

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 de lucro médio em transações não liquidadas

Exemplos

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âmetros

• trade_num(series int) Número de transações não liquidadas. O número da primeira transação é zero.

Até logo. strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

estratégia.closedtrades.entry_bar_index

Retorna o bar_index que já foi inserido na transação de liquidação.

strategy.closedtrades.entry_bar_index(trade_num)

Exemplos

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âmetros

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

Até logo. strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

estratégia.closedtrades.exit_price

O preço de saída é o preço de saída de uma transação que já foi liquidada.

strategy.closedtrades.exit_price(trade_num)

Exemplos

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

Calcule a percentagem do lucro médio de todas as transações liquidadas

Exemplos

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âmetros

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

Até logo. strategy.closedtrades.entry_price

estratégia.closedtrades.exit_bar_index

Retorna o bar_index que saiu da negociação de liquidação.

strategy.closedtrades.exit_bar_index(trade_num)

Exemplos

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.

Exemplos

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âmetros

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

Até logo. bar_index

estratégia.closedtrades.entry_id

Retorna o id de entrada de transações que já foram liquidadas.

strategy.closedtrades.entry_id(trade_num)

Exemplos

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

Retorno de valorRetorna o id de entrada de transações que já foram liquidadas.

Parâmetros

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

NotasSe o trade_num não estiver no intervalo, a função retornará na:0 para strategy.closedtrades−1.

Até logo. strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

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

O preço de entrada é o preço de entrada de uma transação que já foi liquidada.

strategy.closedtrades.entry_price(trade_num)

Exemplos

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

Calcule a percentagem do lucro médio de todas as transações liquidadas

Exemplos

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âmetros

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

Até logo. strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

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

Retornar ao tempo do UNIX no qual a transação foi liquidada.

strategy.closedtrades.entry_time(trade_num)

Exemplos

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âmetros

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

Até logo. strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

Retornar os ganhos e perdas de negociações que já foram liquidadas. A perda é representada como negativa.

strategy.closedtrades.profit(trade_num)

Exemplos

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âmetros

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

Até logo. 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 que já estão em liquidação. Se esse valor for > 0, a posição de mercado é multi-head. Se esse valor for < 0, a posição de mercado é em branco.

strategy.closedtrades.size(trade_num)

Exemplos

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 de lucro médio de negociações de liquidação

Exemplos

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.closedtrade

Mais.