�� le prix limite de la commande。 le type de commande est “limit” ou “stop-limit” si spécifié。 les autres types de commande sont “NaN”。 - stop(series int/float) Paramètre facultatif. Le type d’ordre est “stop” ou “stop-limit” si spécifié. Les autres types d’ordres sont “NaN”. - oca_name(series string) Paramètre facultatif. La commande appartient au nom du groupe OCA. Si la commande n’appartient à aucun groupe OCA, il devrait y avoir un caractère blanc.Remarque: FMZ ne prend pas en charge ce paramètre. - oca_type(input string) Paramètres optionnels. Type de groupe d’ordres OCA. Les valeurs autorisées sont: strategy.oca.none - l’ordre ne doit pas appartenir à un groupe OCA spécifique; strategy.oca.cancel - l’ordre doit appartenir à un groupe OCA, et une fois que l’ordre est passé, tous les autres ordres du même groupe seront annulés; strategy.oca.reduce - l’ordre doit appartenir à un groupe OCA, et si X nombre de contrats d’ordres ont été placés, le nombre d’autres contrats d’ordres du même groupe OCA est réduit par X.Remarque: FMZ ne prend pas en charge ce paramètre. - comment(series string) Paramètres à choisir. Les autres détails de la commande. - when(series bool) Paramètre facultatif。 État de la commande。 Si “true”, la commande est placée。 Si “false”, rien ne se passe ((une commande avec le même ID placée précédemment n’est pas annulée)。 La valeur par défaut est “true”。 - alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d’alerte de la boîte de dialogue de création d’une alerte.

strategy.close

Il s’agit d’un ordre de sortie avec un identifiant spécifié. S’il y a plusieurs ordres d’entrée avec le même identifiant, ils seront tous sortis en même temps. Si aucun ordre d’ouverture avec un identifiant spécifié n’a été déclenché au moment du déclenchement de l’ordre, l’ordre n’aura pas d’effet. L’ordre utilise un ordre de marché.

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

Exemple

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)

paramètre

• id(series string) Paramètre requis。 Identificateur de commande。 La commande peut être fermée en citant son identifiant。
• when(series bool) Paramètre sélectionnable。 Condition de la commande。
• qty(series int/float) Paramètre sélectionnable. Le nombre de contrats/actions/heures/unités de sortie de la transaction. La valeur par défaut est ‘NaN’
• qty_percent(series int/float) Définit le pourcentage de placement en bourse ((0-100) ◦ dont la priorité est inférieure à la priorité du paramètre ‘qty’). Optionnel. La valeur par défaut est 100
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d’alerte de la boîte de dialogue de création d’une alerte.

strategy.close_all

Il s’agit d’une opération de liquidation d’une position sur le marché pour la stabiliser.

strategy.close_all(when, comment, alert_message) 

Exemple

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)

paramètre

• when(series bool) Paramètre sélectionnable。 Condition de la commande。
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d’alerte de la boîte de dialogue de création d’une alerte.

strategy.exit

Il s’agit d’un ordre de sortie désignant une entrée ou une position sur l’ensemble du marché. Si un ordre avec le même ID est déjà en suspens, l’ordre peut être modifié. Si un ordre d’entrée n’a pas été négocié, mais qu’un ordre de sortie apparaît, l’ordre de sortie est suspendu jusqu’à ce que l’ordre de sortie puisse être placé après la négociation d’un ordre d’entrée.

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

Exemple

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"

paramètre

• id(series string) Paramètre requis。 Identificateur de commande。 Les commandes peuvent être annulées ou modifiées en se référant à leur identifiant。
• from_entry(series string) Paramètre sélectionnable。 Exit avec un identifiant d’ordre d’entrée spécifié。 Exit de toutes les positions avec une chaîne vide。 La valeur par défaut est une chaîne vide。
• qty(series int/float) Paramètre sélectionnable. Le nombre de contrats/actions/heures/unités de sortie de la transaction. La valeur par défaut est ‘NaN’
• qty_percent(series int/float) Définit le pourcentage de placement en bourse ((0-100) ◦ dont la priorité est inférieure à la priorité du paramètre ‘qty’). Optionnel. La valeur par défaut est 100
• profit(series int/float) paramètre optionnel. Objectif de profit (indiqué en points) Si spécifié, sortie de la position sur ordre de plafonnement lorsque le montant de profit indiqué (en points) est atteint. La valeur par défaut est NaN
• limit(series int/float) paramètre facultatif ◦ objectif de profit ◦ prix spécifié ◦ sortie du marché à un prix spécifié ◦ ou mieux ◦ priorité du paramètre ‘limit’ supérieure à la priorité du paramètre ‘profit’ ◦ si la valeur n’est pas ‘NaN’, ‘limit’ remplace ‘profit’) ◦ valeur par défaut est NaN ◦
• loss(series int/float) paramètre optionnel ≠ Stop loss (indiqué en points) ≠ Si spécifié, sortie du marché avec un stop loss (indiqué en points) ≠ Si la valeur par défaut est NaN
• stop(series int/float) paramètre facultatif ≠ Stop loss (prix à spécifier) ≠ Exit position de marché à prix spécifié (ou moins) si spécifié ≠ Priorité de paramètre ‘stop loss’ supérieure à la priorité de paramètre ‘loss’ (si valeur n’est pas ‘NaN’, alors ‘stop loss’ au lieu de ‘loss’) ≠ valeur par défaut est NaN
• trail_price(series int/float) paramètres optionnels. Tracking stop activation level ((prix à spécifier)) Si spécifié, le stop est placé lorsque le prix spécifié est atteint. Dans le paramètre de la colonne trail_offset, le décalage est spécifié pour déterminer le prix initial de la colonne tracking stop ((en points): X points en dessous du niveau d’activation pour quitter le multiple; X points au-dessus du niveau d’activation pour quitter le vide. La valeur par défaut est NaN.
• trail_points(series int/float) paramètres optionnels. Tracking Stop Loss Activation Level (indiqué en points pour les bénéfices). Si spécifié, placement d’un Stop Loss Tracking Order (indiqué en points pour les bénéfices) lorsque le niveau de prix calculé est atteint.
• trail_offset(series int/float) paramètres optionnels. Tracking stop activation level ((exprimé en points). Le décalage en points est utilisé pour déterminer le prix initial d’un stop tracking: X points en dessous de ‘trail_price’ ou ‘trail_points’ pour quitter le multi-titres; X points en haut de ‘trail_price’ ou ‘trail_points’ pour quitter le vide.
• oca_name(series string) Paramètre sélectionnable. Nom du groupe OCA (oca_type = strategy.oca.reduce) Objectif de profit, stop loss/tracking stop loss. Si le nom n’est pas spécifié, il sera généré automatiquement.Remarque: FMZ ne prend pas en charge ce paramètre.
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• when(series bool) Paramètre facultatif。 État de la commande。 Si “true”, la commande est placée。 Si “false”, rien ne se passe ((une commande avec le même ID placée précédemment n’est pas annulée)。 La valeur par défaut est “true”。
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d’alerte de la boîte de dialogue de création d’une alerte.

strategy.cancel

Il s’agit d’une commande qui utilise le nom de référence pour annuler / désactiver toutes les listes prédéfinies et qui est générée par les fonctions suivantes: strategy.order, strategy.entry et strategy.exit.

strategy.cancel(id, when) 

Exemple

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

paramètre

• id(series string) Paramètre à sélectionner. Identification de la commande. Positionner cette identification pour annuler une commande.
• when(series bool) Paramètre optionnel. Annuler une commande en fonction de l’ID. Si elle est “true”, l’ordre est annulé. La valeur par défaut est “true”.

strategy.cancel_all

Il s’agit d’une commande d’annulation/déclenchement de toutes les commandes de liste pré-enregistrée, générée par les fonctions suivantes: strategy.order, strategy.entry et strategy.exit.

strategy.cancel_all(when) 

Exemple

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

paramètre

• when(series bool) Paramètre optionnel ≠ annuler les conditions de toutes les commandes ≠ annuler toutes les commandes actives si la condition est vraie ≠ la valeur par défaut est true

strategy.order

Il s’agit d’une commande de la commande suivante. Si une commande avec le même ID est déjà en suspens, la commande peut être modifiée. Si aucune commande avec le même ID n’est spécifiée, une nouvelle commande est émise.

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

Exemple

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

paramètre

• id(series string) Paramètre requis。 Identificateur de commande。 Les commandes peuvent être annulées ou modifiées en se référant à leur identifiant。
• direction(strategy_direction) Un paramètre nécessaire. Direction de la commande: ‘strategy.long’ pour acheter et ‘strategy.short’ pour vendre
• qty(series int/float) Paramètres à choisir. Nombre de contrats/actions/heures/unités négociés. La valeur par défaut est ‘NaN’
• limit(series int/float) Paramètre facultatif。 le prix limite de la commande。 le type de commande est “limit” ou “stop-limit” si spécifié。 les autres types de commande sont “NaN”。
• stop(series int/float) Paramètre facultatif. Le type d’ordre est “stop” ou “stop-limit” si spécifié. Les autres types d’ordres sont “NaN”.
• oca_name(series string) Paramètre facultatif. La commande appartient au nom du groupe OCA. Si la commande n’appartient à aucun groupe OCA, il devrait y avoir un caractère blanc.Remarque: FMZ ne prend pas en charge ce paramètre.
• oca_type(input string) Paramètres optionnels. Type de groupe d’ordres OCA. Les valeurs autorisées sont: strategy.oca.none - l’ordre ne doit pas appartenir à un groupe OCA spécifique; strategy.oca.cancel - l’ordre doit appartenir à un groupe OCA, et une fois que l’ordre est passé, tous les autres ordres du même groupe seront annulés; strategy.oca.reduce - l’ordre doit appartenir à un groupe OCA, et si X nombre de contrats d’ordres ont été placés, le nombre d’autres contrats d’ordres du même groupe OCA est réduit par X.Remarque: FMZ ne prend pas en charge ce paramètre.
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• when(series bool) Paramètre facultatif。 État de la commande。 Si “true”, la commande est placée。 Si “false”, rien ne se passe ((une commande avec le même ID placée précédemment n’est pas annulée)。 La valeur par défaut est “true”。
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d’alerte de la boîte de dialogue de création d’une alerte.

strategy.opentrades.entry_bar_index

Le bar_index qui renvoie à une entrée en bourse non liquidée.

strategy.opentrades.entry_bar_index(trade_num)

Attendre 10 lignes K et faire le plein.

Exemple

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

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

strategy.opentrades.entry_id

L’ID de l’opérateur qui a effectué l’ouverture d’une transaction non liquidée.

strategy.opentrades.entry_id(trade_num)

Exemple

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

Retourne une valeur L’ID de l’opérateur qui a effectué l’ouverture d’une transaction non liquidée.

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

À noter Si trade_num n’est pas dans la fourchette, la fonction renvoie na:0 à strategy.opentrades-1。

Voir aussi strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

strategy.opentrades.entry_price

Le prix d’entrée de la transaction non liquidée.

strategy.opentrades.entry_price(trade_num)

Exemple

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

Calculer le prix moyen d’une position non liquidée

Exemple

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

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi strategy.closedtrades.exit_price

strategy.opentrades.entry_time

Retour à l’heure UNIX de l’entrée en bourse sans avoir encore réglé la position.

strategy.opentrades.entry_time(trade_num)

Exemple

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

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

Les pertes de retour sur les transactions non liquidées. Les pertes sont exprimées en valeur négative.

strategy.opentrades.profit(trade_num)

Retour sur les bénéfices de la dernière transaction ouverte

Exemple

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

Calculer le bénéfice de toutes les transactions non liquidées

Exemple

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

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit

strategy.opentrades.size

Retourne la direction de la transaction et le nombre de contrats dans une transaction en cours. Si cette valeur est supérieure à 0, la position du marché est en tête. Si cette valeur est inférieure à 0, la position du marché est vide.

strategy.opentrades.size(trade_num)

Exemple

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

Pourcentage de bénéfices moyens sur les transactions non liquidées

Exemple

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)

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

strategy.closedtrades.entry_bar_index

Il retourne le bar_index de l’entrée de la transaction qui a été liquidée.

strategy.closedtrades.entry_bar_index(trade_num)

Exemple

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

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

strategy.closedtrades.exit_price

Retour au prix de départ d’une transaction qui a été liquidée.

strategy.closedtrades.exit_price(trade_num)

Exemple

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

Calculer le pourcentage de bénéfices moyens sur toutes les transactions qui ont été liquidées

Exemple

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)

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi strategy.closedtrades.entry_price

strategy.closedtrades.exit_bar_index

Le retour de bar_index de sortie d’une transaction qui a été clôturée

strategy.closedtrades.exit_bar_index(trade_num)

Exemple

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

Calculer le nombre moyen de lignes K pour chaque transaction.

Exemple

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

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi bar_index

strategy.closedtrades.entry_id

L’id de l’entrée qui a été renvoyée pour la transaction qui a été liquidée.

strategy.closedtrades.entry_id(trade_num)

Exemple

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

Retourne une valeur L’id de l’entrée qui a été renvoyée pour la transaction qui a été liquidée.

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

À noter Si trade_num n’est pas dans la fourchette, la fonction renvoie na:0 à strategy.closedtrades-1。

Voir aussi strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

strategy.closedtrades.entry_price

Retour au prix d’entrée de la transaction qui a été liquidée.

strategy.closedtrades.entry_price(trade_num)

Exemple

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

Calculer le pourcentage de bénéfices moyens sur toutes les transactions qui ont été liquidées

Exemple

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)

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

strategy.closedtrades.entry_time

Retour à l’heure UNIX de la clôture de la transaction.

strategy.closedtrades.entry_time(trade_num)

Exemple

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

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

Les pertes sont exprimées en valeur négative.

strategy.closedtrades.profit(trade_num)

Exemple

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

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi strategy.opentrades.profit strategy.closedtrades.commission

strategy.closedtrades.size

Retourne la direction de la transaction et le nombre de contrats dans une transaction qui a été liquidée. Si cette valeur est supérieure à 0, la position du marché est en tête. Si cette valeur est inférieure à 0, la position du marché est vide.

strategy.closedtrades.size(trade_num)

Exemple

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

Calcul du pourcentage de bénéfice moyen sur les transactions en position de marché.

Exemple

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)

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi strategy.opentrades.size strategy.position_size strategy.closedtrades strategy.opentrades

strategy.closedtrades.exit_time

Retour à l’heure UNIX de sortie d’une transaction qui a été réglée.

strategy.closedtrades.exit_time(trade_num)

Exemple

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 secondes pour réouvrir une transaction qui a été réglée

Exemple

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)

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi strategy.closedtrades.entry_time

strategy.risk.allow_entry_in

Cette fonction peut être utilisée pour spécifier la direction dans laquelle la fonction strategy.entry permet d’ouvrir une position sur un marché.

strategy.risk.allow_entry_in(value)

Exemple

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)

paramètre

• value(simple string) Direction autorisée ≠ valeur possible:strategy.direction.all、strategy.direction.long、strategy.direction.short

strategy.risk.max_position_size

Le but de cette règle est de déterminer la valeur maximale d’une position sur le marché. La règle affecte les fonctions suivantes:strategy.entryLe nombre d’entrées peut être réduit (si nécessaire) au nombre de contrats/actions/mains/unités, de sorte que le montant total de la position ne dépasse pas la valeur indiquée dans ‘strategy.risk.max_position_size’. Si le nombre minimum est toujours en violation de la règle, aucune commande ne sera placée.

strategy.risk.max_position_size(contracts)

Exemple

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

paramètre

• contracts(simple int/float) Paramètre requis. Le nombre maximal de contrats/actions/mains/unités pour une position.

math

math.abs

Si seulement.number >= 0，numberLa valeur absolue est numberou pour -number。

math.abs(number) 

Retourne une valeur numberLes valeurs absolues de

math.acos

La fonction acos renvoie le résidu inverse du nombre ((exprimé en arcs), comme cos ((acos ((y)) = y dans la plage y.[-1, 1]。

math.acos(angle)

Retourne une valeur La résonance inverse. Si y est hors de portée[-1,1], l’angle de retour est[0,Pi] ou dans une plage de na.

math.random

Retourne une valeur pseudo-aléatoire. Cette fonction génère une séquence de valeurs différente pour chaque script exécuté. Utiliser la même valeur pour les paramètres sélectifs de semence génère une séquence répétable.

math.random(min, max, seed)

Retourne une valeur Une valeur aléatoire.

paramètre

• min(series int/float) Limite inférieure d’une plage de valeurs aléatoires。 Cette valeur n’est pas incluse dans la plage。 La valeur par défaut est 0。
• max(series int/float) Limite supérieure de la plage de valeurs aléatoires。 Cette valeur n’est pas incluse dans la plage。 La valeur par défaut est 1。
• seed(input int) Paramètre facultatif. Lorsque la même graine est utilisée, il est permis d’appeler la fonction de manière continue pour produire un ensemble de valeurs répétables.

math.asin

La fonction asin renvoie la résine inverse du nombre ((exprimée en arcs), la résine ((asin ((y)) = y dans la plage y[-1, 1]。

math.asin(angle) 

Retourne une valeur La résonance. Si y est hors de portée[-1,1], l’angle de retour est[-Pi / 2, Pi / 2] ou dans une plage de na.

math.atan

La fonction atan renvoie la coupe inverse du nombre ((exprimé en arcs), tan (((atan ((y)) = y dans n’importe quel y.

math.atan(angle) 

Retourne une valeur La valeur de coupe inverse; angle de retour dans[-Pi / 2, dans le domaine de Pi / 2].

math.ceil

La fonction d’intégration vers le haut renvoie le plus petit nombre entier (le plus proche de l’infini négatif) supérieur ou égal à l’arithmétique.

math.ceil(number)

Retourne une valeur Le plus petit entier inférieur ou égal à un nombre donné.

Voir aussi math.floor math.round

math.cos

La fonction cos renvoie l’axe du triangle à l’angle.

math.cos(angle) 

Retourne une valeur Les cordes triangulaires des coins.

paramètre

• angle(series int/float) angle, avec une courbure

math.exp

numberLa fonction exp de e est numberla puissance, où e est le nombre d’our.

math.exp(number) 

Retourne une valeur Une représentation de la valeur de e, c’est numberJe suis désolé.

Voir aussi math.pow

math.floor

math.floor(number) 

Retourne une valeur Le plus grand entier inférieur ou égal à un nombre donné.

Voir aussi math.ceil math.round

math.log

N’importe quoi.numberL’arithmétique naturelle de > 0 est la seule y, de sorte que e^y = number。

math.log(number)

Retourne une valeur numberL’arithmétique naturelle de .

Voir aussi math.log10

math.log10

numberL’arithmétique courante (ou basée sur 10) est celle où l’on doit augmenter 10 pour obtenirnumber。10^y = number。

math.log10(number)

Retourne une valeur numberL’arithmétique de base 10 de .

Voir aussi math.log

math.pow

Fonctions de la matrice mathématique

math.pow(base, exponent)

Exemple

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

Retourne une valeur baseAugmentéexponentSi vous avezbaseC’est une série, elle est calculée par élément.

paramètre

• base(series int/float) spécifie la base à utiliser.
• exponent(series int/float) Indicateur spécifié。

Voir aussi math.sqrt math.exp

math.sign

Si le nombre de pions est égal à zéro, le symbole (signum) du nombre de pions est égal à zéro, si le nombre de pions est supérieur à zéro, il est égal à 1, et si le nombre de pions est inférieur à zéro, il est égal à -1,0.

math.sign(number)

Retourne une valeur Le symbole du paramètre.

math.sin

La fonction cosine renvoie la cosine d’un angle.

math.sin(angle)

Retourne une valeur Syntonie triangulaire des angles

paramètre

• angle(series int/float) angle, avec une courbure

math.sqrt

N’importe quoi.numberLa racine carrée de plus de zéro est la seule chose pour laquelle y est égal à zéro et y est égal à zéro.number。

math.sqrt(number)

Retourne une valeur numberLa racine carrée de

Voir aussi math.pow

math.tan

Le triangle dans lequel la fonction tan renvoie l’angle est orthogonal.

math.tan(angle)

Retourne une valeur Le triangle des coins est rectangle.

paramètre

• angle(series int/float) angle, avec une courbure

math.round

Le retour.numberSi l’on utilise le nombre de points, on peut utiliser le nombre de points, le nombre de points, le nombre de points, le nombre de points, le nombre de points.precisionLe paramètre retourne une valeur de flochette de quatre chiffres à cinq chiffres.

math.round(number) 

math.round(number, precision) 

Retourne une valeur numberLes valeurs de l’équivalent sont approximées à l’entier le plus proche, ou selon la précision.

paramètre

• number(series int/float) La valeur à entourer de 5 est ≠
• precision(series int) est un paramètre sélectif.numberLes nombres décimaux seront arrondis au carré sans paramètres, et arrondis au carré au plus proche entier.

À noter Notez que pour une valeur ‘na’, la fonction renvoie ‘na’。

Voir aussi math.ceil math.floor

math.max

Renvoie la plus grande des valeurs.

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

Exemple

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

Retourne une valeur La plus grande des valeurs données.

Voir aussi math.min

math.min

Retourne la plus petite des valeurs.

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

Exemple

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

Retourne une valeur La plus petite valeur parmi plusieurs valeurs données.

Voir aussi math.max

math.avg

Calculer la moyenne de toutes les séries ((éléments correspondants))

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

Retourne une valeur Moyenne

Voir aussi math.sum ta.cum ta.sma

math.round_to_mintick

Retourne la valeur de mintick qui est ronde sur le produit, c’est-à-dire que la valeur de mintick peut être divisée par la valeur la plus proche de syminfo.mintick, sans résidu, et arrondie vers le haut.

math.round_to_mintick(number) 

Retourne une valeur numberIl a fait quatre tours et cinq entrées pour être précis jusqu’à tick.

paramètre

• number(series int/float) La valeur à entourer de 5 est ≠

Voir aussi math.ceil math.floor

math.sum

La fonction sum renvoie le résultat de la synthèse glissante de la dernière valeur y de x.

math.sum(source, length)

Retourne une valeur lengthLa ligne K est retournéesourceRésumé

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi ta.cum for

math.todegrees

De l’angle en unité d’arc, retournez à l’angle approximativement équivalent en unité de degré.

math.todegrees(radians) 

Retourne une valeur La valeur d’angle est mesurée en unités.

paramètre

• radians(series int/float) Angle représenté par l’arc.

math.toradians

De l’angle en unités de mesure, retournez l’angle approximativement équivalent en unités d’arcade.

math.toradians(degrees) 

Retourne une valeur La valeur angulaire en unités d’arc.

paramètre

• degrees(series int/float) L’angle est mesuré en unités.

others

fixnan

Pour une série donnée, remplacez la valeur NaN par la précédente valeur non-NaN。

fixnan(source) 

Retourne une valeur Une série sans interruption

paramètre

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

Voir aussi na nz

nz

Remplacez la valeur NaN par zéro (ou un nombre spécifié) dans la série.

nz(source, replacement) 

nz(source)

Exemple

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

Retourne une valeur sourceLa valeur, si elle n’est pasnaSisourceest égal ànaSi vous utilisez 1, retourne 0, si vous utilisez 1.replacementParamètres

paramètre

• source(series int/float/bool/color) La valeur de la série à exécuter
• replacement(series int/float/bool/color) remplace les valeurs de tous les thresholds de la série de thresholds de la source de la colonne.

Voir aussi na fixnan

na

Si c’est NaN, la valeur de test est ∂.

na(x)

Retourne une valeur Si x n’est pas un nombre valide, alors c’est vrai ((x est NaN), sinon c’est faux.

Voir aussi fixnan nz

int

Convertir na ou couper la valeur de float en int ≠

int(x) 

Retourne une valeur Convertissez la valeur de l’argument après int.

Voir aussi float bool color string

float

Réglez na à flottant.

float(x) 

Retourne une valeur La conversion en valeur de paramètre après float

Voir aussi int bool color string

alert

Trigger des événements d’alerte lors de l’appel pendant la ligne K en temps réel et créer des alertes basées sur les événements de la fonction d’alerte comme indicateur ou stratégie précédemment créée via la boîte de dialogue Créer une fenêtre d’alerte.

alert(message, freq)

Exemple

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

paramètre

• message(series string) Le message envoyé lors du déclenchement de l’alerte.
• freq(input string) Trigger frequency. Les valeurs possibles sont: alert.freq_all, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar

À noter Le centre d’aide explique comment créer une alerte de ce type. Contrairement à la condition d’alert, l’appel d’alert n’est pas considéré comme un dessin supplémentaire. Les appels de fonctions peuvent être globaux ou locaux. L’appel de la fonction n’affiche rien sur le graphique Le paramètre freq n’affecte que la fréquence de déclenchement utilisée pour cette fonction.

Voir aussi alertcondition

alertcondition

Créer une condition d’alerte est disponible dans la boîte de dialogue Créer une condition d’alerte. Veuillez noter que la condition d’alert ne crée pas d’alerte, mais vous offre plus d’options dans la boîte de dialogue Créer une condition d’alert. De plus, l’effet de la condition d’alert n’est pas visible sur le graphique.

alertcondition(condition, title, message)

Exemple

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

paramètre

• condition(series bool) La série de valeurs bool utilisée pour une alerte. True signifie que l’alerte a été déclenchée et false signifie qu’il n’y a pas d’alerte. Paramètre requis.
• title(const string) Titre de la condition d’alerte. Paramètres à choisir.
• message(const string) Afficher un message lorsque l’alerte est déclenchée.

À noter Veuillez noter que dans Pine v4, les appels de conditions d’alerte génèrent un graphique supplémentaire. Tous ces appels sont pris en compte lorsque nous calculons le nombre de séries de sorties pour chaque script.

Voir aussi alert

indicator

Pour la compatibilitéTrading ViewLe code de stratégie n’a pas besoin d’être appelé.

Voir aussi strategy

time

La fonction time renvoie l’heure UNIX de la ligne K actuelle de la plage de temps et du moment de la transaction, et NaN si le moment n’est pas dans le moment de la transaction. Remarque: FMZ n’est pas pris en chargesessionParamètres

time(timeframe, session, timezone)

time(timeframe, session)

time(timeframe)

Exemple

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

Lorsque vous configurez une session, vous pouvez spécifier non seulement l’heure et la minute, mais aussi le jour de la semaine. Si aucune date n’est spécifiée, on considère que la période de négociation est définie comme étant du dimanche (1) au samedi (7), c’est-à-dire 1100-2000 est identique à 1100-1200:1234567. Vous pouvez le modifier en spécifiant une date. Par