La valeur t est
trail_price(série int/float) Un argument facultatif. Niveau d'activation du trailing stop (requiert un prix spécifique). S'il est spécifié, un ordre de trailing stop sera placé lorsque le niveau de prix spécifié est atteint. Le décalage (en ticks) pour déterminer le prix initial de l'ordre de trailing stop est spécifié dans l'argument trail_points(série int/float) Argument facultatif. Niveau d'activation du trailing stop (bénéfice spécifié en ticks). S'il est spécifié, un ordre d'activation du trailing stop sera placé lorsque le niveau de prix calculé (montant de profit spécifié) est atteint. Le décalage (en ticks) pour déterminer le prix initial de l'ordre d'arrêt du trailing stop est spécifié dans l'argument trail_offset(série int/float) Un argument facultatif. Prix de trailing stop (spécifié en ticks). Le décalage en ticks pour déterminer le prix initial de l'ordre de trailing stop: X ticks inférieur à oca_namecommentUn argument facultatif, des instructions supplémentaires pour l'ordre.when(série bool) Un argument facultatif. Condition de l'ordre. L'ordre est placé si la condition est alert_message(chaîne de séries) Argument facultatif lors de l'utilisation du espace réservé {{strategy.order.alert_message}} dans le champ Il s'agit d'une commande permettant d'annuler/désactiver les ordres en attente en faisant référence à leurs noms, qui ont été générés par les fonctions: strategy.order, strategy.entry etstrategy.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
Les arguments
id(chaîne de séries) Un argument requis. L'identifiant de commande. Il est possible d'annuler une commande en faisant référence à son identifiant.when(série bool) Un argument facultatif. Condition pour annuler une commande avec un ID spécifié. Si la condition est Il s'agit d'une commande permettant d'annuler/désactiver tous les ordres en attente, générés par les fonctions: strategy.order, strategy.entry etstrategy.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
Les arguments
when(série bool) Un argument facultatif. Condition pour annuler toutes les commandes. Si la condition est vraie, alors toutes les commandes actives seront annulées. La valeur par défaut est Il s'agit d'une commande pour passer une commande. Si une commande avec le même ID est déjà en attente, il est possible de modifier l'ordre. S'il n'y a pas d'ordre avec l'ID spécifié, une nouvelle commande est passée. Pour désactiver l'ordre, la commande strategy.cancel ou strategy.cancel_all doit être utilisée. Par rapport à la fonction strategy.entry, la fonction strategy.order n'est pas affectée par la pyramide. Si les paramètres
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
Les arguments
id(série de chaînes) Un paramètre requis. L'identifiant de commande. Il est possible d'annuler ou de modifier une commande en faisant référence à son identifiant.direction(strategy_direction) Un paramètre requis. La direction de l'ordre: qty(série int/float) Un paramètre facultatif. Nombre de contrats/actions/lots/unités à négocier. La valeur par défaut est limit(série int/float) Un paramètre facultatif. Prix limite de l'ordre. S'il est spécifié, le type d'ordre est soit stop(série int/float) Un paramètre facultatif. Prix d'arrêt de l'ordre. S'il est spécifié, le type d'ordre est oca_nameoca_typecommentUn paramètre facultatif, des notes supplémentaires sur l'ordre.when(série bool) Un paramètre facultatif. Condition de l'ordre. L'ordre est placé si la condition est alert_message(série de chaînes) Un paramètre facultatif qui remplace le espace réservé à {{strategy.order.alert_message}} lorsqu'il est utilisé dans le champ Renvoie le bar_index de l'entrée de la transaction ouverte.
strategy.opentrades.entry_bar_index(trade_num)
Attendez 10 mesures et fermez la position.
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")
Les arguments
trade_num(série int) Le numéro de transaction de la transaction ouverte. Le numéro de la première transaction est nul.Voir aussi
strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index
Retourne l'identifiant de la transaction ouverte.
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))
RetoursRenvoie l'ID de l'entrée de transaction ouverte.
Les arguments
trade_num(série int) Le numéro de transaction de la transaction ouverte. Le numéro de la première transaction est nul.Les commentairesLa fonction renvoie na si trade_num n'est pas dans la plage: 0 à strategy.opentrades-1.
Voir aussi
strategy.opentrades.entry_bar_index strategy.opentrades.entry_time
Renvoie le prix de l'entrée de la transaction ouverte.
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 de la position ouverte.
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())
Les arguments
trade_num(série int) Le numéro de transaction de la transaction ouverte. Le numéro de la première transaction est nul.Voir aussi
strategy.closedtrades.exit_price
Renvoie l'heure UNIX de l'entrée de la transaction ouverte.
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")
Les arguments
trade_num(série int) Le numéro de transaction de la transaction ouverte. Le numéro de la première transaction est nul.Voir aussi
strategy.closedtrades.entry_time strategy.closedtrades.exit_time
Retourne le bénéfice/perte de la transaction ouverte.
strategy.opentrades.profit(trade_num)
Retourner le bénéfice 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 positions ouvertes.
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")
Les arguments
trade_num(série int) Le numéro de transaction de la transaction ouverte. Le numéro de la première transaction est nul.Voir aussi
strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit
Retourne la direction et le nombre de contrats négociés dans le commerce ouvert. Si la valeur est supérieure à 0, la position de marché était longue. Si la valeur est inférieure à 0, la position de marché était courte.
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")
Calculer le pourcentage de profit moyen des positions ouvertes.
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)
Les arguments
trade_num(série int) Le numéro de transaction de la transaction ouverte. Le numéro de la première transaction est nul.Voir aussi
strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades
Renvoie l'index de barre de l'entrée de la transaction fermé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())
Les arguments
trade_num(série int) Le numéro de transaction de la transaction clôturée.Voir aussi
strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index
Renvoie le prix de sortie d'une transaction conclue.
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 profit moyen pour toutes les opérations closes.
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)
Les arguments
trade_num(série int) Numéro de transaction de la transaction clôturée.Voir aussi
strategy.closedtrades.entry_price
Retourner le bar_index de la sortie de transaction fermé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 par 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())
Les arguments
trade_num(série int) Le numéro de transaction de la transaction clôturée.Voir aussi
bar_index
Retourne l'identifiant de l'entrée de transaction clôturé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))
RetoursRetourne l'identifiant de l'entrée de transaction clôturée.
Les arguments
trade_num(série int) Le numéro de transaction de la transaction clôturée.Les commentairesLa fonction renvoie na si trade_num n'est pas dans la plage: 0 à strategy.closedtrades-1.
Voir aussi
strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time
Renvoie le prix de l'entrée de la transaction close.
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 profit moyen pour toutes les opérations closes.
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)
Les arguments
trade_num(série int) Le numéro de transaction de la transaction clôturée.Voir aussi
strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades
Renvoie l'heure UNIX de l'entrée de la transaction close.
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")
Les arguments
trade_num(série int) Le numéro de transaction de la transaction clôturée.Voir aussi
strategy.opentrades.entry_time strategy.closedtrades.exit_time time
Retourne le bénéfice/perte de la transaction fermée.
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")
Les arguments
trade_num(série int) Le numéro de transaction de la transaction clôturée.Voir aussi
strategy.opentrades.profit strategy.closedtrades.commission
Retourne la direction et le nombre de contrats négociés dans la transaction fermée. Si la valeur est > 0, la position de marché était longue. Si la valeur est < 0, la position de marché était courte.
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")
Calculer le pourcentage de profit moyen sur les transactions conclues.
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)
Les arguments
trade_num(série int) Le numéro de transaction de la transaction clôturée.Voir aussi
strategy.opentrades.size strategy.position_size strategy.closedtrades strategy.opentrades
Renvoie l'heure UNIX de la sortie de la transaction fermé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")
Réouvrir les transactions fermées après X secondes.
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)
Les arguments
trade_num(série int) Le numéro de transaction de la transaction clôturée.Voir aussi
strategy.closedtrades.entry_time
Cette fonction peut être utilisée pour spécifier dans quelle direction du marché la fonction strategy.entry est autorisée à ouvrir des positions.
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)
Les arguments
value(Simple chaîne) La direction autorisée.strategy.direction.all, strategy.direction.long, strategy.direction.shortCette règle a pour objet de déterminer la taille maximale d'une position de marché.strategy.entry. La quantité d'entrée peut être réduite (le cas échéant) à un tel nombre de contrats/actions/lots/unités, de sorte que la taille totale de la position ne dépasse pas la valeur spécifiée dans
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
Les arguments
contracts(simple int/float) Un paramètre requis: nombre maximal de contrats/actions/lots/unités dans une position.Valeur absolue denumberestnumbersinumber>= 0, ou -number otherwise.
math.abs(number)
RetoursLa valeur absolue denumber.
La fonction acos renvoie l'arccosine (en radians) d'un nombre tel que cos ((acos(y)) = y pour y dans la plage [-1, 1].
math.acos(angle)
RetoursL'arc cosinus d'une valeur; l'angle retourné est dans la plage [0, Pi], ou na si y est en dehors de la plage [-1, 1].
Retourne une valeur pseudo-aléatoire. La fonction générera une séquence de valeurs différente pour chaque exécution de script. L'utilisation de la même valeur pour l'argument seed optionnel produira une séquence répétable.
math.random(min, max, seed)
RetoursUne valeur aléatoire.
Les arguments
min(série int/float) La limite inférieure de la plage de valeurs aléatoires. La valeur n'est pas incluse dans la plage. La valeur par défaut est 0.max(série int/float) La limite supérieure de la plage de valeurs aléatoires. La valeur n'est pas incluse dans la plage. La valeur par défaut est 1.seed(input int) Argument facultatif. Lorsque la même graine est utilisée, permet d'appeler successivement la fonction pour produire un ensemble de valeurs répétables.La fonction asin renvoie l'arcsinus (en radians) d'un nombre tel que sin ((asin(y)) = y pour y dans la plage [-1, 1].
math.asin(angle)
RetoursL'arc-sinus d'une valeur; l'angle retourné est dans la plage [-Pi/2, Pi/2], ou na si y est en dehors de la plage [-1, 1].
La fonction atan renvoie l'arctangente (en radians) d'un nombre tel que tan ((atan ((y)) = y pour n'importe quel y.
math.atan(angle)
RetoursLa tangente d'arc d'une valeur; l'angle renvoyé est dans la plage [-Pi/2, Pi/2].
La fonction plafond renvoie le plus petit (le plus proche de l'infini négatif) entier supérieur ou égal à l'argument.
math.ceil(number)
RetoursLe plus petit entier inférieur ou égal au nombre donné.
Voir aussi
math.floor math.round
La fonction cos renvoie le cosinus trigonométrique d'un angle.
math.cos(angle)
RetoursLe cosinus trigonométrique d'un angle.
Les arguments
angle(série int/float) Angle, en radians.La fonction exp denumberest élevé à la puissance denumber, où e est le nombre d'Euler.
math.exp(number)
RetoursUne valeur représentant e élevée à la puissancenumber.
Voir aussi
math.pow
math.floor(number)
RetoursLe plus grand entier inférieur ou égal au nombre donné.
Voir aussi
math.ceil math.round
Logarithme naturel de n'importe quelnumber> 0 est le y unique tel que e^y =number.
math.log(number)
RetoursLe logarithme naturelnumber.
Voir aussi
math.log10
Le logarithme commun (ou base 10) denumberest la puissance à laquelle 10 doit être soulevé pour obtenir lenumber. 10^y est égalnumber.
math.log10(number)
RetoursLe logarithme en base 10 denumber.
Voir aussi
math.log
Fonction de puissance mathématique.
math.pow(base, exponent)
Exemple
// math.pow
plot(math.pow(close, 2))
Retours
baseélevé au pouvoir deexponentSi.baseest une série, elle est calculée par éléments.
Les arguments
base(série int/float) Spécifier la base à utiliser.exponent(série int/float) spécifie l'exposant.Voir aussi
math.sqrt math.exp
Le signe (signum) de
math.sign(number)
RetoursLe signe de la dispute.
La fonction sin renvoie le sinus trigonométrique d'un angle.
math.sin(angle)
RetoursLe sinus trigonométrique d'un angle.
Les arguments
angle(série int/float) Angle, en radians.La racine carrée de n'importe quellenumber>= 0 est l'unique y >= 0 tel que y^2 =number.
math.sqrt(number)
RetoursLa racine carrée denumber.
Voir aussi
math.pow
La fonction tan renvoie la tangente trigonométrique d'un angle.
math.tan(angle)
RetoursLa tangente trigonométrique d'un angle.
Les arguments
angle(série int/float) Angle, en radians.Renvoie la valeur denumberL'équation est arrondie à l'entier le plus proche, avec les liaisons arrondie vers le haut.precisionParamètre utilisé, renvoie une valeur flottante arrondie à ce nombre de décimales.
math.round(number)
math.round(number, precision)
RetoursLa valeur denumberarrondis au nombre entier le plus proche, ou selon la précision.
Les arguments
number(série int/float) La valeur à arrondir.precision(série int) Argument facultatif.numberLorsqu'aucun argument n'est fourni, l'arrondissement est au nombre entier le plus proche.Les commentairesNotez que pour les valeurs
Voir aussi
math.ceil math.floor
Renvoie la plus grande des valeurs multiples.
math.max(number0, number1, ...)
Exemple
// math.max
plot(math.max(close, open))
plot(math.max(close, math.max(open, 42)))
RetoursLa plus grande des valeurs multiples données.
Voir aussi
math.min
Renvoie la plus petite des valeurs multiples.
math.min(number0, number1, ...)
Exemple
// math.min
plot(math.min(close, open))
plot(math.min(close, math.min(open, 42)))
RetoursLa plus petite des valeurs multiples données.
Voir aussi
math.max
Calcule la moyenne de toutes les séries données (par éléments).
math.avg(number0, number1, ...)
Retours Average.
Voir aussi
math.sum ta.cum ta.sma
Renvoie la valeur arrondie au mintick du symbole
math.round_to_mintick(number)
RetoursLenumberarrondie à la précision de la marque.
Les arguments
number(série int/float) La valeur à arrondir.Voir aussi
math.ceil math.floor
La fonction somme renvoie la somme mobile des dernières valeurs y de x.
math.sum(source, length)
RetoursSomme desourcepourlengthRetournez les barreaux.
Les arguments
source(série int/float) Série de valeurs à traiter.length(série int) Nombre de barres (longueur).Voir aussi
ta.cum for
Retourne un angle équivalent approximatif en degrés d'un angle mesuré en radians.
math.todegrees(radians)
RetoursLa valeur de l'angle en degrés.
Les arguments
radians(série int/float) Angle en radians.Renvoie un angle équivalent approximatif en radians d'un angle mesuré en degrés.
math.toradians(degrees)
RetoursLa valeur de l'angle en radians.
Les arguments
degrees(série int/float) Angle en degrés.Pour une série donnée, remplace les valeurs NaN par la valeur non NaN la plus proche précédente.
fixnan(source)
RetoursUne série sans lacunes.
Les arguments
source(série int/float/bool/color)Voir aussi
na nz
Remplace les valeurs NaN par des zéros (ou une valeur donnée) dans une série.
nz(source, replacement)
nz(source)
Exemple
// nz
plot(nz(ta.sma(close, 100)))
RetoursLa valeur desourcesi ce n'est pas le casna. Si la valeur desourceestna, renvoie zéro, ou lereplacementl'argument lorsqu'on en utilise un.
Les arguments
source(série int/float/bool/color) Série de valeurs à traiter.replacement(série int/float/bool/color) Valeur qui remplacera toutes les valeurs source series.Voir aussi
na fixnan
Valeur d'essai si elle est un NaN.
na(x)
Retoursvrai si x n'est pas un nombre valide (x est NaN), sinon faux.
Voir aussi
fixnan nz
Il casse la valeur de flottabilité à int.
int(x)
RetoursLa valeur de l'argument après le lancement à int.
Voir aussi
float bool color string
Il ne peut pas flotter.
float(x)
RetoursLa valeur de l'argument après le lancement à flot.
Voir aussi
int bool color string
Déclenche un événement d'alerte lorsqu'il est appelé pendant la barre en temps réel et une alerte basée sur les événements de la fonction d'alerte a été précédemment créée pour l'indicateur ou la stratégie via la boîte de dialogue
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)
Les arguments
messageMessage envoyé lorsque l'alerte est déclenchée.freq(chaîne d'entrée) La fréquence de déclenchement. Les valeurs possibles sont: alert.freq_all (tous les appels de fonction déclenchent l'alerte), alert.freq_once_per_bar (le premier appel de fonction pendant la barre déclenche l'alerte), alert.freq_once_per_bar_close (l'appel de fonction déclenche l'alerte uniquement lorsqu'il se produit lors de la dernière itération de script de la barre en temps réel, lorsqu'elle se ferme).Les commentairesLe Centre d'aide explique comment créer de telles alertes.
Contrairement à la condition d'alerte, les appels d'alerte ne sont PAS considérés comme un graphique supplémentaire.
Les appels de fonctions peuvent être localisés dans des environnements globaux et locaux.
Les appels de fonction n'affichent rien sur le graphique.
L'argument
Voir aussi
alertcondition
Créer une condition d'alerte, qui est disponible dans la boîte de dialogue Créer une alerte. Veuillez noter que cette condition d'alerte ne crée PAS une alerte, elle vous donne simplement plus d'options dans la boîte de dialogue Créer une alerte.
alertcondition(condition, title, message)
Exemple
// alertcondition
alertcondition(close >= open, title='Alert on Green Bar', message='Green Bar!')
Les arguments
condition(série bool) Série de valeurs booléennes utilisées pour l'alerte. valeurs vraies signifient feu d'alerte, faux - aucune alerte. argument requis.titleTitre de la condition d'alerte. Argument facultatif.messageMessage à afficher lorsque l'alerte se déclenche.Les commentairesVeuillez noter que dans Pine Script v4/v5, un appel à condition d'alerte génère un graphique supplémentaire. Tous ces appels sont pris en compte lors du calcul du nombre de séries de sortie par script.
Voir aussi
alert
Pour être compatibles avec leTrading Viewcode de stratégie, il n'est pas nécessaire de l'appeler.
Voir aussi
strategy
La fonction temps renvoie l'heure UNIX de la barre actuelle pour la période de temps et la session spécifiée ou NaN si le point de temps est hors session.session arguments.
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"))
Lors de la configuration d'une session, vous pouvez spécifier non seulement les heures et les minutes, mais aussi les jours de la semaine qui seront inclus dans cette session.
Si les jours ne sont pas précisés, la session est considérée comme ayant été fixée du dimanche (1) au samedi (7), c'est-à-dire
Exemple
// Time
t1 = time(timeframe.period, "0000-0000:23456")
bgcolor(t1 ? color.new(color.blue, 90) : na)
Une.sessionPar exemple, le script suivant mettra en évidence les barres de 10h00 à 11h00 et de 14h00 à 15h00 (uniquement les jours ouvrables):
Exemple
// Time
t1 = time(timeframe.period, "1000-1100,1400-1500:23456")
bgcolor(t1 ? color.new(color.blue, 90) : na)
RetoursÀ l'heure UNIX.
Les arguments
timeframeUne chaîne vide est interprétée comme la période actuelle du graphique.sessiontimezone(simple chaîne) Fuseau horaire dusessionIl peut être utilisé uniquement lorsqu'une Les commentairesLe temps UNIX est le nombre de millisecondes écoulées depuis 00:00:00 UTC, le 1er janvier 1970.
year(time)
year(time, timezone)
RetoursAnnée (en fuseau horaire d'échange) pour l'heure UNIX fournie.
Les arguments
time(série int) Temps UNIX en millisecondes.timezoneUn argument facultatif, le fuseau horaire.Les référencesL'heure UNIX est le nombre de millisecondes écoulées depuis 00:00:00 UTC, le 1er janvier 1970. Notez que cette fonction renvoie l'année en fonction de l'heure à laquelle les barres sont ouvertes. Pour les sessions du jour au lendemain (par exemple EURUSD, où la session du lundi commence le dimanche, 17:00 UTC-4), cette valeur peut être inférieure de 1 à l'année du jour de négociation.
Voir aussi
year time month dayofmonth dayofweek hour minute second
month(time)
month(time, timezone)
RetoursMois (en fuseau horaire d'échange) pour l'heure UNIX fournie.
Les arguments
time(série int) Temps UNIX en millisecondes.timezoneUn argument facultatif, le fuseau horaire.Les commentairesL'heure UNIX est le nombre de millisecondes écoulées depuis 00:00:00 UTC, le 1er janvier 1970. Notez que cette fonction renvoie le mois en fonction de l'heure à laquelle les barres sont ouvertes. Pour les sessions du jour au lendemain (par exemple EURUSD, où la session du lundi commence le dimanche, 17h00 UTC-4), cette valeur peut être inférieure de 1 au mois du jour de négociation.
Voir aussi
month time year dayofmonth dayofweek hour minute second
hour(time)
hour(time, timezone)
RetoursHeure (dans le fuseau horaire d'échange) pour l'heure UNIX fournie.
Les arguments
time(série int) Temps UNIX en millisecondes.timezoneUn paramètre optionnel, fuseau horaire.Les commentairesL'heure UNIX est le nombre de millisecondes qui se sont écoulées depuis 00:00:00 UTC, le 1er janvier 1970.
Voir aussi
hour time year month dayofmonth dayofweek minute second
minute(time)
minute(time, timezone)
RetoursMinute (en fuseau horaire d'échange) pour l'heure UNIX fournie.
Les arguments
time(série int) Temps UNIX en millisecondes.timezoneUn argument facultatif, le fuseau horaire.Les commentairesL'heure UNIX est le nombre de millisecondes qui se sont écoulées depuis 00:00:00 UTC, le 1er janvier 1970.
Voir aussi
minute time year month dayofmonth dayofweek hour second
second(time)
second(time, timezone)
RetoursDeuxième (en fuseau horaire d'échange) pour l'heure UNIX fournie.
Les arguments
time(série int) Temps UNIX en millisecondes.timezoneUn paramètre optionnel, fuseau horaire.Les commentairesL'heure UNIX est le nombre de millisecondes qui se sont écoulées depuis 00:00:00 UTC, le 1er janvier 1970.
Voir aussi
second time year month dayofmonth dayofweek hour minute
weekofyear(time)
weekofyear(time, timezone)
RetoursSemaine de l'année (en fuseau horaire d'échange) pour l'heure UNIX fournie.
Les arguments
time(série int) Temps UNIX en millisecondes.timezoneUn paramètre optionnel, fuseau horaire.Les commentairesL'heure UNIX est le nombre de millisecondes écoulées depuis 00:00:00 UTC, le 1er janvier 1970. Notez que cette fonction renvoie la semaine en fonction de l'heure à laquelle les barres sont ouvertes. Pour les sessions du jour au lendemain (par exemple EURUSD, où la session du lundi commence le dimanche, 17h00) cette valeur peut être inférieure de 1 à la semaine du jour de négociation.
Voir aussi
weekofyear time year month dayofmonth dayofweek hour minute second
dayofweek(time)
dayofweek(time, timezone)
RetoursJour de la semaine (en fuseau horaire d'échange) pour l'heure UNIX fournie.
Les arguments
time(série int) Temps UNIX en millisecondes.timezoneUn paramètre optionnel, fuseau horaire.Les commentairesNotez que cette fonction renvoie le jour en fonction de l'heure à laquelle les barres sont ouvertes. Pour les sessions du jour au lendemain (par exemple EURUSD, où la session du lundi commence le dimanche 17h00) cette valeur peut être inférieure de 1 au jour du jour de négociation. L'heure UNIX est le nombre de millisecondes écoulées depuis 00:00:00 UTC, le 1er janvier 1970.
Voir aussi
time dayofmonth
dayofmonth(time)
dayofmonth(time, timezone)
RetoursJour du mois (dans le fuseau horaire d'échange) pour l'heure UNIX fournie.
Les arguments
time(série int) temps unix en millisecondes.timezoneUn paramètre optionnel, fuseau horaire.Les commentairesL'heure UNIX est le nombre de millisecondes écoulées depuis 00:00:00 UTC, le 1er janvier 1970. Notez que cette fonction renvoie le jour en fonction de l'heure à laquelle les barres sont ouvertes. Pour les sessions du jour au lendemain (par exemple EURUSD, où la session du lundi commence le dimanche, 17h00 UTC-4), cette valeur peut être inférieure de 1 au jour du jour de négociation.
Voir aussi
time dayofweek
La fonction timestamp renvoie l'heure UNIX de la date et de l'heure spécifiées.
timestamp(dateString)
timestamp(year, month, day, hour, minute, second)
timestamp(timezone, year, month, day, hour, minute, second)
Exemple
// timestamp
plot(timestamp(2016, 01, 19, 09, 30), linewidth=3, color=color.green)
plot(timestamp(syminfo.timezone, 2016, 01, 19, 09, 30), color=color.blue)
plot(timestamp(2016, 01, 19, 09, 30), color=color.yellow)
plot(timestamp("GMT+6", 2016, 01, 19, 09, 30))
plot(timestamp(2019, 06, 19, 09, 30, 15), color=color.lime)
plot(timestamp("GMT+3", 2019, 06, 19, 09, 30, 15), color=color.fuchsia)
plot(timestamp("Feb 01 2020 22:10:05"))
plot(timestamp("2011-10-10T14:48:00"))
Les mendiantsPourquoi les stratégies de la place de la réplique de la stratégie de Pine ne peuvent pas être mises en œuvre
L'inventeur de la quantification - un petit rêveBien, nous allons vérifier.
Les mendiantsLe Traqueur de tendances optimisé de Zhang
L'inventeur de la quantification - un petit rêveBonjour, quelle est la stratégie spécifique?