Die Ressourcen sind geladen. Beförderung...

MyLanguage Doc

Schriftsteller:Die Erfinder quantifizieren - Kleine Träume, Erstellt: 2022-06-30 18:24:06, aktualisiert: 2024-02-06 17:36:19

[TOC]

MyLanguage ist eine programmatische Handelssprache, die mit MyLanguage kompatibel und erweitert ist. Die MyLanguage von FMZ Quant wird einer strengen Syntaxprüfung unterzogen.%%Der Betreiber wird einen Fehler verursachen.

Grundlegende Anweisungen
- Vertrag
  
  Kryptowährungsvertrag
  
  Kryptowährungsvertrag
```
this_week     cryptocurrency futures contract this week
next_week     cryptocurrency futures contract next week
month         cryptocurrency futures contract month
quarter       cryptocurrency futures contract quarter
next_quarter  cryptocurrency futures contract next quarter
third_quarter cryptocurrency futures contract third quarter
last_quarter  contract last quarter

XBTUSD        BITMEX perpetual contract
swap          cryptocurrency futures perpetual contracts other than BITMEX exchange

For details, please refer to the exchange.SetContractType() function section of the JavaScript/Python/C++ documentation
```
- Variablen
  
  Eine Variable ist ein Platz im Computerspeicher, der für die Speicherung von Daten genutzt wird.
  
  Öffnen Sie die erste Variable
```
// assign 1 to variable a
a:=1;
```
  InMyLanguage, ist leicht zu unterscheidendata volume:
  1. Einwertdaten: Es gibt nur einen Wert, z. B.0, 1, 'abc'.
  2. Sequenzdaten: eine Datensequenz, die aus einer Reihe von Daten mit einem einzigen Wert besteht, z. B.Close(Schlusskurs), wobeiCloseenthält den Schlusskurs vonn periods. [ 10.1 , 10.2 , 10.3 , 10.4 , 10.5 ...]
  Unterscheidung von Variable type
  1. String-Typ: er muss mit ```' umwickelt sein, String-Typ darf nicht direkt verwendet werden und muss mit der Funktion in die Ansicht ausgeführt werden.
```
INFO(CLSOE>OPEN,'OK!');
```
  1. Wertearten: einschließlich Ganzzahlen, Fließkommazahlen (Dezimalzahlen).
```
// integer
int:=2;

// decimal
float:=3.1;
```
  1. Boole-Typ, mit 1 (für wahr) oder 0 (für falsch): 1, 0, wahr oder falsch.A:=1>0;Nach Ausführung dieses Codes wird der Wert vonAist 1.
```
// The closing price of the current period is greater than -999, you will find that the return value of each period is 1, which means true, because the closing price is almost impossible to be negative.
is_true:=Close>-999;
```
  1. Gesamtvariablen
```
VARIABLE:VALUE1:10;     // Declare a global variable, assign the value 10, and execute it only once.
```
  Beachten Sie, dass beim Backtesting:
```
VARIABLE:NX:0;    // The initial global variable NX is 0
NX..NX+1;         // Accumulate 1 each time
INFO(1,NX);       // Print NX every time
```
  Anfangs war dieINFOAusdrucke von Erklärungen101Vielleicht nicht.0Anfangs? Der Grund dafür ist, dass es 100 anfängliche K-Linien im Backtest gibt, und 100 K-Linien wurden bereits durchlaufen, was 100 Mal angehäuft wurde. Der tatsächliche Preis hängt davon ab, wie viele K-Linien zunächst erhalten werden.
  - Regeln für die Benennung
    
    In den meisten Systemen erlaubt die Variablenbenennung nicht die Verwendung von System reservierten Wörtern (eingebettete Variablennamen, Funktionsnamen).Close, CDarüber hinaus sind reine Zahlen oder führende Zahlen nicht erlaubt. Schließlich darf es nicht sehr lang sein, und verschiedene Systeme haben unterschiedliche Längenbeschränkungen. Ich glaube, dass MyLanguage für Chinesen sehr freundlich ist. Für erfahrene Programmierer wird empfohlen, die folgenden zwei Namensregeln zu verwenden:
    1. Chinesische Bezeichnung
```
// elegant output
5-day moving average:=MA(C,5);
```
    1. Englisch + Unterstriche
```
// Output
move_avg_5:=MA(C,5);
```
    Wenn Sie Englisch bevorzugen, versuchen Sie, die Bedeutung Ihrer Variablen so verständlich wie möglich zu machen.A1, AAA, BBB... Vertrauen Sie mir, wenn Sie Ihren Indikatorcode in ein paar Tagen noch einmal überprüfen, werden Sie wegen Gedächtnisverlustes sehr unglücklich sein.
    
    Ich hoffe, dass MyLanguage ein mächtiges Werkzeug für Ihre Analyse und Entscheidungsfindung werden kann.
- Art der Daten
  
  Wenn wir einer Variablen schriftlich klare Daten zuweisen, wird die Variable auch zum Typ der Daten selbst.
  - 1. Art des Werts:
```
1.2.3.1.1234.2.23456 ...
```
  - 1. String-Typ:
```
'1' .'2' .'3' ，String types must be wrapped with ''
```
  - 1. Sequenzdaten:
```
A collection of data consisting of a series of single-valued data
```
  - 1. Boolean-Typ (Boolean):
    Verwendung1stellttrueund0fürfalse.
    
    Beispiel
```
// declare a variable of value type
var_int := 1;
// Declare a variable for sequence data
var_arr := Close;
// The string type cannot be declared alone, it needs to be combined with the function
INFO(C>O, 'positive line');
```
- Betreiber
  
  Die für die Ausführung des Indikatorcodes verwendeten Operationen und Berechnungen sind lediglich die Symbole, die in die Operation einbezogen werden.
  - Zuweisungsbetreiber
    
    Um einer Variablen einen Wert zuzuweisen
    - 1. :
      :, stellt Zuordnung und Ausgabe an den Graphen (Untergraphen) dar.
```
Close1:Close;      // Assign Close to the variable Close1 and output to the figure
```
    - 1. :=
      :=, stellt eine Zuordnung dar, wird aber nicht in den Diagramm ausgeführt (Hauptdiagramm, Unterdiagramm...), noch wird sie in der Statusleiste angezeigt.
```
Close2:=Close;     // Assign Close to the variable Close2
```
    - 1. ^^
      ^^Zwei.^Symbole stellen Zuordnung, Zuordnung von Werten zu Variablen und Ausgabe zum Graph (Hauptgraph) dar.
```
lastPrice^^C;
```
    - 1. ..
      ..Zwei..Symbole stellen eine Zuordnung dar, weisen Variablen Werte zu und zeigen Variablennamen und -werte im Diagramm an, zeichnen jedoch keine Bilder für das Diagramm (Hauptbild, Unterbild...).
```
openPrice..O
```
  - Relationale Operatoren
    
    Relationale Operatoren sind binäre Operatoren, die in bedingten Ausdrücken verwendet werden, um die Beziehung zwischen zwei Daten zu bestimmen.
    
    Rückgabewert: Boolean-Typ, entwedertrue(1) oderfalse(0).
    - 1. mehr als>
```
// Assign the operation result of 2>1 to the rv1 variable, at this time rv1=1
rv1:=2>1;
```
    - 1. weniger als<
```
// Returns false, which is 0, because 2 is greater than 1
rv3:=2<1;
```
    - 1. größer als oder gleich>=
```
x:=Close;
// Assign the result of the operation that the closing price is more than or equal to 10 to the variable rv2
// Remark that since close is a sequence of data, when close>=10 is performed, the operation is performed in each period, so each period will have a return value of 1 and 0
rv2:=Close>=10;
```
    - 1. kleiner als oder gleich<=
```
omitted here
```
    - 1. gleich=
```
A:=O=C;     // Determine whether the opening price is equal to the closing price.
```
    - 1. Nicht gleich<>
```
1<>2       // To determine whether 1 is not equal to 2, the return value is 1 (true)
```
  - Logische Operatoren
    
    Rückgabewert: Boolean-Typ, entwedertrue(1) oderfalse(0).
    1. Die logische und&&, kann durchand, und die linken und rechten Seiten der Verbindung müssen gleichzeitig hergestellt werden.
```
// Determine whether cond_a, cond_b, cond_c are established at the same time
cond_a:=2>1;
cond_b:=4>3;
cond_c:=6>5;
cond_a && cond_b and cond_c;    // The return value is 1, established
```
    1. Logisch oder||, können Sie verwendenorUm die linken und linken Seiten des oder zu ersetzen, ist eine Seite wahr (wahr), das Ganze ist wahr (zurückgegebenen Wert wahr).
```
cond_a:=1>2;
cond_b:=4>3;
cond_c:=5>6;
cond_a || cond_b or cond_c;    // The return value is 1, established
```
    1. ()Operator, wird der Ausdruck in Klammern zuerst ausgewertet.
```
1>2 AND (2>3 OR 3<5)    // The result of the operation is false
1>2 AND 2>3 OR 3<5      // The result of the operation is true
```
  - Arithmetische Operatoren
```
Return value: numeric type
```
    Arithmetische Operatoren sind Arithmetische Operatoren. Es ist ein Symbol für das Abschließen von grundlegenden arithmetischen Operationen (Arithmetische Operatoren), das ein Symbol ist, das zur Verarbeitung von vier arithmetischen Operationen verwendet wird.
    - Plus +
```
A:=1+1;      // return 2
```
    - minus -
```
A:=2-1;      // return 1
```
    - *multiplizieren *
```
A:=2*2;      // return 4
```
    - Teilen /
```
A:=4/2;      // return 2
```
- Funktionen
  - Funktionen
    
    In der Programmierwelt ist eine function ein Stück Code, das eine bestimmte Funktion implementiert.
```
function(param1,param2,...)
```
    - Zusammensetzung:
      
      Funktionsname (Parameter1, Parameter2,...), kann keine Parameter haben oder mehrere Parameter haben.MA(x,n);Mittel zur Rückkehr zum einfachen gleitenden Durchschnitt vonxinnerhalbnDazu gehören:MA()ist eine Funktion,xundnsind die Parameter der Funktion.
      
      Wenn wir eine Funktion verwenden, müssen wir die grundlegende Definition der Funktion verstehen, dh welche Daten durch Aufrufen der Funktion erhalten werden können. Im Allgemeinen haben Funktionen Parameter. Wenn wir Parameter übergeben, müssen wir sicherstellen, dass der eingehende Datentyp konsistent ist. In diesem Stadium ist die Code-Hinting-Funktion der meisten IDE sehr unvollkommen. Es gibt einen Datentyp des Parameters, der einige Probleme für unsere Verwendung bringt, undMA(x,n);wird wie folgt ausgelegt:
```
Return to simple moving average
Usage:
AVG:=MA(X,N): N-day simple moving average of X, algorithm (X1+X2+X3+...+Xn)/N, N supports variables
```
      Das ist sehr unfreundlich für Anfänger, aber als nächstes werden wir die Funktion gründlich zerlegen und versuchen, einen schnellen Weg zu finden, um die Funktion zu lernen und zu verwenden.
  - Rücklaufwert
    
    Um Funktionen schnell zu lernen, müssen wir zuerst ein Konzept verstehen, es wird return value genannt, Zurück, wie der Name schon sagt, bedeutet zurückkehren; Der Wert steht für spezifischen Wert, dann ist die Bedeutung des Rückgabewerts: die Daten, die erhalten werden können.
```
// Because it will be used in the following code, the variable return_value is used to receive and save the return value of function()
// retrun_value := function(param1,param2);
// For example:
AVG:=MA(C,10);     // AVG is retrun_value, function is MA function, param1 parameter: C is the closing price sequence data, param2 parameter: 10.
```
  - Parameter
    
    Zweitens ist das zweite wichtige Konzept der Funktion der Parameter, und verschiedene Rückgabewerte können durch Übergabe verschiedener Parameter erhalten werden.
```
// The variable ma5 receives the 5-day moving average of closing prices
ma5:=MA(C,5);
// The variable ma10 receives the 10-day moving average of closing prices
ma10:=MA(C,10);
```
    Der erste ParameterXder oben genannten Variablenma5, ma10istC(Schlusskurs)Cist auch eine Funktion (sendet die Reihenfolge der Schlusskursse von der Eröffnung bis zur Gegenwart zurück), hat aber keine Parameter.MA()Die Funktion wird flexibler durch die Parameter zu verwenden.
  - Wie man lernt
    - 1. Zuerst müssen wir verstehen, was eine Funktion tut, das heißt, welche Daten diese Funktion uns zurückgeben kann.
    - 1. Die letzte Sache ist, den Typ des zurückgegebenen Wertes zu verstehen.
    - 1. Darüber hinaus müssen wir den Datentyp des Parameters wissenMA(x,n), wenn Sie den Datentyp des Parameters nicht kennenx, n, wird es nicht in der Lage sein, den Return-Wert korrekt zu erhalten.
    Bei der folgenden Funktionseinführung und -verwendung folgen Sie den oben genannten drei Grundsätzen.
- Sprachverstärkung
  - MyLanguageundJavaScriptMischsprachige Programmierung
```
%%
// This can call any API quantified of FMZ
scope.TEST = function(obj) {
    return obj.val * 100;
}
%%
Closing price: C;
Closing price magnified 100 times: TEST(C);
The last closing price is magnified by 100 times: TEST(REF(C, 1)); // When the mouse moves to the K-line of the backtest, the variable value will be prompted
```
    - scopeGegenstand
      
      DiescopeObjekt kann Attribute hinzufügen und Anonymfunktionen zu Attributen zuweisen, und die anonyme Funktion, auf die dieses Attribut verwiesen wird, kann im Code-Teil von MyLanguage aufgerufen werden.
    - scope.getRefs(obj)Funktion
      
      InJavaScriptCode-Block, rufen Sie diescope.getRefs(obj)Funktion, um die Daten der übergebenen inobj object.
      
      DieJavaScriptCode, der mit folgenden Angaben versehen ist:%% %%Wir werden dieCdie in derTEST(C)Die Funktion in MyLanguage Code heißt Close price. Diescope.getRefsDiese Funktion gibt alle Schlusskosten dieser K-Liniendaten zurück.throw "stop"Um das Programm zu unterbrechen, wird die VariablearrSie können versuchen, zu löschenthrow "stop", wird es diereturnam Ende derJavaScriptCode und geben alle Daten zum Schlusskurs zurück.
```
%%
scope.TEST = function(obj){
    var arr = scope.getRefs(obj)
    Log("arr:", arr)
    throw "stop"
    return
}
%%
TEST(C);
```
    - scope.bars
      
      Zugriff auf alle K-Linienbalken in derJavaScriptCode-Block.
      
      DieTEST1 ist eine negative Linie und 0 ist eine positive Linie.
```
%%
scope.TEST = function(){
    var bars = scope.bars
    return bars[bars.length - 1].Open > bars[bars.length - 1].Close ? 1 : 0    // Only numeric values can be returned
}
%%
arr:TEST;                                                                      
```
```
# Attention:
# An anonymous function received by TEST, the return value must be a numeric value.
# If the anonymous function has no parameters, it will result in an error when calling TEST, writing VAR:=TEST; and writing VAR:=TEST(); directly.
# TEST in scope.TEST must be uppercase.
```
    - scope.bar
      
      In derJavaScriptCode-Block, Zugriff auf die aktuelle Leiste.
      
      Berechnen Sie den Durchschnitt der hohen Eröffnungspreise und der niedrigen Schließpreise.
```
%%
scope.TEST = function(){
    var bar = scope.bar
    var ret = (bar.Open + bar.Close + bar.High + bar.Low) / 4
    return ret
}
%%
avg^^TEST;
```
    - scope.depth
      
      Zugang zu Marktdaten (Auftragsbuch).
```
%%
scope.TEST = function(){
    Log(scope.depth)
    throw "stop"             // After printing the depth data once, throw an exception and pause
}
%%
TEST;
```
    - scope.symbol
      
      Holen Sie sich die Namensfolge des aktuellen Handelspaares.
```
%%
scope.TEST = function(){
    Log(scope.symbol)
    throw "stop"
}
%%
TEST;
```
    - scope.barPos
      
      Holen Sie die Bar-Position der K-Linie.
```
%%
scope.TEST = function(){
    Log(scope.barPos)
    throw "stop"
}
%%
TEST;
```
    - Scope.get_locals (Name)
      
      Diese Funktion wird verwendet, um die Variablen im Code-Bereich von MyLanguage zu erhalten.
```
V:10;
%%
scope.TEST = function(obj){
    return scope.get_locals('V')
}
%%
GET_V:TEST(C);
```
```
# Attention:
# If a variable cannot calculate the data due to insufficient periods, call the scope.get_locals function in the JavaScript code at this time
# When getting this variable, an error will be reported: line:XX - undefined locals A variable name is undefined
```
    - scope.canTrade
      
      DiecanTradeAttributmarkierungen, ob der aktuelle Balken gehandelt werden kann (ob der aktuelle Balken der letzte ist)
      
      Zum Beispiel, wenn man beurteilt, dass die Marktdaten gedruckt werden, wenn sich die Strategie in einem Zustand befindet, in dem der Auftrag gehandelt werden kann
```
%%
scope.LOGTICKER = function() {
    if(exchange.IO("status") && scope.canTrade){
        var ticker = exchange.GetTicker();
        if(ticker){
            Log("ticker:", ticker);
            return ticker.Last;
        }
    }
}
%%
LASTPRICE..LOGTICKER;
```
  - Anwendungsbeispiel
```
%%
scope.TEST = function(a){
    if (a.val) {
        throw "stop"
    }    
}
%%
O>C,BK;
C>O,SP;
TEST(ISLASTSP);
```
    Stoppen Sie die Strategie nach Eröffnung und Schließung einer Position einmal.
- Mehrjahresbezug
  
  Das System wählt automatisch eine geeignete zugrunde liegende K-Linien-Periode aus und verwendet diese zugrunde liegenden K-Linien-Periodendaten, um alle referenzierten K-Liniendaten zu synthetisieren, um die Genauigkeit der Daten zu gewährleisten.
  - Anwendung:#EXPORT formula_name ... #ENDWenn die Formel nicht nur berechnet wird, um Daten aus verschiedenen Perioden zu erhalten, können Sie auch eine leere Formel schreiben.
    
    Eine leere Formel ist:
```
#EXPORT TEST 
NOP;
#END           // end
```
  - Anwendung:#IMPORT [MIN,period,formula name] AS variable valueErhalten Sie verschiedene Daten des festgelegten Zeitraums (Schlusskurs, Eröffnungspreis usw., durch Variablenwert ermittelt).
    
    DieMINin derIMPORTBefehl bedeutetMinutenebene.MyLanguage der FMZ Quant-Plattform, und nur dieMINDas Niveau wird imIMPORTNicht-Standard-Perioden werden jetzt unterstützt.#IMPORT [MIN, 240, TEST] AS VAR240Daten wie die 240-minütige Periode (4-Stunden) K-Linie zu importieren.
    
    Codebeispiel:
```
// This code demonstrates how to reference formulas of different periods in the same code
// #EXPORT extended grammar, ending with #END marked as a formula, you can declare multiple
#EXPORT TEST 
Mean value 1: EMA(C, 20);
Mean value 2: EMA(C, 10);
#END // end

#IMPORT [MIN,15,TEST] AS VAR15 // Quoting the formula, the K-line period takes 15 minutes
#IMPORT [MIN,30,TEST] AS VAR30 // Quoting the formula, the K-line period takes 30 minutes
CROSSUP(VAR15.Mean value is 1, VAR30.Mean value is 1),BPK;
CROSSDOWN(VAR15.Mean value is 2, VAR30.Mean value is 2),SPK;
The highest price in fifteen minutes:VAR15.HIGH;
The highest price in thirty minutes:VAR30.HIGH;
AUTOFILTER;
```
  - Es ist notwendig, bei der Anwendung aufREF, LLV, HHVund sonstige Anweisungen zur Verweisung von Daten bei der Verweisung von Daten in mehreren Zeiträumen.
```
(*backtest
start: 2021-08-05 00:00:00
end: 2021-08-05 00:15:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_OKCoin","currency":"ETH_USD"}]
args: [["TradeAmount",100,126961],["ContractType","swap",126961]]
*)      

%%
scope.PRINTTIME = function() {
    var bars = scope.bars;
    return _D(bars[bars.length - 1].Time);
}
%%
BARTIME:PRINTTIME;      

#EXPORT TEST 
REF1C:REF(C,1);
REF1L:REF(L,1);
#END // end      

#IMPORT [MIN,5,TEST] AS MIN5
INFO(1, 'C:', C, 'MIN5.REF1C:', MIN5.REF1C, 'REF(MIN5.C, 1):', REF(MIN5.C, 1), 'Trigger BAR time:', BARTIME, '#FF0000');
INFO(1, 'L:', L, 'MIN5.REF1L:', MIN5.REF1L, 'REF(MIN5.L, 1):', REF(MIN5.L, 1), 'Trigger BAR time:', BARTIME, '#32CD32');
AUTOFILTER;
```
    Vergleich der Unterschiede zwischenMIN5.REF1CundREF(MIN5.C, 1)Wir finden:MIN5.REF1Cist der Wert des Schlusskurses des vorletzten BAR zum aktuellen Zeitpunkt der 5-minütigen K-Liniendaten.REF(MIN5.C, 1)ist der K-Linien-Periode des aktuellen Modells (die obige Code-Backtest-Periode ist auf 1 Minute gesetzt, d. h. ```period: 1m``), der Schlusskurs des 5-minütigen Zeitraums, in dem sich die vorletzte BAR im aktuellen Moment befindet. Diese beiden Definitionen unterscheiden sich und können je nach Bedarf verwendet werden.
- Beschreibung des Modus
  - Signalfiltermodell mit einer Öffnung und einer Nivellierung
    
    In dem Modell wird dieAUTOFILTERWenn mehrere Öffnungssignale die Bedingungen erfüllen, wird das erste Signal als das gültige Signal angenommen und das gleiche Signal auf der K-Linie wird herausgefiltert.
    
    Anweisungen, die durch Filtermodell unterstützt werden: BK, BP, BPK, SK, SP, SPK, CLOSEOUT usw. Anweisungen mit Losnummern wie BK ((5) werden nicht unterstützt.
    
    Zum Beispiel:
```
MA1:MA(CLOSE,5);
MA2:MA(CLOSE,10);
CROSSUP(C,MA1),BK;
CROSSUP(MA1,MA2),BK;
C>BKPRICE+10||C<BKPRICE-5,SP;
AUTOFILTER;
```
```
Comprehension:
As in the above example, when AUTOFILTER is not set, the third row BK, the fourth row BK and the fifth row SP are triggered in sequence, and each K-line triggers a signal once. After opening the position, and closing the position, the model state is reset.      
If AUTOFILTER is set, after triggering BK, only SP is triggered, other BK signals are ignored, and each K-line triggers a signal once.
```
  - Modell für die Erhöhung und Verringerung der Position
    
    DieAUTOFILTERdie Funktion ist nicht in das Modell eingetragen, so dass kontinuierliche Öffnungs- oder Schließsignale möglich sind, die Positionen erhöhen und verringern können.
    
    Unterstützte Anweisungen: BK(N), BP(N), SK(N), SP(N), CLOSEOUT, BPK(N), SPK(N), offene und schließende Aufträge ohne Losgröße werden nicht unterstützt. (1)Die Gruppierung von Anweisungen wird unterstützt. (2)Wenn mehrere Anweisungsbedingungen gleichzeitig erfüllt sind, werden die Signale in der Reihenfolge ausgeführt, in der die bedingten Anweisungen geschrieben werden. Zum Beispiel:
```
MA1:MA(CLOSE,5);
MA2:MA(CLOSE,10);
CROSSUP(C,MA1),BK(1);
CROSSUP(MA1,MA2),BK(1);
C>BKPRICE+10||C<BKPRICE-5,SP(BKVOL);
```
    VerwendungTRADE\_AGAINEs ist möglich, die gleiche Befehlszeile, mehrere Signale in Folge zu machen.
```
Comprehension:
The above example is executed one by one, and the signal after execution is no longer triggered. Reset the model status after closing the position. A K -line triggers a signal once.
```
  - Modell mit einer K-Linie und einem Signal
    
    Unabhängig davon, ob die K-Linie abgeschlossen ist, wird das Signal in Echtzeit-Bestellungen berechnet, dh die K-Linie wird vor der Bestellung platziert; die K-Linie wird am Ende überprüft. Wenn die Positionsrichtung nicht der Signalrichtung am Ende der K-Linie entspricht, wird die Position automatisch synchronisiert.
    
    Zum Beispiel:
```
MA1:MA(CLOSE,5);
MA2:MA(CLOSE,10);
CROSSUP(MA1,MA2),BPK;    //The 5-period moving average crosses up, and the 10-period moving average goes long.
CROSSDOWN(MA1,MA2),SPK;  //The 5-period moving average crosses down, and the 10-period moving average goes short.
AUTOFILTER;
```
  - Ein Modell mehrerer Signale auf einer K-Linie
    
    Das Modell verwendetmultsigzur Steuerung und Implementierung mehrerer Signale von einer K-Linie.
    
    Unabhängig davon, ob die K-Linie fertig ist, wird das Signal in Echtzeit berechnet.
    
    Das Signal wird nicht überprüft, es gibt kein Verschwinden des Signals und die Richtung des Signals entspricht immer der Richtung der Position.
    
    Wenn mehrere Signalbedingungen in einer K-Linie erfüllt sind, kann sie wiederholt ausgeführt werden.
```
For example:
MA1:MA(CLOSE,5);
MA2:MA(CLOSE,10);
CROSSUP(MA1,MA2),BK;
C>BKPRICE+10||C<BKPRICE-5,SP;
AUTOFILTER;
MULTSIG(0,0,2,0);
```
    MULTSIGkann mehrere Befehlszeilen innerhalb einer K-Zeile ausführen. Eine Befehlszeile wird nur einmal signalisiert.
```
O<C,BK;            // These conditions may all be executed in a K-line Bar, but only one signal per line
10+O<C,BK;         // Strategy plus TRADE_AGAIN(10);it can make multiple signals per line
20+O<C,BK;
40+O<C,BK;
MULTSIG(1,1,10);
```
    Zusatz: 1.Das Modell der Addition und Reduktion von Positionen, zwei Arten eines Signals und einer K-Linie: Aufgabe eines Auftrags zum Schlusskurs und Aufgabe eines Auftrags zum Auftragspreis, werden beide unterstützt. 2.Das Modell zur Addition und Reduktion von Positionen unterstützt auch die Reihenfolge mehrerer Signale aus einer K-Linie. Das Modell für die Addition und Reduktion von Positionen, schreiben Sie diemultsigFunktion, um mehrere Additionen oder mehrere Reduktionen auf einer K-Linie zu realisieren.
- Ausführungsart
  - Modell für Stangen
    
    Das Bar-Modell bezieht sich auf das Modell, das ausgeführt wird, nachdem der aktuelle BAR abgeschlossen ist, und der Handel wird ausgeführt, wenn der nächste BAR beginnt.
  - Tick-Modell
    
    Das Tick-Modell bedeutet, dass das Modell für jede Kursbewegung einmal ausgeführt wird und sofort gehandelt wird, wenn ein Signal auftritt. Das Tick-Modell ignoriert das Signal des vorherigen Tages (das Signal des vorherigen Tages wird sofort am selben Tag ausgeführt), und das Tick-Modell konzentriert sich nur auf die aktuellen Marktdaten, um festzustellen, ob das Signal ausgelöst wird.
- Anzeige von Diagrammen
  - Zusätzliche Indikatoren für das Hauptdiagramm
    
    Verwenden Sie den Operator^^, werden auf dem Hauptdiagramm Satzindikatoren angezeigt, während den Variablen Werte zugeordnet werden.
```
MA60^^MA(C, 60);  // Calculate the average indicator with the parameter of 60
```
  - Zusätzliche Indikatoren für Teildiagramme
    
    Verwenden Sie den Operator:, werden auf dem Unterdiagramm festgelegte Indikatoren angezeigt, während den Variablen Werte zugeordnet werden.
```
ATR:MA(MAX(MAX((HIGH-LOW),ABS(REF(CLOSE,1)-HIGH)),ABS(REF(CLOSE,1)-LOW)),26);    // Assign a value to the ATR variable, the ":" symbol is followed by the formula for calculating the ATR
```
    Wenn Sie nicht möchten, dass es auf dem Haupt- oder Unterdiagramm angezeigt wird, verwenden Sie den Operator ....
```
MA60..MA(C, 60);  // Calculate the average indicator with the parameter of 60
```
    Sie können es benutzen.DOTundCOLORREDUm den Zeilentyp und die Zeilenfarbe usw. entsprechend den Gewohnheiten der mit MyLanguage vertrauten Benutzer festzulegen.
- Häufige Probleme
  
  Einführung derProblemeIn der Regel sind dies die Punkte, die beim Schreiben beachtet werden müssen (kontinuierlich hinzugefügt).
  - Beachten Sie das Semikolon;Am Ende.
  - Beachten Sie, dass Systemschlüsselwörter nicht als Variablen deklariert werden können.
  - Beachten Sie, dass die ZeichenfolgeEinzeltitel, zum Beispiel: die Zeichenfolge'Open position'.
  - Anmerkung
    
    Anmerkung
    - // The Remark content(Eingabemethode kann sowohl auf Chinesisch als auch auf Englisch eingegeben werden) bedeutet, dass der Code nicht während des Ausführungsprozesses kompiliert wird, d. h. der Inhalt nach der Ausführung//Normalerweise verwenden wir es, um die Bedeutung des Codes zu markieren, wenn es bequem ist, den Code zu überprüfen, kann es schnell verstanden und erinnert werden.
    - { Remark content }- Blockieren Sie die Bemerkung.
```
A:=MA(C,10);
{The previous line of code is to calculate the moving average.}
```
    - (* Remark content *)- Blockieren Sie die Bemerkung.
```
A:=MA(C,10);
(*The previous line of code is to calculate the moving average.*)
```
  - Eingabe
    
    Wenn man Code schreibt, weil die Eingabemethode häufig zwischen Chinesisch und Englisch gewechselt wird, was zu Symbolfehlern führt.:Der Terminator.;Komma,, Klammern()Diese Zeichen in verschiedenen Zuständen des Chinesischen und Englischen brauchen Aufmerksamkeit.
    
    Wenn Sie Sogou, Baidu oder Bing Eingabe Methoden verwenden, können Sie schnell zwischen Chinesisch und Englisch wechseln, indem Sie dieshiftSchlüssel einmal.
  - Fehleranfällige Logik
    1. Mindestens, nicht weniger als, nicht weniger als: der entsprechende Relationsoperator>=.
    2. Höchstens: der entsprechende Relationsoperator<=.
  - Synchronisierung des Strategiestartes
    
    In der Futures-Strategie, wenn eine manuell geöffnete Position vor dem Start des Strategie-Roboters vorhanden ist, wird der Roboter, wenn er startet, die Positionsinformationen erkennen und mit dem tatsächlichen Positionsstatus synchronisieren. In der Strategie können Sie dieSP, BP, CLOSEOUTBefehle zur Schließung der Position.
```
%%
if (!scope.init) {
    var ticker = exchange.GetTicker();
    exchange.Buy(ticker.Sell+10, 1);
    scope.init = true;
}
%%
C>0, CLOSEOUT;
```
  - Zwei-Wege-Positionen werden nicht unterstützt
    
    MyLanguage unterstützt nicht den gleichen Vertrag mit Long- und Short-Positionen.

K-Liniendaten-Zitierung

Öffnen

Erhalten Sie den Eröffnungspreis des K-Liniendiagramms.

Eröffnungspreis

Funktion: OPEN, Abkürzung für O

Parameter: keine

Erläuterung: Gibt den Eröffnungspreis von dieser Periode zurück

Sequenzdaten

OPEN gets the opening price of the K-line chart.

Remark:
1.It can be abbreviated as O.

Example 1:
OO:=O;           //Define OO as the opening price; Remark that the difference between O and 0.
Example 2:
NN:=BARSLAST(DATE<>REF(DATE,1));
OO:=REF(O,NN);   //Take the opening price of the day
Example 3:
MA5:=MA(O,5);    //Define the 5-period moving average of the opening price (O is short for OPEN).

HIGH

Holen Sie sich den höchsten Preis auf der K-Line-Tabelle.

Der höchste Preis

Funktion: HIGH, abgekürzt H

Parameter: keine

Erläuterung: Rückgabe des höchsten Preises für diesen Zeitraum

Sequenzdaten

HIGH achieved the highest price on the K-line chart.

Remark:
1.It can be abbreviated as H.

Example 1:
HH:=H;         // Define HH as the highest price
Example 2:
HH:=HHV(H,5);  // Take the maximum value of the highest price in 5 periods
Example 3:
REF(H,1);      // Take the highest price of the previous K-line

Niedrig

Holen Sie sich den niedrigsten Preis auf der K-Liniendiagramm.

Der niedrigste Preis

Funktion: LOW, abgekürzt L

Parameter: keine

Erläuterung: Rückgabe des niedrigsten Preises dieser Periode

Sequenzdaten

LOW gets the lowest price on the K-line chart.

Remark:
1.It can be abbreviated as L.

Example 1:
LL:=L;            // Define LL as the lowest price
Example 2:
LL:=LLV(L,5);     // Get the minimum value of the lowest price in 5 periods
Example 3:
REF(L,1);         // Get the lowest price of the previous K-line

Nähe

Holen Sie sich den Schlusskurs des K-Liniendiagramms.

Schlusskurs

Funktion: CLOSE, kurz C

Parameter: keine

Erläuterung: Gibt den Schlusskurs von dieser Periode zurück

Sequenzdaten

CLOSE Get the closing price of the K-line chart

Remarks:
1.Obtain the latest price when the intraday K-line has not finished.
2.It can be abbreviated as C.

Example 1:
A:=CLOSE;          //Define the variable A as the closing price (A is the latest price when the intraday K-line has not finished)
Example 2:
MA5:=MA(C,5);      //Define the 5-period moving average of the closing price (C is short for CLOSE)
Example 3:
A:=REF(C,1);       //Get the closing price of the previous K-line

VOL

Erhalten Sie das Handelsvolumen des K-Liniendiagramms.

Handelsvolumen

Funktion: VOL, kurz V

Parameter: keine

Erläuterung: Gibt das Handelsvolumen für diesen Zeitraum zurück

Sequenzdaten

VOL obtains the trading volume of the K-line chart.

Remarks:
 It can be abbreviated as V.
The return value of this function on the current TICK is the cumulative value of all TICK trading volume on that day.

Example 1:
VV:=V;       // Define VV as the trading volume
Example 2:
REF(V,1);    // Indicates the trading volume of the previous period
Example 3:
V>=REF(V,1); // The trading volume is greater than the trading volume of the previous period, indicating that the trading volume has increased (V is the abbreviation of VOL)

OPI

Die aktuelle Gesamtposition auf dem Futures- (Kontrakt-) Markt.
```
OpenInterest:OPI;
```

Referenzbericht

Vorläufige Zitierung.

Reference the value of X before N periods.

Remarks:
1.When N is a valid value, but the current number of K-lines is less than N, returns null;
2.Return the current X value when N is 0;
3.Return a null value when N is null.
4.N can be a variable.

Example 1:
REF(CLOSE,5);Indicate the closing price of the 5th period before the current period is referenced
Example 2:
AA:=IFELSE(BARSBK>=1,REF(C,BARSBK),C);//Take the closing price of the K-line of the latest position opening signal
// 1）When the BK signal is sent, the bar BARSBK returns null, then the current K-line REF(C, BARSBK) that sends out the BK signal returns null;
// 2）When the BK signal is sent out, the K-line BARSBK returns null, and if BARSBK>=1 is not satisfied, it is the closing price of the K-line.
// 3）The K-line BARSBK after the BK signal is sent, returns the number of periods from the current K-line between the K-line for purchasing and opening a position, REF(C,BARSBK)
Return the closing price of the opening K-line.
// 4）Example: three K-lines: 1, 2, and 3, 1 K-line is the current K-line of the position opening signal, then returns the closing price of the current K-line, 2, 3
The K-line returns the closing price of the 1 K-line.

Einheit

Holen Sie sich die Handelseinheit des Datenvertrags.

Get the trading unit of the data contract.
Usage:
UNIT takes the trading unit of the loaded data contract.

Kryptowährungs-Spot

UNIT-Wert ist 1.

Futures für Kryptowährungen

Der Wert in UNIT bezieht sich auf die Vertragswährung.

OKEX futures currency standard contracts: 1 contract for BTC represents $100, 1 contract for other currencies represents $10

MINPRICE

Der Mindestvariationspreis des Datenvertrags.

Take the minimum variation price of the data contract.
Usage:
MINPRICE; Take the minimum variation price of the loaded data contract.

MINPRICE1

Der Mindestvariationspreis eines Handelsvertrags.

Take the minimum variation price of a trading contract.
Usage:
MINPRICE1; Take the minimum variation price of a trading contract.

Zeitfunktion

BARPOS

Nehmen Sie die Position der K-Linie ein.

BARPOS, Returns the number of periods from the first K-line to the current one.

Remarks:
1.BARPOS returns the number of locally available K-line, counting from the data that exists on the local machine.
2.The return value of the first K-line existing in this machine is 1.

Example 1:LLV(L,BARPOS);        // Find the minimum value of locally available data.

Example 2:IFELSE(BARPOS=1,H,0); // The current K-line is the first K-line that already exists in this machine, and it takes the highest value, otherwise it takes 0.

DAYBARPOS

DAYBARPOS die aktuelle K-Line BAR ist die K-Line BAR des Tages.
Zeit

Der Periodenwert ist die Anzahl der Minuten.
```
1, 3, 5, 15, 30, 60, 1440
```

Datum

DatumFunktion DATE, Erhalten Sie das Jahr, den Monat und den Tag des Zeitraums seit 1900.

Example 1:
AA..DATE;                  // The value of AA at the time of testing is 220218, which means February 18, 2022

Zeit

Es ist Zeit, die K-Linie zu nehmen.

TIME, the time of taking the K-line.

Remarks:
1.The function returns in real time in the intraday, and returns the starting time of the K-line after the K-line is completed.
2.This function returns the exchange data reception time, which is the exchange time.
3.The TIME function returns a six-digit form when used on a second period, namely: HHMMSS, and displays a four-digit form on other periods, namely: HHMM.
4.The TIME function can only be loaded in periods less than the daily period, and the return value of the function is always 1500 in the daily period and periods above the daily period.
5. It requires attention when use the TIME function to close a position at the end of the day
(1).It is recommended to set the time for closing positions at the end of the market to the time that can actually be obtained from the return value of the K-line (for example: the return time of the last K-line in the 5-minute period of the thread index is 1455, and the closing time at the end of the market is set to TIME>=1458, CLOSEOUT; the signal of closing the position at the end of the market cannot appear in the effect test)
(2).If the TIME function is used as the condition for closing the position at the end of the day, it is recommended that the opening conditions should also have a corresponding time limit (for example, if the condition for closing the position at the end of the day is set to TIME>=1458, CLOSEOUT; then the condition TIME needs to be added to the corresponding opening conditions. <1458; avoid re-opening after closing)

Example 1:
C>O&&TIME<1450,BK;
C<O&&TIME<1450,SK;
TIME>=1450,SP;
TIME>=1450,BP;
AUTOFILTER;
// Close the position after 14:50.
Example 2:
ISLASTSK=0&&C>O&&TIME>=0915,SK;

Jahr

Year.

YEAR, year of acquisition.

Remark:
The value range of YEAR is 1970-2033.

Example 1:
N:=BARSLAST(YEAR<>REF(YEAR,1))+1;
HH:=REF(HHV(H,N),N);
LL:=REF(LLV(L,N),N);
OO:=REF(VALUEWHEN(N=1,O),N);
CC:=REF(C,N);                               // Take the highest price, lowest price, opening price, and closing price of the previous year
Example 2:
NN:=IFELSE(YEAR>=2000 AND MONTH>=1,0,1);

Monat

Nehmen Sie sich den Monat.

MONTH, returns the month of a period.

Remark:
The value range of MONTH is 1-12.

Example 1:
VALUEWHEN(MONTH=3&&DAY=1,C);                // Take its closing price when the K-line date is March 1
Example 2:
C>=VALUEWHEN(MONTH<REF(MONTH,1),O),SP;

Tag

Finden Sie die Anzahl der Tage in einer Periode

DAY, returns the number of days in a period.

Remark:
The value range of DAY is 1-31.

Example 1:
DAY=3&&TIME=0915，BK;                      // 3 days from the same day, at 9:15, buy it
Example 2:
N:=BARSLAST(DATE<>REF(DATE,1))+1;
CC:=IFELSE(DAY=1,VALUEWHEN(N=1,O),0);      // When the date is 1, the opening price is taken, otherwise the value is 0

Uhrzeit

Hour.

HOUR, returns the number of hours in a period.

Remark:
The value range of HOUR is 0-23

Example 1:
HOUR=10;                                   // The return value is 1 on the K-line at 10:00, and the return value on the remaining K-lines is 0

Das ist eine Minute.

Minute.

MINUTE, returns the number of minutes in a period.

Remarks:
1: The value range of MINUTE is 0-59
2: This function can only be loaded in the minute period, and returns the number of minutes when the K-line starts.
Example 1:
MINUTE=0;                                 // The return value of the minute K-line at the hour is 1, and the return value of the other K-lines is 0
Example 2:
TIME>1400&&MINUTE=50,SP;                   // Sell and close the position at 14:50

Tag der Woche

Holen Sie sich die Nummer der Woche.

WEEKDAY, get the number of the week.

Remark:
1: The value range of WEEKDAY is 0-6. (Sunday ~ Saturday)

Example 1:
N:=BARSLAST(MONTH<>REF(MONTH,1))+1;
COUNT(WEEKDAY=5,N)=3&&TIME>=1450,BP;
COUNT(WEEKDAY=5,N)=3&&TIME>=1450,SP;
AUTOFILTER;                               // Automatically close positions at the end of the monthly delivery day
Example 2:
C>VALUEWHEN(WEEKDAY<REF(WEEKDAY,1),O)+10,BK;
AUTOFILTER;

Funktion des logischen Urteils

BARSTATUS

Geben Sie den Positionsstatus für den laufenden Zeitraum zurück.

BARSTATUS returns the position status for the current period.

Remark:
The function returns 1 to indicate that the current period is the first period, returns 2 to indicate that it is the last period, and returns 0 to indicate that the current period is in the middle.

Example:
A:=IFELSE(BARSTATUS=1,H,0);              // If the current K-line is the first period, variable A returns the highest value of the K-line, otherwise it takes 0

Zwischen

Between.

BETWEEN(X,Y,Z) indicates whether X is between Y and Z, returns 1 (Yes) if established, otherwise returns 0 (No).

Remark:
1.The function returns 1(Yse) if X=Y, X=Z, or X=Y and Y=Z.

Example 1:
BETWEEN(CLOSE,MA5,MA10);                // It indicates that the closing price is between the 5-day moving average and the 10-day moving average

- Das ist nicht wahr.

BARSLASTCOUNT(COND) zählt die Anzahl der aufeinander folgenden Perioden, die die Bedingung erfüllen, und zählt ab dem laufenden Zeitraum.

Remark:
1. The return value is the number of consecutive non zero periods calculated from the current period
2. the first time the condition is established when the return value of the current K-line BARSLASTCOUNT(COND) is 1

Example:
BARSLASTCOUNT(CLOSE>OPEN);
//Calculate the number of consecutive positive periods within the current K-line

Kreuze

Kreuzfunktion.

CROSS(A,B) means that A crosses B from bottom to top, and returns 1 (Yes) if established, otherwise returns 0 (No)

Remark:
1.To meet the conditions for crossing, the previous k-line must satisfy A<=B, and when the current K-line satisfies A>B, it is considered to be crossing.

Example 1:
CROSS(CLOSE,MA(CLOSE,5));              // Indicates that the closing line crosses the 5-period moving average from below

Überschneidung

Durchschlag

CROSSDOWN(A,B): indicates that when A passes through B from top to bottom, it returns 1 (Yes) if it is established, otherwise it returns 0 (No)

Remark:
1.CROSSDOWN(A,B) is equivalent to CROSS(B,A), and CROSSDOWN(A,B) is easier to understand

Example 1:
MA5:=MA(C,5);
MA10:=MA(C,10);
CROSSDOWN(MA5,MA10),SK;               // MA5 crosses down MA10 to sell and open a position
// CROSSDOWN(MA5,MA10),SK; Same meaning as CROSSDOWN(MA5,MA10)=1,SK;

KRSSUP

Crossup.

CROSSUP(A,B) means that when A crosses B from the bottom up, it returns 1 (Yes) if it is established, otherwise it returns 0 (No)

Remark:
1.CROSSUP(A,B) is equivalent to CROSS(A,B), and CROSSUP(A,B) is easier to understand.

Example 1:
MA5:=MA(C,5);
MA10:=MA(C,10);
CROSSUP(MA5,MA10),BK;                 // MA5 crosses MA10, buy open positions
// CROSSUP(MA5,MA10),BK;与CROSSUP(MA5,MA10)=1,BK; express the same meaning

Jeder

Bestimmen, ob sie kontinuierlich erfüllt ist.

EVERY(COND,N), Determine whether the COND condition is always satisfied within N periods. The return value of the function is 1 if it is satisfied, and 0 if it is not satisfied.

Remarks:
1.N contains the current K-line.
2.If N is a valid value, but there are not so many K-lines in front, or N is a null value, it means that the condition is not satisfied, and the function returns a value of 0.
3.N can be a variable.

Example 1:
EVERY(CLOSE>OPEN,5);                // Indicates that it has been a positive line for 5 periods
Example 2:
MA5:=MA(C,5);                       // Define a 5-period moving average
MA10:=MA(C,10);                     // Define a 10-period moving average
EVERY(MA5>MA10,4),BK;               // If MA5 is greater than MA10 within 4 periods, then buy the open position
// EVERY(MA5>MA10,4),BK; has the same meaning as EVERY(MA5>MA10,4)=1,BK;

BESTÄNDEN

Stellen Sie fest, ob Sie zufrieden sind.

EXIST(COND, N) judges whether there is a condition that satisfies COND within N periods.

Remarks:
1.N contains the current K-line.
2.N can be a variable.
3.If N is a valid value, but there are not so many K-lines in front, it is calculated according to the actual number of periods.

Example 1:
EXIST(CLOSE>REF(HIGH,1),10);     // Indicates whether there is a closing price greater than the highest price of the previous period in 10 periods, returns 1 if it exists, and returns 0 if it does not exist
Example 2:
N:=BARSLAST(DATE<>REF(DATE,1))+1;
EXIST(C>MA(C,5),N);              // Indicates whether there is a K-line that satisfies the closing price greater than the 5-period moving average on the day, returns 1 if it exists, returns 0 if it does not exist

Wenn

Zustandsfunktion.

IF(COND,A,B)Returns A if the COND condition is true, otherwise returns B.

Remarks:
1.COND is a judgment condition; A and B can be conditions or values.
2.This function supports the variable circular reference to the previous period's own variable, that is, supports the following writing Y: IF(CON,X,REF(Y,1)).
Example 1:
IF(ISUP,H,L);                   // The K-line is the positive line, the highest price is taken, otherwise the lowest price is taken
Example 2:
A:=IF(MA5>MA10,CROSS(DIFF,DEA),IF(CROSS(D,K),2,0));     // When MA5>MA10, check whether it satisfies the DIFF and pass through DEA, otherwise (MA5 is not greater than MA10), when K and D are dead fork, let A be assigned a value of 2, if none of the above conditions are met, A is assigned a value of 0
A=1,BPK;                                                // When MA5>MA10, the condition for opening a long position is to cross DEA above the DIFF
A=2,SPK;                                                // When MA5 is not greater than MA10, use K and D dead forks as the conditions for opening short positions

IFELSE

Zustandsfunktion.

IFELSE(COND,A,B) Returns A if the COND condition is true, otherwise returns B.

Remarks:
1.COND is a judgment condition; A and B can be conditions or values.
2.This function supports variable circular reference to the previous period's own variable, that is, supports the following writing Y: IFELSE(CON,X,REF(Y,1));
Example 1:
IFELSE(ISUP,H,L);                                             // The K-line is the positive line, the highest price is taken, otherwise the lowest price is taken
Example 2:
A:=IFELSE(MA5>MA10,CROSS(DIFF,DEA),IFELSE(CROSS(D,K),2,0));   // When MA5>MA10, check whether it satisfies the DIFF and pass through DEA, otherwise (MA5 is not greater than MA10), when K and D are dead fork, let A be assigned a value of 2, if none of the above conditions are met, A is assigned a value of 0
A=1,BPK;                                                      // When MA5>MA10, the condition for opening a long position is to cross DEA above the DIFF
A=2,SPK;                                                      // When MA5 is not greater than MA10, use K and D dead forks as the conditio

Nächste Seite

Verwandt

Mehr

MyLanguage Doc

Grundlegende Anweisungen

Vertrag

Variablen

Regeln für die Benennung

Art der Daten

Betreiber

Zuweisungsbetreiber

Relationale Operatoren

Logische Operatoren

Arithmetische Operatoren

Funktionen

Funktionen

Rücklaufwert

Parameter

Wie man lernt

Sprachverstärkung

Mehrjahresbezug

Beschreibung des Modus

Signalfiltermodell mit einer Öffnung und einer Nivellierung

Modell für die Erhöhung und Verringerung der Position

Modell mit einer K-Linie und einem Signal

Ein Modell mehrerer Signale auf einer K-Linie

Ausführungsart

Modell für Stangen

Tick-Modell

Anzeige von Diagrammen

Zusätzliche Indikatoren für das Hauptdiagramm

Zusätzliche Indikatoren für Teildiagramme

Häufige Probleme

Anmerkung

Eingabe

Fehleranfällige Logik

Synchronisierung des Strategiestartes

Zwei-Wege-Positionen werden nicht unterstützt

K-Liniendaten-Zitierung

Öffnen

HIGH

Niedrig

Nähe

VOL

OPI

Referenzbericht

Einheit

MINPRICE

MINPRICE1

Zeitfunktion

BARPOS

DAYBARPOS

Zeit

Datum

Zeit

Jahr

Monat

Tag

Uhrzeit

Das ist eine Minute.

Tag der Woche

Funktion des logischen Urteils

BARSTATUS

Zwischen

- Das ist nicht wahr.

Kreuze

Überschneidung

KRSSUP

Jeder

BESTÄNDEN

Wenn

IFELSE