FMZ PINE Script est un fichier

Retourne la valeurLe nombre moyen d'éléments d'une matrice.

Paramètres

• id(int[]/float[]) Objets de l'arrayé.

À bientôt array.avg array.variance array.min

array.mode

Cette fonction renvoie le modèle d'un élément d'une matrice. Si plusieurs valeurs ont la même fréquence, elle renvoie la valeur minimale.

array.mode(id)

Exemples

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

Retourne la valeurLe modèle des éléments d'une matrice.

Paramètres

• id(int[]/float[]) Objets de l'arrayé.

À bientôt array.new_float array.avg array.variance array.min

Le nombre de fois où la valeur est supérieure ou égale à

Retourne le pourcentage spécifié d'une valeur d'une matrice inférieure ou égale à sa valeur, en utilisant une insertion linéaire.

array.percentile_linear_interpolation(id, percentage) 

Paramètres

• id(int[]/float[]) Objets de l'arrayé.
• percentage(series int/float) doit être égal ou inférieur au pourcentage de la valeur retournée.

Nom de l'auteurDans les statistiques, le pourcentage est le pourcentage d'articles de classement qui apparaissent à un certain score ou en dessous d'un certain score. Cette mesure indique le pourcentage de points dans la distribution de fréquences standard inférieure au score que vous mesurez.

À bientôt array.new_float array.insert array.slice array.reverse order.ascending order.descending

Le nombre d'annonces est calculé en fonction du nombre d'annonces reçues.

Retourne la valeur de l'ensemble des pourcentages spécifiés (pourcentages) inférieure ou égale à celle-ci en utilisant la méthode de classement le plus récent.

array.percentile_nearest_rank(id, percentage) 

Paramètres

• id(int[]/float[]) Objets de l'arrayé.
• percentage(series int/float) doit être égal ou inférieur au pourcentage de la valeur retournée.

Nom de l'auteurDans les statistiques, le pourcentage est le pourcentage d'articles de classement qui apparaissent à un certain score ou en dessous d'un certain score. Cette mesure indique le pourcentage de fractions dans la distribution de fréquence standard inférieure au score que vous mesurez.

À bientôt array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.percentrank

Retourne le classement en pourcentage de la moyenne d'une matrice.

array.percentrank(id, index) 

Paramètres

• id(int[]/float[]) Objets de l'arrayé.
• index(series int) calcule la valeur de sa position en pourcentage.

Nom de l'auteurLe classement en pourcentage est le pourcentage du nombre d'éléments de l'arrayé inférieur ou égal à la valeur de référence.

À bientôt array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.range

Cette fonction renvoie la différence entre la valeur minimale et la valeur maximale de l'arithmétique donnée.

array.range(id) 

Exemples

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

Retourne la valeurDifférence entre la valeur minimale et la valeur maximale d'un ensemble.

Paramètres

• id(int[]/float[]) Objets de l'arrayé.

À bientôt array.new_float array.min array.max array.sum

array.remove

Cette fonction modifie le contenu de l'array en supprimant l'élément avec l'index spécifié.

array.remove(id, index)

Exemples

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

Retourne la valeurLa valeur de l'élément est supprimée.

Paramètres

• id(any array type) Objet de l'array.
• index(series int) l'index des éléments à supprimer.

À bientôt array.new_float array.set array.push array.insert array.pop array.shift

array.reverse

Cette fonction inverse l'ordre. Le premier élément devient le dernier, et le dernier devient le premier.

array.reverse(id)

Exemples

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

Paramètres

• id(any array type) Objet de l'array.

À bientôt array.new_float array.sort array.push array.set array.avg

array.from

Cette fonction utilise un nombre variable de paramètres de l'un des types suivants: int, float, boolean, string, line, color, linefill, et renvoie une rangée de type correspondant.

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

Exemples

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

Retourne la valeurLa valeur de l'élément d'une matrice.

Paramètres

• arg0, arg1, ...(series int/float/bool/color/string/line/linefill) Paramètres de série.

array.new

Cette fonction crée un nouveau<type>L'élément est un objet de l'arithmétique.

array.new(size, initial_value)

Exemples

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

Exemples

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

Exemples

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

Exemples

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres

• sizeLa taille initiale de la série (series int) ⇒ est facultative. La valeur par défaut est 0.
• initial_value(series ) La valeur initiale de tous les éléments de la série↑ est optionnelle↑ la valeur par défaut est na↑

Nom de l'auteurL'index de la matrice commence à 0. Si vous souhaitez initialement initialer une matrice et spécifier tous ses éléments en même temps, utilisez la fonction array.from.

À bientôt array.from array.push array.get array.size array.remove array.shift array.sum

- Je ne sais pas.

Cette fonction crée un nouvel objet d'array composé d'éléments de type bool.

array.new_bool(size, initial_value)

Exemples

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres

• sizeLa taille initiale de la série (series int) ⇒ est facultative. La valeur par défaut est 0.
• initial_value(series bool) La valeur initiale de tous les éléments de la série↑ Optionnelle↑ La valeur par défaut est na↑

Nom de l'auteurL'index d'une matrice commence à zéro.

À bientôt array.new_float array.get array.slice array.sort

Le nombre de fois où l'on utilise

Cette fonction crée un nouvel objet d'une matrice d'éléments flottants.

array.new_float(size, initial_value)

Exemples

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres

• sizeLa taille initiale de la série (series int) ⇒ est facultative. La valeur par défaut est 0.
• initial_value(series int/float) La valeur initiale de tous les éléments de la série. Optionnelle. La valeur par défaut est na.

Nom de l'auteurL'index d'une matrice commence à zéro.

À bientôt array.new_bool array.get array.slice array.sort

Le nombre de points

Cette fonction crée un nouvel objet d'array composé d'éléments de type int.

array.new_int(size, initial_value)

Exemples

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres

• sizeLa taille initiale de la série (series int) ⇒ est facultative. La valeur par défaut est 0.
• initial_value(series int) La valeur initiale de tous les éléments de la série↑ est optionnelle↑ la valeur par défaut est na↑

Nom de l'auteurL'index d'une matrice commence à zéro.

À bientôt array.new_float array.get array.slice array.sort

Array.new_string est en cours d'exécution

Cette fonction crée de nouveaux objets d'array avec un élément de type de chaîne.

array.new_string(size, initial_value)

Exemples

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres

• sizeLa taille initiale de la série (series int) ⇒ est facultative. La valeur par défaut est 0.
• initial_value(series string) La valeur initiale de tous les éléments de la série↑ est optionnelle↑ la valeur par défaut est na↑

Nom de l'auteurL'index d'une matrice commence à zéro.

À bientôt array.new_float array.get array.slice

array.get

Cette fonction renvoie la valeur de l'élément indiqué dans l'index.

array.get(id, index)

Exemples

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

Retourne la valeurLa valeur de l'élément d'une matrice.

Paramètres

• id(any array type) Objet de l'array.
• index(series int) est l'index de l'élément dont la valeur doit être renvoyée.

À bientôt array.new_float array.set array.slice array.sort

array.push

Cette fonction ajoute une valeur à l'array.

array.push(id, value)

Exemples

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

Paramètres

• id(any array type) Objet de l'array.
• value (series <type of the array's elements>) est ajoutée à la valeur de l'élément à la fin de l'arrangement.

À bientôt array.new_float array.set array.insert array.remove array.pop array.unshift

array.set

Cette fonction définit la valeur de l'élément comme l'index indiqué.

array.set(id, index, value) 

Exemples

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

Paramètres

• id(any array type) Objet de l'array.
• index(series int) modifier l'index de l'élément.
• value (series <type of the array's elements>) nouvelle valeur à définir.

À bientôt array.new_float array.get array.slice

array.sum

Cette fonction renvoie la somme des éléments d'une matrice.

array.sum(id) 

Exemples

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

Retourne la valeurLa somme des éléments d'une matrice.

Paramètres

• id(int[]/float[]) Objets de l'arrayé.

À bientôt array.new_float array.max array.min

array.avg

Cette fonction renvoie la moyenne des éléments d'une matrice.

array.avg(id)

Exemples

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

Retourne la valeurLes valeurs moyennes des éléments d'une matrice.

Paramètres

• id(int[]/float[]) Objets de l'arrayé.

À bientôt array.new_float array.max array.min array.stdev

array.indexof

Cette fonction renvoie l'index dans lequel la valeur est apparue pour la première fois. Si la valeur n'est pas trouvée, elle renvoie −1.

array.indexof(id, value)

Exemples

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

Retourne la valeurL'index de l'élément.

Paramètres

• id(any array type) Objet de l'array.
• value (series <type of the array's elements>La valeur à rechercher dans l'array.

À bientôt array.lastindexof array.get array.lastindexof array.remove array.insert

stratégie

DansstrategyDans les fonctions intégrées, le nombre de points de stop-loss, le nombre de points de stop-loss est défini comme le multiple d'un saut de prix; par exemple:strategy.exitLa fonctionprofit、lossParamètres avec des points indiquant le stop, le stop, les paramètresprofitS'il est défini à 10, c'est-à-dire qu'un saut de prix est multiplié par 10 comme différence de prix de stop-loss, le saut de prix est une variable intégréesyminfo.mintick。

stratégie

La fonction définit plusieurs attributs de stratégie. Attention, le partage est uniquement en soutien.title，shorttitle，overlay，pyramiding，default_qty_type，default_qty_valueParamètres, d'autres paramètres peuvent être réglés par les paramètres d'interface de la stratégie de la langue PINE.

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

Exemples

strategy("Strategy", overlay = true)

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

Paramètres

• title(const string) Le titre de l'indicateur que vous voyez dans le plugin indicateur / stratégie. Paramètres requis.
• shorttitle(const string) Le titre court de l'indicateur que vous voyez dans l'exemple du graphique.
• overlay(const bool) Si true, le paramètre est ajouté comme superposition de la série principale. Si false - il est ajouté dans une fenêtre de graphique séparée.
• format(const string) Les types de valeurs possibles pour les indicateurs de formatation sur l'axe de prix sont les suivants: format.inherit、format.price、format.volume、format.inherit par défaut。
• precision(const int) Le nombre de chiffres après le nombre de virgules de la valeur de l'indicateur sur l'axe des prix. Il doit être un entier non négatif et ne pas être supérieur à 16. Si c'est omis, le format de la série mère est utilisé. Si format est format.inherit et que ce paramètre est défini, format devient format.price.
• scale(scale_type) L'indicateur doit suivre les coordonnées de prix. Les valeurs possibles sont: scale.right, scale.left, scale.none.
• pyramiding(const int) Le nombre maximal d'entrées autorisées dans la même direction. Si cette valeur est 0, une seule entrée peut être ouverte dans la même direction, et toute autre entrée sera rejetée. La valeur par défaut est 0.
• calc_on_order_fills(const bool) calcul d'une commande intrabar supplémentaire. Si le paramètre est défini sur la commande true, la stratégie recalculera une fois que la ligne K est remplie après l'ordre (pas seulement à la fermeture de la ligne k).
• calc_on_every_tick(const bool) calcul de la stratégie intrabar supplémentaire. Si le paramètre est true, la stratégie calculera en temps réel chaque degré sans fermer la ligne k. Cette paramètre n'affecte pas le calcul de la stratégie sur les données historiques.
• max_bars_back(const int) Le nombre maximal de barres peut être utilisé pour la politique de référence historique. Si le code du script cite les données historiques de la variable (l'opérateur "barre []' est utilisé), ce paramètre est appliqué à chaque variable intégrée ou à chaque variable utilisateur du script. La taille de la zone de sauvegarde variable dans le script pine est généralement détectée automatiquement. Cependant, dans certains cas, cela est impossible, ce qui explique pourquoi le paramètre permet à l'utilisateur de définir manuellement la valeur inférieure.
• backtest_fill_limits_assumption(const int) L'hypothèse de l'exécution de l'offre limitée. L'offre limitée n'est traitée à l'intrabar que lorsque le prix du marché dépasse le nombre de ticks indiqué au niveau de l'offre limitée.
• default_qty_type(const string) est défini pourqtyLa valeur du paramètre est indiquée dans la fonction strategy.entry ou strategy.order. Les valeurs possibles sont: strategy.fixed indique le nombre de contrats/actions/manches, strategy.cash indique le montant de la monnaie, ou strategy.percent_of_equity indique le pourcentage d'intérêts disponibles.
• default_qty_value(const int/float) Le nombre de transactions par défaut de la fonction strategy.entry ou de la fonction strategy.order, dont l'unité est déterminée par le paramètre utilisé avec le paramètre default_qty_type lorsque leur paramètre qty n'est pas défini.
• currency(const string) La monnaie de compte de cette stratégie. Optionnelle. La valeur par défaut est la monnaie du produit figurant sur le graphique. Les valeurs possibles sont: currency.NONE, currency.USD, currency.EUR, currency.AUD, currency.GBP, currency.NZD, currency.CAD, currency.CHF, currency.HKD, currency.JPY, currency.NOK, currency.SEK, currency.SGD, currency.TRY, currency.ZAR, currency.BTC, currency.ETH, currency.MYR, currency.KRW.
• slippage(const int) avec tick comme unité de soumission, le slitt est ajouté/soustrait du prix de transaction d'un ordre de vente/achat ou d'un ordre de stop-loss. Si mintick = 0.01 et le slitt = 5, le total des slitt sera 5 * 0.01 = 0.05.
• commission_type(const string) Type de commission pour chaque commande. Les valeurs autorisées sont: stratégie.commission.percent (pourcentage de la quantité de cash de l'ordre), stratégie.commission.cash_per_contract (pour chaque contrat, le montant est indiqué dans la monnaie du compte), stratégie.commission.cash_per_order (pour chaque commande, le montant est indiqué dans la monnaie du compte).
• commission_value(const int/float) valeur de la commission d'une commande; selon le type choisi (commission type) inclure un pourcentage ou un montant;
• process_orders_on_close(const bool) est réglé sur la barre de configuration pour générer d'autres tentatives d'exécution des ordres après la clôture du graphique et la fin du calcul de la stratégie. Si les ordres sont des ordres au prix du marché, l'émulateur du courtier les exécute avant l'ouverture du prochain graphique. Si les ordres sont des prix limités, les ordres ne sont exécutés que lorsque les conditions de prix sont remplies.
• close_entries_rule(const string) Définit l'ordre de clôture de l'ordre. La valeur autorisée est: FIFO ou ANY. FIFO signifie que la première transaction doit être clôturée lorsque plusieurs transactions sont ouvertes. Cette règle s'applique aux actions, aux contrats à terme et aux devises américaines (règles de conformité NFA 2-43b).
• max_lines_count(const int) affiche le nombre de lignes de caractères récentes. La valeur par défaut est 50, la valeur maximale autorisée est 500.
• max_labels_count(const int) affiche le nombre de tableaux de balises les plus récents. La valeur par défaut est 50, la valeur maximale autorisée est 500.
• max_boxes_count(const int) Le nombre de tableaux de la dernière boîte affichée. La valeur par défaut est 50, la valeur maximale autorisée est 500.
• margin_long(const int/float) Le taux de couverture multi-tête est le pourcentage du prix d'achat d'un titre qui doit être couvert par de l'argent ou des garanties. Il doit être non négatif.
• margin_short(const int/float) Le taux de change est le pourcentage du prix d'achat d'un titre qui doit être couvert par de l'argent ou des garanties. Il doit être non négatif.
• explicit_plot_zorder(const bool) spécifie l'ordre de représentation des indices, de leur remplissage et de leur ligne horizontale. Si true, le tableau est dessiné dans l'ordre dans lequel ils apparaissent dans le code de l'indicateur, chaque nouveau graphique étant dessiné sur le graphique précédent.
• initial_capital(const int/float) Le montant d'argent utilisé pour la transaction stratégique est initialement indiqué par la devise définie dans la pile de devises de la console. Optionnel. La valeur par défaut est 1000000.
• risk_free_rate(const int/float) Le taux de rendement sans risque est la variation annuelle en pourcentage de la valeur d'un investissement au risque minimal ou nul, utilisée pour calculer les ratios Sharpe et Sortino.

Nom de l'auteurChaque script de stratégie doit avoir une stratégie appelée. Le code PineScript qui utilise le paramètre calc_on_every_tick = true peut effectuer des calculs différents sur les enregistrements historiques et les données en temps réel. Lorsque vous utilisez un graphique de type non standard comme base de stratégie, vous devez savoir que les résultats seront différents. Les commandes seront exécutées au prix de ce tableau (par exemple, pour Heikin Ashi, le prix de Heikin Ashi sera utilisé (la moyenne n'est pas le vrai prix du marché). Nous vous recommandons donc fortement d'utiliser le type de graphique standard dans votre stratégie.

À bientôt indicator

strategy.entry

C'est une commande d'entrée de marché. Une commande peut être modifiée si une commande avec le même ID est déjà accrochée. Une nouvelle commande peut être envoyée si une commande sans ID est spécifiée. Pour annuler une commande d'entrée, vous devez utiliser la commande stratégie.cancel ou stratégie.cancel_all. Comparativement à la fonction stratégie.order, la fonction stratégie.entry est influencée par la pyramide et peut inverser correctement la position du marché.

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

Exemples

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

Paramètres

• id(series string) Paramètres requis. L'identifiant de la commande. On peut annuler ou modifier une commande en citant son identifiant.
• direction(strategy_direction) Un paramètre nécessaire. Direction de l'action sur le marché: "strategy.long" pour le multi-tête, "strategy.short" pour le vide.
• qty(series int/float) paramètres optionnels↑ nombre de contrats/actions/points de vente/unités négociés↑ valeur par défaut: NaN↑
• limit(series int/float) paramètre sélectionnable. Le prix limite de l'ordre. Le type d'ordre est "limit" ou "stop-limit" s'il est spécifié.
• stop(series int/float) paramètre sélectionnable↑ prix de stop-loss de l'ordre↑ type d'ordre "stop" ou "stop-limit" s'il est spécifié↑ autre type d'ordre "NaN"↑
• oca_name(series string) Optionnelle. Cette commande appartient au nom du groupe OCA. Si l'ordre ne appartient à aucun groupe OCA, il devrait y avoir un caractère vide.Attention: FMZ ne prend pas en charge ce paramètre.
• oca_type(input string) Optionnelle; type de groupe d'ordres OCA. La valeur autorisée est: strategy.oca.none - l'ordre ne doit pas appartenir à un groupe OCA spécifique; strategy.oca.cancel - l'ordre doit appartenir au groupe OCA et tous les autres ordres du même groupe seront annulés une fois que l'ordre est passé; strategy.oca.reduce - l'ordre doit appartenir au groupe OCA, si X de contrats d'ordres ont été placés, le nombre d'autres ordres du même groupe OCA diminue X.Attention: FMZ ne prend pas en charge ce paramètre.
• comment(series string) Paramètres sélectifs.
• when(series bool) paramètre sélectionnable. Status de l'ordre. Si "true", l'ordre est placé. Si "false", rien ne se passe.
• alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

strategy.close

Il s'agit d'une commande pour un ordre d'exit avec un ID spécifié. Si plusieurs ordres d'entrée ont le même ID, ils s'excluent tous en même temps. Si un ordre ouvert n'a pas d'ID spécifié au moment du déclenchement de la commande, la commande n'est pas exécutée.

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

Exemples

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ètres

• id(series string) Paramètres requis. L'identifiant de l'ordre. L'ordre peut être fermé en citant son identifiant.
• when(series bool) Paramètres sélectifs. Conditions de la commande.
• qty(series int/float) Paramètres optionnels. Nombre de contrats/nombre de parts/nombre de pièces/unités de sortie.
• qty_percent(series int/float) Définit le pourcentage de l'équilibre ((0-100)). Sa priorité est inférieure à la priorité de l'option qty. Optionnelle.
• comment(series string) Paramètres sélectifs.
• alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

stratégie.close_all

Le gouvernement a décidé de retirer ses positions actuelles du marché pour les maintenir à plat.

strategy.close_all(when, comment, alert_message) 

Exemples

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ètres

• when(series bool) Paramètres sélectifs. Conditions de la commande.
• comment(series string) Paramètres sélectifs.
• alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

strategy.exit

Il s'agit d'une commande d'exit qui spécifie une entrée ou une position de marché complète. Une commande peut être modifiée si une commande avec le même ID est déjà suspendue. Si une commande d'entrée n'est pas passée, mais qu'une commande de retrait apparaît, l'ordre de retrait est suspendu jusqu'à ce que la personne après la commande d'entrée puisse placer une commande de retrait. Pour arrêter une commande de retrait, vous devez utiliser la commande strategy.cancel ou strategy.cancel_all. Si la fonction strategy.exit est appelée une seule fois, elle ne sera retirée qu'une seule fois.应该多次调用命令strategy.exitSi vous utilisez des stop-loss et des stop-loss de suivi, dont le type d'ordre est le stop-loss, seul l'un d'entre eux sera placé (il sera transait en premier). Si tous les paramètres suivants sont les suivants: stop-profit, stop-limit, stop-loss, stop-trail, stop-trail_points, stop-trail_offset, l'ordre échouera.

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

Exemples

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ètres

• id(series string) Paramètres requis. L'identifiant de la commande. On peut annuler ou modifier une commande en citant son identifiant.
• from_entry(series string) Paramètre sélectionnable↑ pour spécifier l'identifiant d'entrée d'instruction Exit↑ pour exiter tous les positions, une chaîne vide doit être utilisée↑ par défaut une chaîne vide↑
• qty(series int/float) Paramètres optionnels. Nombre de contrats/nombre de parts/nombre de pièces/unités de sortie.
• qty_percent(series int/float) Définit le pourcentage de l'équilibre ((0-100)). Sa priorité est inférieure à la priorité de l'option qty. Optionnelle.
• profit(series int/float) paramètre sélectionnable♦ objectif de profit (indiqué par un point)♦ si spécifié, quittez le marché avec un ordre de prix limité lorsque le point de profit spécifié est atteint♦ valeur par défaut NaN♦
• limit(series int/float) paramètre sélectionnable. Objectif de profit (prix à spécifier). Si c'est le cas, sortez du marché au prix (ou mieux) indiqué. La priorité du paramètre est supérieure à celle du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre.
• loss(series int/float) paramètre sélectionnable↑ Stop-loss (indiqué par un point)↑ Si spécifié, quittez le marché en un seul stop-loss lorsque le point de perte spécifié est atteint↑ Par défaut, le prix est NaN↑
• stop(series int/float) Paramètres optionnels. Arrêt de perte (prix à spécifier). Si c'est le cas, la position sera retirée du marché au prix indiqué (ou pire). La priorité du paramètre arrêt de perte est supérieure à celle du paramètre arrêt de perte (priorité du paramètre arrêt de perte).
• trail_price(series int/float) Optionnelle. Paramètre d'activation des niveaux d'arrêt de suivi (prix requis). Si elle est spécifiée, l'ordre d'arrêt de suivi sera placé lorsque le niveau de prix spécifié est atteint. Paramètre d'affichage de la déviation utilisée pour déterminer le prix initial de l'ordre d'arrêt d'observation dans le paramètre d'affichage de la trajectoire_offset (en point): X point inférieur au niveau d'activation pour une sortie à plusieurs niveaux; X point supérieur au niveau d'activation pour une sortie à plusieurs niveaux.
• trail_points(series int/float) Paramètres optionnels. Niveau d'activation de stop-loss suivi (indiqué par des points de profit). Si spécifié, un ordre de stop-loss suivi sera placé lorsque le niveau de prix calculé (indiqué par un montant de profit) est atteint. Dans le paramètre de l'ordre de stop-loss suivi (indiqué par un compteur de points) dans le paramètre de l'ordre de stop-loss suivi (indiqué par un compteur de points): point X inférieur au niveau d'activation pour une sortie à plusieurs têtes; point X supérieur au niveau d'activation pour une sortie à vide.
• trail_offset(series int/float) Optionnelle. Niveau d'activation des stops de suivi (indiqué par des points). Le décalage en points est utilisé pour déterminer le prix initial de l'ordre de suivi des stops de suivi: X point inférieur à la barre de prix de la piste ou à la barre de points de piste pour une sortie multiple; X point supérieur à la barre de prix de la piste ou à la barre de points de piste pour une sortie vide.
• oca_name(series string) Paramètres optionnels. Nom du groupe OCA (oca_type = strategy.oca.reduce) Objectif de gain, stop/track stop. Si aucun nom n'est spécifié, ce nom est généré automatiquement.Attention: FMZ ne prend pas en charge ce paramètre.
• comment(series string) Paramètres sélectifs.
• when(series bool) paramètre sélectionnable. Status de l'ordre. Si "true", l'ordre est placé. Si "false", rien ne se passe.
• alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

strategy.cancel

Il s'agit d'une référence au nom pour annuler / désactiver toutes les commandes de liste de contrôle, générée par les fonctions suivantes: strategy.order, strategy.entry andstrategy.exit。

strategy.cancel(id, when) 

Exemples

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ètres

• id(series string) Paramètres à sélectionner.  Marque de commande.  Localiser cette marque pour annuler une commande.
• when(series bool) Optionnelle. Arrêter une commande en fonction de l'ID. Si "true", l'ordre est annulé.

stratégie.annuler_tout

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

strategy.cancel_all(when) 

Exemples

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ètres

• when(series bool) Optionnelle ⇒ annuler toutes les commandes ⇒ annuler toutes les commandes actives si la condition est vraie ⇒ valeur par défaut ⇒ true ⇒

strategy.order

C'est la commande de la commande suivante. Si une commande avec le même ID est déjà accrochée, vous pouvez modifier l'ordre. Si une commande sans ID est spécifiée, une nouvelle commande est envoyée. Pour arrêter l'ordre, vous devez utiliser la commande stratégie.cancel ou stratégie.cancel_all. Contrairement à la fonction stratégie.entry, la fonction stratégie.order n'est pas affectée par la forme de la pyramide.

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

Exemples

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ètres

• id(series string) Paramètres requis. L'identifiant de la commande. On peut annuler ou modifier une commande en citant son identifiant.
• direction(strategy_direction) Un paramètre nécessaire. Direction de l'ordre: stratégie.long est pour acheter, stratégie.short est pour vendre.
• qty(series int/float) paramètres optionnels↑ nombre de contrats/actions/points de vente/unités négociés↑ valeur par défaut: NaN↑
• limit(series int/float) paramètre sélectionnable. Le prix limite de l'ordre. Le type d'ordre est "limit" ou "stop-limit" s'il est spécifié.
• stop(series int/float) paramètre sélectionnable↑ prix de stop-loss de l'ordre↑ type d'ordre "stop" ou "stop-limit" s'il est spécifié↑ autre type d'ordre "NaN"↑
• oca_name(series string) Optionnelle. Cette commande appartient au nom du groupe OCA. Si l'ordre ne appartient à aucun groupe OCA, il devrait y avoir un caractère vide.Attention: FMZ ne prend pas en charge ce paramètre.
• oca_type(input string) Optionnelle; type de groupe d'ordres OCA. La valeur autorisée est: strategy.oca.none - l'ordre ne doit pas appartenir à un groupe OCA spécifique; strategy.oca.cancel - l'ordre doit appartenir au groupe OCA et tous les autres ordres du même groupe seront annulés une fois que l'ordre est passé; strategy.oca.reduce - l'ordre doit appartenir au groupe OCA, si X de contrats d'ordres ont été placés, le nombre d'autres ordres du même groupe OCA diminue X.Attention: FMZ ne prend pas en charge ce paramètre.
• comment(series string) Paramètres sélectifs.
• when(series bool) paramètre sélectionnable. Status de l'ordre. Si "true", l'ordre est placé. Si "false", rien ne se passe.
• alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

La stratégie.ouverture des marchés.entrée_bar_index

Retourne le bar_index pour une entrée de transaction qui n'a pas été levée.

strategy.opentrades.entry_bar_index(trade_num)

Attendre 10 lignes K et les aligner

Exemples

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ètres

• trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

stratégie.opentrades.entrée_id

Retournez l'ID de l'entrée pour les transactions qui ne sont pas liquidées.

strategy.opentrades.entry_id(trade_num)

Exemples

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 la valeurRetournez l'ID de l'entrée pour les transactions qui ne sont pas liquidées.

Paramètres

• trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

Nom de l'auteurSi trade_num n'est pas dans la plage, la fonction renvoie na:0 à strategy.opentrades−1.

À bientôt strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

stratégie.opentrades.prix d'entrée

Le prix d'entrée est retourné sur les transactions non liquidées.

strategy.opentrades.entry_price(trade_num)

Exemples

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 non équilibré

Exemples

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ètres

• trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt strategy.closedtrades.exit_price

stratégie.ouverture des opérations.heure d'entrée

Retourne l'heure d'entrée de la transaction sans solde sur UNIX.

strategy.opentrades.entry_time(trade_num)

Exemples

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ètres

• trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

Retournez les gains et les pertes sur les transactions non liquidées.

strategy.opentrades.profit(trade_num)

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

Exemples

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 les bénéfices de toutes les transactions qui n'ont pas été liquidées

Exemples

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ètres

• trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit

strategy.opentrades.size

Retourne la direction des transactions et le nombre de contrats dans une transaction qui n'est pas levée. Si cette valeur est supérieure à 0, la position sur le marché est à plusieurs têtes. Si cette valeur est inférieure à 0, la position sur le marché est à vide.

strategy.opentrades.size(trade_num)

Exemples

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 bénéfices moyens sur les transactions non liquidées

Exemples

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ètres

• trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

La valeur de l'échange est la valeur de l'échange.

Retourne le bar_index de la transaction qui a déjà été négociée.

strategy.closedtrades.entry_bar_index(trade_num)

Exemples

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ètres

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

À bientôt strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

La valeur de l'échange est calculée en fonction de la valeur de l'échange.

Le prix de sortie est retourné au prix de sortie d'une transaction qui a été liquidée.

strategy.closedtrades.exit_price(trade_num)

Exemples

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

Exemples

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ètres

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

À bientôt strategy.closedtrades.entry_price

La valeur de l'échange est la valeur de l'échange.

Retourne le bar_index qui a été retiré de la transaction.

strategy.closedtrades.exit_bar_index(trade_num)

Exemples

strategy("strategy.closedtrades.exit_bar_index Example 1")

// Strategy calls to place a single short trade. We enter the trade at the first bar and exit the trade at 10 bars before the last chart bar.
if bar_index == 0
    strategy.entry("Short",  strategy.short)
if bar_index == last_bar_index - 10
    strategy.close("Short")

// Calculate the amount of bars since the last closed trade.
barsSinceClosed = strategy.closedtrades > 0 ? bar_index - strategy.closedtrades.exit_bar_index(strategy.closedtrades - 1) : na

plot(barsSinceClosed, "Bars since last closed trade")

Calcule le nombre moyen de lignes K par transaction.

Exemples

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ètres

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

À bientôt bar_index

La valeur de l'échange est calculée en fonction de la valeur de l'échange.

Retourne l'id de l'entrée pour une transaction qui a été liquidée.

strategy.closedtrades.entry_id(trade_num)

Exemples

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 la valeurRetourne l'id de l'entrée pour une transaction qui a été liquidée.

Paramètres

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

Nom de l'auteurSi trade_num n'est pas dans la plage, la fonction renvoie na:0 à strategy.closedtrades−1.

À bientôt strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

Stratégie.transactions clôturées.prix d'entrée

Le prix d'entrée est retourné au prix d'entrée des transactions qui ont été liquidées.

strategy.closedtrades.entry_price(trade_num)

Exemples

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

Exemples

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ètres

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

À bientôt strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

La valeur de l'échange est calculée en fonction de la valeur de l'échange.

Retournez à l'heure de l'entrée de la transaction en liquidation de UNIX.

strategy.closedtrades.entry_time(trade_num)

Exemples

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ètres

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

À bientôt strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

Retournez les gains et les pertes des transactions qui ont été liquidées.

strategy.closedtrades.profit(trade_num)

Exemples

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ètres

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

À bientôt strategy.opentrades.profit strategy.closedtrades.commission

strategy.closedtrades.size

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

strategy.closedtrades.size(trade_num)

Exemples

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 en liquide

Exemples

strategy("`strategy.closedtrades.size` Example 2")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")


// Calculate profit for both closed trades.
profitPct = 0.0
for tradeNo = 0 to strategy.closedtrades - 1
    entryP = strategy.closedtrade

Plus de