FMZ PINE Script Dokumentation

Rückgabe von WertenDie Mittelzahl der Array-Elemente.

Parameter

• id(int[]/float[]) Arrayobjekte.

Bis dann array.avg array.variance array.min

array.mode

Die Funktion gibt den Modell des Array-Elements zurück. Wenn mehrere Werte mit der gleichen Frequenz vorhanden sind, gibt sie den Mindestwert zurück.

array.mode(id)

Beispiele

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

Rückgabe von WertenDas Modell der Array-Elemente.

Parameter

• id(int[]/float[]) Arrayobjekte.

Bis dann array.new_float array.avg array.variance array.min

Anschluss an die Datenbank

Die angegebene Prozentsatz (Prozentsatz) eines Arraywerts, der kleiner als oder gleich seinem Wert ist, wird mit einem linearen Intagel zurückgegeben.

array.percentile_linear_interpolation(id, percentage) 

Parameter

• id(int[]/float[]) Arrayobjekte.
• percentage(series int/float) muss der Prozentsatz des Wertes sein, der gleich oder kleiner als der zurückgegebene Wert ist.

AnmerkungenIn Statistiken ist ein Prozentanteil der Rangliste, die in einem bestimmten Punkt oder unter einem bestimmten Punkt erscheint. Diese Messung zeigt den Anteil der Punkte in Prozent an der Standardfrequenzverteilung, die unterhalb der von Ihnen gemessenen Prozentstufe liegt.

Bis dann array.new_float array.insert array.slice array.reverse order.ascending order.descending

Anschluss an die Angabe der Angabe

Mit der kürzesten Reihenfolge-Methode wird ein Arraywert (Prozentsatz) für die angegebene Prozentzahl zurückgegeben, der kleiner als oder gleich ihrem Wert ist.

array.percentile_nearest_rank(id, percentage) 

Parameter

• id(int[]/float[]) Arrayobjekte.
• percentage(series int/float) muss der Prozentsatz des Wertes sein, der gleich oder kleiner als der zurückgegebene Wert ist.

AnmerkungenIn Statistiken ist ein Prozentsatz das Prozentsatz der Ranglisten, die in einer bestimmten Punktzahl oder unter einer bestimmten Punktzahl erscheinen. Diese Messung zeigt den Prozentsatz der Anteile in der Standardfrequenzverteilung der von Ihnen gemessenen Prozentzahl an, die niedriger ist als die gewünschte Punktzahl.

Bis dann array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.percentrank

Das Ergebnis ist die Anzahl der Arrays, in denen die Arrays mitteln.

array.percentrank(id, index) 

Parameter

• id(int[]/float[]) Arrayobjekte.
• index(series int) berechnet den Wert ihrer Prozentzahl.

AnmerkungenDie Perzentualstufe ist die Prozentzahl der Elemente, die weniger als oder gleich dem Referenzwert sind.

Bis dann array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.range

Die Funktion gibt die Differenz zwischen dem Mindestwert und dem Maximum der gegebenen Array zurück.

array.range(id) 

Beispiele

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

Rückgabe von WertenDie Differenz zwischen dem Minimum und dem Maximum der Arrays.

Parameter

• id(int[]/float[]) Arrayobjekte.

Bis dann array.new_float array.min array.max array.sum

array.remove

Die Funktion ändert den Inhalt des Arrays, indem sie Elemente entfernt, die einen bestimmten Index haben.

array.remove(id, index)

Beispiele

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

Rückgabe von WertenDer Wert des entfernten Elements.

Parameter

• id(any array type) Array-Objekte.
• index(series int) Index der zu löschenden Elemente.

Bis dann array.new_float array.set array.push array.insert array.pop array.shift

array.reverse

Die Funktion umkehrt die Array. Das erste Element wird zum letzten und das letzte Element zum ersten.

array.reverse(id)

Beispiele

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

Parameter

• id(any array type) Array-Objekte.

Bis dann array.new_float array.sort array.push array.set array.avg

array.from

Die Funktion verwendet eine Anzahl von Variablen von einem der folgenden Typen: int, float, boole, string, line, color, linefill und gibt eine Array des entsprechenden Typs zurück.

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

Beispiele

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

Rückgabe von WertenDie Werte der Elemente der Array.

Parameter

• arg0, arg1, ...(series int/float/bool/color/string/line/linefill) Arrayparameter;

array.new

Die Funktion erstellt eine neue<type>Elementar-Array-Objekte.

array.new(size, initial_value)

Beispiele

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

Beispiele

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

Beispiele

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

Beispiele

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter

• sizeDie ursprüngliche Größe der (series int) Serie↑ Optional↑ Default 0↑
• initial_value(series ) Der Anfangswert für alle Sequenzelemente↑ Optional↑ Der Standardwert ist na↑

AnmerkungenDie Arrayindex beginnen bei 0. Wenn Sie ein Array einlösen und alle Elemente gleichzeitig angeben möchten, verwenden Sie die Funktion array.from.

Bis dann array.from array.push array.get array.size array.remove array.shift array.sum

Das ist nicht das Problem.

Diese Funktion erstellt ein neues Array-Objekt, das aus Elementen des Typs bool besteht.

array.new_bool(size, initial_value)

Beispiele

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter

• sizeDie ursprüngliche Größe der (series int) Serie↑ Optional↑ Default 0↑
• initial_value(series bool) Der Anfangswert aller Sequenzelemente↑ Optional↑ Der Standardwert ist na↑

AnmerkungenDie Arrayindex beginnen bei 0.

Bis dann array.new_float array.get array.slice array.sort

Array.new_float

Diese Funktion erzeugt ein neues Arrayobjekt mit einem Floating-Point-Element.

array.new_float(size, initial_value)

Beispiele

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter

• sizeDie ursprüngliche Größe der (series int) Serie↑ Optional↑ Default 0↑
• initial_value(series int/float) Der Anfangswert für alle Sequenzelemente. Optional. Der Standardwert ist na.

AnmerkungenDie Arrayindex beginnen bei 0.

Bis dann array.new_bool array.get array.slice array.sort

- Das ist nicht das Problem.

Die Funktion erstellt ein neues Arrayobjekt, das aus Elementen des Typs int besteht.

array.new_int(size, initial_value)

Beispiele

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter

• sizeDie ursprüngliche Größe der (series int) Serie↑ Optional↑ Default 0↑
• initial_value(series int) Der Anfangswert aller Sequenzelemente↑ Optional↑ Der Standardwert ist na↑

AnmerkungenDie Arrayindex beginnen bei 0.

Bis dann array.new_float array.get array.slice array.sort

Die Datenbank ist nicht mehr verfügbar.

Die Funktion erstellt neue Arrayobjekte mit einem String-Typ-Element.

array.new_string(size, initial_value)

Beispiele

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter

• sizeDie ursprüngliche Größe der (series int) Serie↑ Optional↑ Default 0↑
• initial_value(series string) Der Anfangswert aller Sequenzelemente↑ Optional↑ Der Standardwert ist na↑

AnmerkungenDie Arrayindex beginnen bei 0.

Bis dann array.new_float array.get array.slice

array.get

Die Funktion gibt den Wert des angegebenen Indexpunktelements zurück.

array.get(id, index)

Beispiele

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

Rückgabe von WertenDie Werte der Elemente der Array.

Parameter

• id(any array type) Array-Objekte.
• index(series int) ist ein Index für ein Element, dessen Wert zurückgegeben werden soll.

Bis dann array.new_float array.set array.slice array.sort

array.push

Die Funktion fügt einen Wert zu einem Array hinzu.

array.push(id, value)

Beispiele

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

Parameter

• id(any array type) Array-Objekte.
• value (series <type of the array's elements>) wird dem Elementwert am Ende des Arrays hinzugefügt.

Bis dann array.new_float array.set array.insert array.remove array.pop array.unshift

array.set

Die Funktion setzt den Wert eines Elements auf den angegebenen Index.

array.set(id, index, value) 

Beispiele

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

Parameter

• id(any array type) Array-Objekte.
• index(series int) Das Index eines Elements wird geändert.
• value (series <type of the array's elements>) neue Werte zu setzen.

Bis dann array.new_float array.get array.slice

array.sum

Die Funktion gibt die Summe der Elemente zurück.

array.sum(id) 

Beispiele

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

Rückgabe von WertenDie Summe der Elemente eines Arrays.

Parameter

• id(int[]/float[]) Arrayobjekte.

Bis dann array.new_float array.max array.min

array.avg

Die Funktion gibt den Durchschnittswert der Array-Elemente zurück.

array.avg(id)

Beispiele

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

Rückgabe von WertenDie Mittelwerte der Array-Elemente.

Parameter

• id(int[]/float[]) Arrayobjekte.

Bis dann array.new_float array.max array.min array.stdev

array.indexof

Diese Funktion gibt den Index zurück, in dem der Wert zuerst erschien. Wenn der Wert nicht gefunden wird, gibt sie -1 zurück.

array.indexof(id, value)

Beispiele

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

Rückgabe von WertenDas ist der Index eines Elements.

Parameter

• id(any array type) Array-Objekte.
• value (series <type of the array's elements>) ist der Wert, nach dem man in einem Array suchen soll.

Bis dann array.lastindexof array.get array.lastindexof array.remove array.insert

Strategie

In derstrategyIn den entsprechenden eingebauten Funktionen wird die Stop-Loss-Nummer, die Stop-Spring-Nummer definiert als das Multiplikator des Preissprunges.strategy.exitDie Funktionprofit、lossParameter mit Punkten für Stopp, Stopp, ParameterprofitSetzen Sie auf 10, d.h. Preissprung multipliziert mit 10 als Stopppreisdifferenz, wobei Preissprung die eingebaute Variable ist.syminfo.mintick。

Strategie

Die Funktion setzt verschiedene Policy-Eigenschaften ein. Bitte beachten Sie, dass es nur Unterstützung gibt.title，shorttitle，overlay，pyramiding，default_qty_type，default_qty_valueParameter, andere Parameter können über die Interfaceparameter der PINE-Sprachpolitik eingestellt werden.

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) 

Beispiele

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)

Parameter

• title(const string) wird der Index-Titel, den Sie im Indikator-/Strategien-Plugin sehen.
• shorttitle(const string) Die Kurzüberschrift der Indikatoren, die in den Diagrammbeispielen zu sehen sind.
• overlay(const bool) Wenn true, wird der Indikator als Überlagerung der Hauptreihe hinzugefügt. Wenn false - er wird in eine separate Grafikfenzeile hinzugefügt.
• format(const string) Der Typ des auf der Preisachse formatierten Indikatorwerts kann folgendermaßen sein: format.inherit、format.price、format.volume、default format.inherit。
• precision(const int) Die Ziffer nach der Zahl der Schwellpunkte der Indikatorenwerte auf der Preisachse. Die Ziffer muss eine nicht-negative ganze Zahl sein und darf nicht größer als 16 sein. Wenn sie ausgelassen wird, wird das Format der Stammreihe verwendet. Wenn format format.inherit ist und dieser Parameter gesetzt ist, wird format format.price.
• scale(scale_type) Der Indikator sollte den Preiskoordinaten folgen. Die möglichen Werte sind scale.right, scale.left, scale.none.
• pyramiding(const int) Die maximale Anzahl von Eintrittsbestellungen in die gleiche Richtung. Wenn dieser Wert 0 ist, kann nur eine Eintrittsbestellung in die gleiche Richtung geöffnet werden, und alle anderen Eintrittsbestellungen werden abgelehnt.
• calc_on_order_fills(const bool) Berechnung zusätzlicher Intrabar-Bestellungen. Wenn der Parameter auf true gesetzt ist, wird die Strategie neu berechnet (nicht nur beim Schließen der K-Zeile). Der Standardwert ist false.
• calc_on_every_tick(const bool) Zusätzliche Intrabar-Politikberechnung. Wenn die Parameter true sind, berechnet die Strategie in Echtzeit jede Zeitspanne, ohne die k-Zeile zu schließen. Die Parameter beeinflussen nicht die Politikberechnung der historischen Daten.
• max_bars_back(const int) Die maximale Anzahl von Bars, die für die historische Referenzpolitik verwendet werden kann. Wenn in dem Skriptcode auf die historische Daten der Variablen Bezug genommen wird, wird dieser Parameter für jede eingebaute Variable oder Benutzervariable im Skript angewendet. Die Größe des variablen Buffers in einem Pine-Skript wird normalerweise automatisch erkannt. In einigen Fällen ist dies jedoch nicht möglich, weshalb der Parameter es dem Benutzer erlaubt, den Untergrenzwert manuell festzulegen.
• backtest_fill_limits_assumption(const int) Einschränkungsausschreibung setzt voraus. Die Einschränkungsausschreibung wird nur dann in der Intrabar gehandelt, wenn der Marktpreis die angegebene Anzahl von Tickern überschreitet.
• default_qty_type(const string) wird fürqtyDer Wert des Parameters ist der Inhalt der Funktion strategy.entry oder strategy.order. Die möglichen Werte sind: strategy.fixed für Vertrag/Aktie/Handzahl, strategy.cash für Geldbetrag oder strategy.percent_of_equity für das Prozentsatz der verfügbaren Vermögenswerte.
• default_qty_value(const int/float) Die Anzahl der Standardtransaktionen der Strategie.Entry- oder Strategie.Order-Funktionen, deren Einheit durch die Parameter bestimmt wird, die zusammen mit der Strategie.Default_qty_type-Parameter verwendet werden, wenn ihre qty-Parameter nicht definiert sind.
• currency(const string) Die Kontowährung dieser Strategie. Optional. Der Standardwert ist die Währung der auf dem Diagramm aufgeführten Waren. Die möglichen Werte sind: 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) mit tick als Quote-Einheit wird der Gleitpunkt von der Transaktionspreis der Kauf/Verkauf- oder Stop-Loss-Offer erhöht/abgezogen. Wenn mintick = 0.01 und glittpunkt = 5, dann wird der Gesamtglittpunkt 5 * 0.01 = 0.05 sein.
• commission_type(const string) Die Art der Provisionen für jeden Auftrag. Die zulässigen Werte sind: strategy.commission.percent (Prozentsatz des Auftragsbetrags), strategy.commission.cash_per_contract (Betrag in der Kontowährung pro Auftrag) und strategy.commission.cash_per_order (Betrag in der Kontowährung pro Auftrag).
• commission_value(const int/float) Kommissionswert des Auftrags.
• process_orders_on_close(const bool) wird eingestellt, um weitere Versuche zur Erstellung von Exekutionsbestellungen nach dem Abschließen des Diagramms und der Durchführung der Strategieberechnung durchzuführen. Wenn die Bestellungen Marktpreise sind, wird der Broker-Simulator sie vor der Eröffnung des nächsten Diagramms ausführen. Wenn die Bestellung ein Limitpreis ist, wird die Bestellung nur ausgeführt, wenn die Preisbedingungen erfüllt sind.
• close_entries_rule(const string) Bestimmt die Reihenfolge, in der der Auftrag geschlossen wird. Der zulässige Wert lautet: FIFO oder ANY. FIFO (First-in, First-out) bedeutet, dass der erste Handel geschlossen werden muss, wenn mehrere Trades geöffnet sind. Diese Regel gilt für Aktien, Futures und US-Forex (NFA-konforme Regel 2-43b).
• max_lines_count(const int) zeigt die Anzahl der letzten Strichbilder an. Der Standardwert ist 50, der maximal zulässige Wert ist 500.
• max_labels_count(const int) Zeigt die Anzahl der letzten Markierungen an.
• max_boxes_count(const int) Anzahl der angezeigten letzten Box-Drawings. Der Standardwert ist 50, der maximal zulässige Wert ist 500.
• margin_long(const int/float) Multiplatform ist das Prozentsatz des Kaufpreises für eine Multiplatform, die mit Bargeld oder Pfand gedeckt sein muss.
• margin_short(const int/float) Leerkapital ist das Prozentsatz des Kaufpreises einer Wertpapierposition, die mit Bargeld oder Pfand gedeckt sein muss.
• explicit_plot_zorder(const bool) Geben Sie die Reihenfolge der Darstellung von Indikatoren, Füllungen und Horizontalen an. Wenn true, wird das Diagramm in der Reihenfolge dargestellt, in der es in dem Indikatorcode erscheint. Jedes neuere Diagramm wird auf dem vorherigen Diagramm dargestellt. Dies gilt nur für die Plot*() Funktion, Fill und Hline.
• initial_capital(const int/float) Das ursprünglich für den Strategiehandel verfügbare Geldvolumen wird in einer Währung angegeben, die in der Währungswelle definiert wird.
• risk_free_rate(const int/float) Die risikofreie Rendite ist die jährliche prozentuale Veränderung des Wertes einer Investition, bei der der Risiko minimal oder null ist. Sie wird für die Berechnung des Sharpe- und Sortino-Rates verwendet.

AnmerkungenJedes Strategie-Skript muss einen Strategie-Aufruf haben. PineScript-Code, der den Parameter calc_on_every_tick = true verwendet, kann unterschiedliche Berechnungen für historische Aufzeichnungen und Echtzeitdaten durchführen. Wenn Sie ein Diagramm mit einem nicht-standardischen Charttyp als Basis für Ihre Strategie verwenden, müssen Sie wissen, dass die Ergebnisse unterschiedlich sein können. Die Bestellung wird zum Preis der Tabelle ausgeführt (z. B. für Heikin Ashi wird der Preis von Heikin Ashi verwendet (durchschnittlich) ist nicht der tatsächliche Marktpreis). Daher empfehlen wir Ihnen dringend, den Standard-Charttyp in Ihrer Strategie zu verwenden.

Bis dann indicator

strategy.entry

Dies ist ein Market-Entry-Befehl. Wenn ein Auftrag mit derselben ID bereits aufgehängt ist, kann der Auftrag geändert werden. Wenn kein Auftrag mit derselben ID angegeben ist, wird ein neuer Auftrag ausgegeben. Um die Eintrittsanweisung zu beenden, sollte der Auftrag "strategy.cancel" oder "strategy.cancel_all" verwendet werden. Im Gegensatz zu der Funktion "strategy.order" kann die Strategy.entry-Funktion durch die Pyramiden beeinflusst werden und die Marktposition korrekt umkehren.

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

Beispiele

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

Parameter

• id(series string) Notwendige Parameter. Auftrags-Identifikator.
• direction(strategy_direction) Ein notwendiger Parameter. Markthaltungsrichtung: Strategy.long ist mehrfach, Strategy.short ist leer.
• qty(series int/float) Optionable Parameter↑ Vertrag/Anzahl der Aktien/Handzahlen/Einheiten der Transaktionen↑ Voreinstellungswert NaN↑
• limit(series int/float) Einstellbares Parameter♦ Limit des Auftrags♦ Wenn angegeben, ist der Auftragstyp "limit" oder "stop-limit"♦ andere Auftragsformen sind "NaN"♦
• stop(series int/float) Optionale Parameter. Stop-Loss-Preis der Bestellung. Wenn angegeben, ist der Bestelltyp "stop" oder "stop-limit".
• oca_name(series string) Optionale Parameter. Der Auftrag gehört zu einem OCA-Gruppennamen. Wenn der Auftrag nicht zu einer OCA-Gruppe gehört, sollte er einen leeren Charakter haben.Hinweis: FMZ unterstützt diesen Parameter nicht.
• oca_type(input string) Optionsparameter.  OCA-Ordergruppe-Typ.  Der zulässige Wert lautet: strategy.oca.none - der Auftrag darf nicht zu einer bestimmten OCA-Gruppe gehören; strategy.oca.cancel - der Auftrag sollte zu einer OCA-Gruppe gehören, sodass alle anderen Aufträge in derselben Gruppe abgeschafft werden, sobald der Auftrag ausgeführt wurde; strategy.oca.reduce - der Auftrag sollte zu einer OCA-Gruppe gehören, so dass die Anzahl der anderen Aufträge in derselben OCA-Gruppe X reduziert, wenn die Anzahl der Aufträge X platziert wurde.Hinweis: FMZ unterstützt diesen Parameter nicht.
• comment(series string) Optionale Parameter.
• when(series bool) Optionale Parameter. Status des Auftrags. Wenn "true", wird der Auftrag platziert. Wenn "false", passiert nichts.
• alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

strategy.close

Es handelt sich um einen Befehl für einen Ausstiegs-Auftrag mit einer angegebenen ID. Wenn mehrere Eintritts-Aufträge mit derselben ID vorhanden sind, werden sie alle gleichzeitig ausgeschlossen. Der Befehl wird nicht ausgeführt, wenn keine offene Order mit einer angegebenen ID beim Auslösen des Befehls vorhanden ist. Der Befehl verwendet Marktordern. Jeder Eintritt wird von einem separaten Marktordern geschlossen.

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

Beispiele

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)

Parameter

• id(series string) Notwendige Parameter.
• when(series bool) Optionale Parameter.
• qty(series int/float) Optionale Parameter↑ Anzahl der ausgehenden Verträge/Anzahl der Aktien/Anzahl der Hände/Einheiten↑ Default ist NaN↑
• qty_percent(series int/float) definiert den Anteil der Ausgleichsposition ((0-100) ). Seine Priorität liegt unter der Priorität des Parameters qty. Optional.
• comment(series string) Optionale Parameter.
• alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

Strategie.schließen_alle

Der Markt wird in den kommenden Monaten wieder stabilisiert, wenn die derzeitigen Marktpositionen ausgeschlossen werden.

strategy.close_all(when, comment, alert_message) 

Beispiele

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)

Parameter

• when(series bool) Optionale Parameter.
• comment(series string) Optionale Parameter.
• alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

strategy.exit

Dies ist ein Ausstiegsbefehl, der einen bestimmten Eingang oder eine gesamte Marktposition angibt. Wenn ein Auftrag mit der gleichen ID bereits aufgehängt ist, kann der Auftrag geändert werden. Wenn ein Eingangsauftrag nicht ausgeführt wird, aber ein Auszugsauftrag auftritt, wird der Auszugsauftrag ausgesetzt, bis der Auftragseigentümer, der den Eingangsauftrag ausgeführt hat, den Auszugauftrag platzieren kann. Um einen Ausgangsauftrag zu beenden, sollte der Befehlstrategy.cancel oderstrategy.cancel_all verwendet werden.应该多次调用命令strategy.exitWenn Sie Stop-Loss- und Tracking-Stopp-Orders verwenden, deren Auftragsart die Stop-Loss-Kette ist, wird nur einer von ihnen platziert (er wird zuerst ausgeführt). Wenn alle folgenden Parameter: Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette, Stop-Loss-Kette und Stop-Loss-Kette, werden die Aufträge gescheitert.

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

Beispiele

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"

Parameter

• id(series string) Notwendige Parameter. Auftrags-Identifikator.
• from_entry(series string) Optionable Parameter↑ Zur Angabe des Eingabe-Anweisungs-Identifikators "Aussteigen"↑ Zur Aussteigen aus allen Positionen sollte eine leere String verwendet werden↑ Der Standardwert ist eine leere String↑
• qty(series int/float) Optionale Parameter↑ Anzahl der ausgehenden Verträge/Anzahl der Aktien/Anzahl der Hände/Einheiten↑ Default ist NaN↑
• qty_percent(series int/float) definiert den Anteil der Ausgleichsposition ((0-100) ). Seine Priorität liegt unter der Priorität des Parameters qty. Optional.
• profit(series int/float) Optionale Parameter♦ Gewinnziele (doppelt angegeben)♦ Wenn angegeben, bei Erreichen der angegebenen Gewinnmenge (doppelt angegeben) eine Markteintrittsposition mit einem Limit-Order.
• limit(series int/float) Optionale Parameter << Gewinnziel << Preis angezeigt werden muss << Wenn dies angegeben ist, geht man zu einem angegebenen Preis << oder besser >> aus der Marktposition << Die Priorität des Parameters NaN-Limit ist höher als die Priorität des Parameters NaN-Profit << Wenn der Wert nicht NaN-Limit ist, ersetzt NaN-Limit die NaN-Profit-Limit << Der Standardwert ist NaN-Limit <<
• loss(series int/float) Optionale Parameter──Stoppverlust (d.h. Punkte) ─ Wenn angegeben, bei Erreichen des angegebenen Verlustbetrags (d.h. Punkte) mit einem Stoppverlust aus der Position aussteigen── Der Standardwert ist NaN─
• stop(series int/float) Optionale Parameter.Stopp-Loss (Preis angezeigt).Wenn angegeben, wird die Marktposition zum angegebenen Preis (oder schlechter) verlassen. Der Parameter Stopp-Loss-Loss hat eine höhere Priorität als der Parameter Stop-Loss-Loss-Loss-Loss. Der Standardwert ist Stop-Loss-Loss-Loss-Loss statt Stop-Loss-Loss-Loss-Loss-Loss-Loss-Loss.
• trail_price(series int/float) Optionale Parameter: ◦ Tracking Stop-Loss-Aktivierungs-Level (Preis muss angegeben werden) ◦ Wenn angegeben, wird die Tracking Stop-Loss-Liste platziert, wenn die angegebene Preis-Level erreicht wird. ◦ In den Parametern der Tracking-Strail_offset-Liste wird die Abweichung angegeben, um den Anfangspreis der Tracking-Stop-Loss-Liste zu bestimmen. ◦ Punkte: X-Punkte unter dem Aktivierungs-Level für einen Multi-Head-Austritt; X-Punkte über dem Aktivierungs-Level für einen Leerlauf-Austritt.
• trail_points(series int/float) Optionale Parameter: ◦ Tracking Stop-Loss-Aktivierungs-Level (geprägt durch Punkte) ◦ Wenn angegeben, wird die Tracking Stop-Loss-Liste platziert, wenn das berechnete Preisniveau (geprägt durch Punkte) erreicht wird. ◦ In der Parameterparameter der Tracking-Strail_offset-Liste wird die Abweichung angegeben, um den Anfangspreis der Tracking-Stop-Loss-Liste zu bestimmen (geprägt durch Punkte): X-Punkte unter dem Aktivierungs-Level für einen Multi-Head-Austritt; X-Punkte über dem Aktivierungs-Level für einen Blank-Head-Austritt. ◦ Der Standardwert ist NaN-NaN-Head.
• trail_offset(series int/float) Optionale Parameter <
• oca_name(series string) Optionale Parameter. Name der OCA-Gruppe (oca_type = strategy.oca.reduce) Gewinnziel, Stop/Track Stop. Wenn kein Name angegeben ist, wird dieser automatisch generiert.Hinweis: FMZ unterstützt diesen Parameter nicht.
• comment(series string) Optionale Parameter.
• when(series bool) Optionale Parameter. Status des Auftrags. Wenn "true", wird der Auftrag platziert. Wenn "false", passiert nichts.
• alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

strategy.cancel

Dies ist ein Benennungsanspruch, um alle Vorhanglisten zu deaktivieren, der von folgenden Funktionen erzeugt wird: strategy.order, strategy.entry andstrategy.exit。

strategy.cancel(id, when) 

Beispiele

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

Parameter

• id(series string) Notwendige Parameter↑ Bestellzeichen↑ Stellen Sie dieses Zeichen an, um eine Bestellung zu widerrufen↑
• when(series bool) Optionale Parameter. Eine Bestellung auf Basis der ID zu stornieren. Bei "true" wird die Bestellung storniert. Der Standardwert ist "true".

Strategie.abbrechen_alle

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

strategy.cancel_all(when) 

Beispiele

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

Parameter

• when(series bool) Optionale Parameter↑ Bedingungen für alle Bestellungen stornieren↑ Wenn die Bedingung wahr ist, werden alle aktiven Bestellungen storniert↑ Der Standardwert ist true↑

strategy.order

Das ist der Befehl, der die Bestellung aufhebt. Wenn eine Bestellung mit derselben ID bereits aufgehängt ist, kann der Befehl geändert werden. Wenn keine Bestellung mit derselben ID angegeben ist, wird eine neue Bestellung ausgegeben. Um die Bestellung zu beenden, sollte der Befehl strategy.cancel oder strategy.cancel_all verwendet werden. Im Gegensatz zu der Funktion strategy.entry ist die Funktion strategy.order nicht von der Form der Pyramide beeinflusst.

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

Beispiele

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

Parameter

• id(series string) Notwendige Parameter. Auftrags-Identifikator.
• direction(strategy_direction) Ein notwendiger Parameter. Auftragsrichtung: "strategy.long für Kauf", "strategy.short für Verkauf".
• qty(series int/float) Optionable Parameter↑ Vertrag/Anzahl der Aktien/Handzahlen/Einheiten der Transaktionen↑ Voreinstellungswert NaN↑
• limit(series int/float) Einstellbares Parameter♦ Limit des Auftrags♦ Wenn angegeben, ist der Auftragstyp "limit" oder "stop-limit"♦ andere Auftragsformen sind "NaN"♦
• stop(series int/float) Optionale Parameter. Stop-Loss-Preis der Bestellung. Wenn angegeben, ist der Bestelltyp "stop" oder "stop-limit".
• oca_name(series string) Optionale Parameter. Der Auftrag gehört zu einem OCA-Gruppennamen. Wenn der Auftrag nicht zu einer OCA-Gruppe gehört, sollte er einen leeren Charakter haben.Hinweis: FMZ unterstützt diesen Parameter nicht.
• oca_type(input string) Optionsparameter.  OCA-Ordergruppe-Typ.  Der zulässige Wert lautet: strategy.oca.none - der Auftrag darf nicht zu einer bestimmten OCA-Gruppe gehören; strategy.oca.cancel - der Auftrag sollte zu einer OCA-Gruppe gehören, sodass alle anderen Aufträge in derselben Gruppe abgeschafft werden, sobald der Auftrag ausgeführt wurde; strategy.oca.reduce - der Auftrag sollte zu einer OCA-Gruppe gehören, so dass die Anzahl der anderen Aufträge in derselben OCA-Gruppe X reduziert, wenn die Anzahl der Aufträge X platziert wurde.Hinweis: FMZ unterstützt diesen Parameter nicht.
• comment(series string) Optionale Parameter.
• when(series bool) Optionale Parameter. Status des Auftrags. Wenn "true", wird der Auftrag platziert. Wenn "false", passiert nichts.
• alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

Strategie.Oppentrades.Entry_bar_index

Gibt den Bar_index zurück, der nicht in den Handel eingegangen ist.

strategy.opentrades.entry_bar_index(trade_num)

Warten Sie auf 10 K-Linien und brechen Sie

Beispiele

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

Parameter

• trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

Strategie.Offentrades.Eintrag_id

Die Anmeldedaten für ungelöste Transaktionen werden zurückgegeben.

strategy.opentrades.entry_id(trade_num)

Beispiele

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

Rückgabe von WertenDie Anmeldedaten für ungelöste Transaktionen werden zurückgegeben.

Parameter

• trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

AnmerkungenWenn trade_num nicht im Bereich liegt, gibt die Funktion na:0 an strategy.opentrades-1 zurück.

Bis dann strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

Strategie.Offener Handel.Eintrittspreis

Der Preis für den Eintritt in eine nicht gebalancierte Transaktion wird zurückgegeben.

strategy.opentrades.entry_price(trade_num)

Beispiele

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

Berechnung des durchschnittlichen ungleichgewichtigten Preises

Beispiele

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

Parameter

• trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann strategy.closedtrades.exit_price

Strategie.Offentrades.Eintrittszeit

Geben Sie die UNIX-Zeit zurück, in der ein nicht-ausgeglichener Handel eingegangen ist.

strategy.opentrades.entry_time(trade_num)

Beispiele

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

Parameter

• trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

Die Gewinn- und Verlustwerte für nicht ausgeglichene Transaktionen werden zurückgegeben.

strategy.opentrades.profit(trade_num)

Die Gewinne aus der letzten Börse zurück

Beispiele

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

Berechnen Sie die Gewinne für alle nicht ausgeglichenen Geschäfte

Beispiele

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

Parameter

• trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit

strategy.opentrades.size

Gibt die Handelsrichtung und die Anzahl der Kontrakte in nicht-ausgeglichenen Geschäften zurück. Wenn dieser Wert > 0, ist die Marktposition mehrfach. Wenn dieser Wert < 0, ist die Marktposition leer.

strategy.opentrades.size(trade_num)

Beispiele

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

Berechnung des Prozentsatzes des durchschnittlichen Gewinns von nicht gebundenen Geschäften

Beispiele

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)

Parameter

• trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

Strategie.abgeschlossener Handel.Eintrag_Bar_Index

Gibt den Bar_index zurück, der bereits eingetragen ist.

strategy.closedtrades.entry_bar_index(trade_num)

Beispiele

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

Parameter

• trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

Strategie.abgeschlossener Handel.Ausgangspreis

Der Preis für den Ausgang eines ausgeglichenen Handels wird zurückgegeben.

strategy.closedtrades.exit_price(trade_num)

Beispiele

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

Berechnen Sie die Prozentsätze der durchschnittlichen Gewinne aller ausgeglichenen Geschäfte

Beispiele

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)

Parameter

• trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann strategy.closedtrades.entry_price

Strategie.abgeschlossener Handel.Exit_bar_index

Bar_index wird zurückgegeben.

strategy.closedtrades.exit_bar_index(trade_num)

Beispiele

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

Berechnen Sie die durchschnittliche Anzahl von K-Linien pro Transaktion.

Beispiele

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

Parameter

• trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann bar_index

Strategie.abgeschlossener Handel.Eintrag_id

Die Anmeldedaten für die bereits ausgeglichenen Transaktionen werden zurückgegeben.

strategy.closedtrades.entry_id(trade_num)

Beispiele

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

Rückgabe von WertenDie Anmeldedaten für die bereits ausgeglichenen Transaktionen werden zurückgegeben.

Parameter

• trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

AnmerkungenWenn trade_num nicht im Bereich liegt, gibt die Funktion na:0 an strategy.closedtrades-1 zurück.

Bis dann strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

Strategie.Abgeschlossener Handel.Eintrittspreis

Der Preis für den Eintritt in den ausgeglichenen Handel wird zurückgegeben.

strategy.closedtrades.entry_price(trade_num)

Beispiele

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

Berechnen Sie die Prozentsätze der durchschnittlichen Gewinne aller ausgeglichenen Geschäfte

Beispiele

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)

Parameter

• trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

Strategie.Abgeschlossener Handel.Eintrittszeit

Zurück zu der UNIX-Zeit, zu der der Handel eingegangen ist.

strategy.closedtrades.entry_time(trade_num)

Beispiele

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

Parameter

• trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

Die Gewinne und Verluste der ausgeglichenen Transaktionen werden zurückgegeben.

strategy.closedtrades.profit(trade_num)

Beispiele

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

Parameter

• trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann strategy.opentrades.profit strategy.closedtrades.commission

strategy.closedtrades.size

Gibt die Handelsrichtung und die Anzahl der Verträge in einem bereits ausgeglichenen Handel zurück. Wenn dieser Wert > 0, ist die Marktposition mehrfach. Wenn dieser Wert < 0, ist die Marktposition leer.

strategy.closedtrades.size(trade_num)

Beispiele

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

Berechnung des Prozentsatzes der durchschnittlichen Gewinne bei einem Aktienhandel

Beispiele

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

Mehr