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”.
- (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_name
(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.
- oca_type
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.
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 100comment
(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.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.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 100profit
(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 NaNlimit
(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 NaNstop
(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 NaNtrail_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
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.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”.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 trueIl 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 vendreqty
(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
oca_type
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.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
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
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
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
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
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
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 0Voir aussi
strategy.closedtrades.exit_bar_index
strategy.opentrades.entry_bar_index
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 0Voir aussi
strategy.closedtrades.entry_price
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 0Voir aussi
bar_index
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
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 0Voir aussi
strategy.closedtrades.exit_price
strategy.closedtrades.size
strategy.closedtrades
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 0Voir aussi
strategy.opentrades.entry_time
strategy.closedtrades.exit_time
time
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 0Voir aussi
strategy.opentrades.profit
strategy.closedtrades.commission
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 0Voir aussi
strategy.opentrades.size
strategy.position_size
strategy.closedtrades
strategy.opentrades
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 0Voir aussi
strategy.closedtrades.entry_time
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
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.entry
Le 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.Si seulement.number
>= 0,number
La valeur absolue est number
ou pour -number
。
math.abs(number)
Retourne une valeur
number
Les valeurs absolues de
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.
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.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.
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].
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
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 courburenumber
La fonction exp de e est number
la puissance, où e est le nombre d’our.
math.exp(number)
Retourne une valeur
Une représentation de la valeur de e, c’est number
Je suis désolé.
Voir aussi
math.pow
math.floor(number)
Retourne une valeur Le plus grand entier inférieur ou égal à un nombre donné.
Voir aussi
math.ceil
math.round
N’importe quoi.number
L’arithmétique naturelle de > 0 est la seule y, de sorte que e^y = number
。
math.log(number)
Retourne une valeur
number
L’arithmétique naturelle de .
Voir aussi
math.log10
number
L’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
number
L’arithmétique de base 10 de .
Voir aussi
math.log
Fonctions de la matrice mathématique
math.pow(base, exponent)
Exemple
// math.pow
plot(math.pow(close, 2))
Retourne une valeur
base
Augmentéexponent
Si vous avezbase
C’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
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.
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 courbureN’importe quoi.number
La 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
number
La racine carrée de
Voir aussi
math.pow
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 courbureLe retour.number
Si 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.precision
Le paramètre retourne une valeur de flochette de quatre chiffres à cinq chiffres.
math.round(number)
math.round(number, precision)
Retourne une valeur
number
Les 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.number
Les 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
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
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
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
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
number
Il 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
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
length
La ligne K est retournéesource
Ré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
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.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.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
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
source
La valeur, si elle n’est pasna
Sisource
est égal àna
Si vous utilisez 1, retourne 0, si vous utilisez 1.replacement
Paramètres
paramètre
source
(series int/float/bool/color) La valeur de la série à exécuterreplacement
(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
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
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
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
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
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
Pour la compatibilitéTrading View
Le code de stratégie n’a pas besoin d’être appelé.
Voir aussi
strategy
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 chargesession
Paramè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