Analyse von Hochfrequenz-Handelsstrategien - Penny Jump

Hochfrequenzhandel ist ein herausforderndes und wettbewerbsintensives Feld, das auf schnelle Handelsausführung und ein sensibles Verständnis der Mikrostruktur des Marktes angewiesen ist. Eine der beliebtesten Strategien ist der Penny Jump, der sich darauf konzentriert, den "Elefanten" im Markt zu nutzen, um kleine, aber häufige Gewinne zu erzielen. In diesem Artikel werden wir die Funktionsweise der Penny Jump-Strategie im Detail erklären und die Details des Strategiecodes eingehend untersuchen, damit Anfänger verstehen können, wie sie funktioniert.

Die Penny Jump-Strategie verstehen

In den Aktienmärkten bezieht sich der Begriff "Elefant" häufig auf institutionelle Investoren, die eine große Anzahl von Aktien kaufen oder verkaufen möchten, aber nicht bereit sind, zu einem Marktpreis zu handeln. Stattdessen wählen sie, um ihre Absicht zu zeigen, eine große Anzahl von Begrenzungslisten auf dem Markt zu hängen. Diese Verhaltensweisen haben in den Märkten große Aufmerksamkeit erregt, da große Handelslisten erhebliche Auswirkungen auf den Markt haben können.

Nehmen wir zum Beispiel an, dass die Markttiefe einer Aktie ursprünglich so aussah: 200 $1.01 x $1.03 200; und dann kommt ein Elefant und hängt eine Rechnung von 3000 $1.01 auf.

• Der Wettbewerb Für Hochfrequenzhändler kommt ihr Gewinn hauptsächlich aus der Analyse der Mikrostruktur des Marktes, um die Absichten anderer Händler zu vermuten. Sobald ein Elefant auftaucht, werden Hochfrequenzhändler schnell Positionen aufbauen, um winzige Preisschwankungen zu erhalten. Ihr Ziel ist es, in kurzer Zeit häufig zu handeln und kleine, aber kumulative Gewinne zu sammeln.

• Das Problem der Elefanten Obwohl die Elefanten möglicherweise große Operationen im Markt anstreben, zeigen ihre Handlungen auch ihre Handlungsabsichten, was sie zu Zielen von Hochfrequenz-Händlern macht. Hochfrequenz-Händler versuchen, Positionen im Voraus zu erstellen, um dann bei Preisschwankungen zu profitieren. Die Präsenz der Elefanten im Markt kann eine Reaktion der Wettbewerber auslösen, was ihre Handlungsstrategie beeinflusst.

• Betrug auf dem Markt In der Realität werden große institutionelle Investoren in der Regel nicht in der Lage sein, große Mengen an Kauf- oder Verkaufsanweisungen in den Märkten offensichtlich zu veröffentlichen, da diese Verhaltensweisen andere Marktteilnehmer dazu bringen können, Gegenmaßnahmen zu ergreifen oder sogar den Markt zu manipulieren. Daher können sie Strategien einführen, um eine Illusion zu erzeugen, um Hochfrequenzhändler anzusprechen und dann schnell zu verkaufen oder zu kaufen, um einen Gewinn aus den Preisschwankungen zu erzielen.

Die Kernidee der Penny Jump Strategie

Der Kerngedanke der Penny Jump Strategie ist, dass, sobald ein Elefant in einem Markt erscheint und einen bestimmten Preis unterstützt (z. B. $1.01), die HF-Händler schnell ihr Angebot um einen Cent erhöhen, z. B. auf $1.02.

Darüber hinaus können die High-Frequency-Händler auch nach dem Kauf einen Gewinn erzielen, auch wenn der Preis nicht gestiegen ist. Weil sie wissen, dass der Elefant den Unterwert unterstützt, können sie die Aktien schnell an den Elefanten verkaufen und einen winzigen Gewinn erzielen.

Das Penny Jump-Politik-Code wird gelöst.

Die Strategie ist hier:https://www.fmz.com/strategy/358

Die oben angegebene Strategie-Code ist ein Beispiel für die Implementierung der Penny Jump-Strategie. Hier ist eine detaillierte Erklärung des Codes, damit Anfänger verstehen können, wie es funktioniert:

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

// Variables
var InitAccount = null;

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", Counter.f, "\n"+msg+"#0000ff\n"+new Date());
}

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("买单得手: " + opAmount +", 开始出手...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

Ich werde den von Ihnen bereitgestellten Strategiecode Schritt für Schritt analysieren, um Ihnen zu helfen, ein besseres Verständnis dafür zu bekommen, wie er funktioniert.

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

Dieser Code initializiert ein Objekt namens Counter, das für die Tracking-Strategie verwendet wird.

• i: Das ist die Anzahl der Transaktionen.
• w: Die Anzahl der erfolgreichen Transaktionen.
• f: Die Anzahl der gescheiterten Transaktionen.

Diese Eigenschaften werden während der Ausführung der Politik aufgezeichnet und aktualisiert.

var InitAccount = null;

Diese Zeile initialiert eine Variable namens initAccount, die die Kontoinformationen speichert, wenn die Politik ausgeführt wird.

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

Das ist ein Projekt namensCancelAll()Die Funktion, deren Ziel es ist, alle unvollendeten Aufträge auf dem Markt zu löschen. Lassen Sie uns ihre Funktion schrittweise erklären:

• while (true): Es ist ein endloser Kreislauf, der so lange läuft, bis es keine unvollendeten Aufträge gibt.
• var orders = _C(exchange.GetOrders)：这一行代码使用exchange.GetOrders函数获取当前账户所有挂出的订单，并将它们存储在orders变量中。
• if (orders.length == 0): Diese Code-Zeile prüft, ob es noch unvollendete Aufträge gibt. Wenn die Länge der Arrays 0 bedeutet, dass es keine unvollendeten Aufträge gibt, wird der Kreislauf unterbrochen.
• for (var i = 0; i < orders.length; i++): Dies ist eine For-Lippe, die alle unvollendeten Bestellungen durchläuft.
• exchange.CancelOrder(orders[i].Id): Diese Codezeile verwendet die Funktion exchange.CancelOrder, um jede Bestellung mit der ID der Bestellung zu stornieren.
• Sleep(Interval): Diese Codezeile führt einen Wartezyklus ein, der eine Zeitlanges Warten ("in Millisekunden") vorsieht, um sicherzustellen, dass die Operation, die Bestellungen zu stornieren, nicht zu häufig ist.

Der Zweck dieser Funktion ist es, sicherzustellen, dass keine unvollendeten Aufträge vor der Ausführung der Hauptpolitik vorhanden sind, um zu vermeiden, dass die Ausführung der Hauptpolitik gestört wird.

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", Counter.f, "\n" + msg + "#0000ff\n" + new Date());
}

Das ist ein Projekt namensupdateStatus(msg)Die Funktion wird verwendet, um Informationen über den Status der Transaktionen zu aktualisieren und zu erfassen. Sie akzeptiert einen msg-Parameter, der normalerweise Informationen über den aktuellen Marktzustand enthält.

NutzungLogStatus()Die Funktion zeichnet die Informationen auf, die in der Statusleiste angezeigt werden, wenn die Strategie ausgeführt wird. Sie zeigt den Text über die Anzahl der Transaktionen, die Anzahl der Erfolge und die Anzahl der Misserfolge an. ZusätzlichmsgParameter, die Informationen über die aktuelle Marktlage enthalten. Der aktuelle Zeitfenster wurde hinzugefügt.new Date()) um Zeitinformationen anzuzeigen. Der Zweck dieser Funktion ist es, Informationen über den Status der Transaktionen zu erfassen und zu aktualisieren, um sie während der Strategieausführung zu überwachen und zu analysieren.

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("买单得手: " + opAmount +", 开始出手...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

Das ist die wichtigste Funktion der Strategie.main()Es enthält die Kernlogik der Strategie.

• if (DisableLog): Diese Codezeile prüft, ob die DisableLog-Variable wahr ist und schaltet Logs aus.

• CancelAll()Die vorher beschriebene Funktion "CancelAll" wird aufgerufen, um sicherzustellen, dass keine unvollendeten Bestellungen vorhanden sind.

• InitAccount = _C(exchange.GetAccount): Diese Codezeile erhält Informationen über das aktuelle Konto und speichert sie in der InitAccount-Variable.

• var i = 0;undvar locks = 0;: Initialisiert zwei Variablen i und locks, die in der nachfolgenden Strategielogik verwendet werden.

• while (true)Es ist ein endloser Kreislauf, der hauptsächlich für die kontinuierliche Umsetzung der Strategie verwendet wird.

In diesem Artikel werden wir Ihnen eine Zeile für Zeile erklären.while (true)Die wichtigsten strategischen Logiken innerhalb des Kreislaufs.

while (true) {
    Sleep(Interval);
    var depth = _C(exchange.GetDepth);
    if (depth.Asks.length === 0 || depth.Bids.length === 0) {
        continue;
    }
    updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);

• Sleep(Interval): Diese Codezeile lässt die Strategie eine Zeitlang ruhen, um die Ausführungsfrequenz der Strategie zu steuern. Der Interval-Parameter definiert die Zeitintervalle, in denen die Strategie ruht (in Millisekunden).

• var depth = _C(exchange.GetDepth)Sie erhalten aktuelle Markttiefeninformationen, einschließlich der Preise und der Anzahl der Verkaufs- und Verkaufsauftrags. Diese Informationen werden in der Tiefenvariable gespeichert.

• if (depth.Asks.length === 0 || depth.Bids.length === 0): Diese Codezeile überprüft die Markttiefe der Informationen, um sicherzustellen, dass sowohl Verkaufs- als auch Kaufgespräche vorhanden sind. Wenn eines davon nicht vorhanden ist, bedeutet dies, dass der Markt möglicherweise nicht über ausreichend Transaktionsinformationen verfügt, und die Strategie bleibt warten.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks): Diese Codezeile ruft die Update Status-Funktion auf, um den Status der Politik zu aktualisieren. Sie zeichnet den aktuellen Marktzustand auf, einschließlich des Kauf- und Verkaufspreises sowie der Anzahl der vorherigen Sperren.

    var askPrice = 0;
    for (i = 0; i < depth.Asks.length; i++) {
        if (depth.Asks[i].Amount >= Lot) {
            askPrice = depth.Asks[i].Price;
            break;
        }
    }
    if (askPrice === 0) {
        continue;
    }
    var elephant = null;

• var askPrice = 0;: Initiiert die Variable askPrice, die verwendet wird, um den Verkaufspreis zu speichern, der die Bedingungen erfüllt.

• for (i = 0; i < depth.Asks.length; i++): Dies ist ein For-Loop, mit dem Preis- und Quantitätsinformationen über die Verkaufslisten auf dem Markt verbreitet werden.

• if (depth.Asks[i].Amount >= Lot): in der Runde überprüft, ob die Anzahl der einzelnen Aufträge größer oder gleich der angegebenen Anzahl von Loten ((Handzahlen)) ist. Wenn ja, wird der Preis für diese Aufträge im AskPrice gespeichert und der Kreislauf beendet.

• if (askPrice === 0): Wenn kein Satz gefunden wird, der die Bedingungen erfüllt (askPrice bleibt 0), wird die Strategie weiter gewartet und die nachfolgende Operation übersprungen.

• var elephant = null;: Initialisieren der Elephant-Variable, die für die Speicherung von Zahlungsinformationen verwendet wird, die als Elefantenhülse identifiziert wurden.

    for (i = 1; i < depth.Bids.length; i++) {
        if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
            break;
        }
        if (depth.Bids[i].Amount >= ElephantAmount) {
            elephant = depth.Bids[i];
            break;
        }
    }

    if (!elephant) {
        locks = 0;
        continue;
    }
    locks++;
    if (locks < LockCount) {
        continue;
    }
    locks = 0;

Weitere Informationen über die Preise und Mengen der auf dem Markt angebotenen Angebote finden Sie hier.

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): überprüft, ob die Differenz zwischen dem aktuellen Kaufpreis und dem AskPrice größer ist als die von ElephantSpace. Wenn ja, bedeutet dies, dass die Strategie nicht weiter sucht.

• if (depth.Bids[i].Amount >= ElephantAmount): überprüft, ob die Anzahl der aktuellen Zahlungen größer oder gleich ElephantAmount ist, und speichert, wenn ja, die Zahlungsinformation in der Variablen elephant.

• if (!elephant): Wenn keine Elefantenhalmhalme gefunden werden, werden die numerischen Schlösser auf 0 gesetzt und weiter gewartet.

locks++: Die Anzahl der Sperrungen wird erhöht, wenn die Schilddrüse gefunden wird. Dies ist, um sicherzustellen, dass die Politik nach mehreren bestätigten Schilddrüsen in einer bestimmten Zeit wieder ausgeführt wird.

• if (locks < LockCount): Überprüfen Sie, ob die erforderliche Anzahl von Sperrungen erreicht wurde. Wenn nicht, warten Sie weiter.

    updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
    exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
    var ts = new Date().getTime();
    while (true) {
        Sleep(CheckInterval);
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        if ((new Date().getTime() - ts) > WaitInterval) {
            for (var i = 0; i < orders.length; i++) {
                exchange.CancelOrder(orders[i].Id);
            }
        }
    }

• updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant)): ruft die Update Status-Funktion an, die den aktuellen Status der Strategie, einschließlich des Standes der gefundenen Schildkröten und der entsprechenden Informationen, aufzeichnet. Dies wird in der Status-Tabelle der Strategie angezeigt.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): mit der exchange.Buy-Funktion finden Sie eine Elefantenpfeife. Der Kaufpreis lautet elephant.Price + PennyTick, die Anzahl der Käufe lautet Lot, und die Kaufoperation wird als "Bids[" + i + ]pfeife" beschrieben.

• var ts = new Date().getTime(): Erhält die Zeitscheibe der aktuellen Zeit, um den Zeitintervall zu berechnen.

• while (true): Eintritt in einen neuen, unbegrenzten Kreislauf, der für die Erfüllung von Bestellungen auf Kauf von Schildkröten verwendet wird.

• Sleep(CheckInterval)Strategie: eine Zeitlang ruhen, um die Häufigkeit der Überprüfung des Bestellstatus zu kontrollieren.

• var orders = _C(exchange.GetOrders)Sie erhalten Informationen über alle Bestellungen in Ihrem aktuellen Konto.

• if (orders.length == 0): Überprüft, ob es noch unvollendete Bestellungen gibt, wenn nicht, springt aus dem Kreislauf.

• (new Date().getTime() - ts) > WaitInterval: Berechnung der Zeitintervalle zwischen der aktuellen Zeit und dem Zeitpunkt des Kaufs von Kaffee-Elefanten-Kaffee, wenn die Wartezeit überschritten wird, bedeutet, dass die Wartezeit überschritten ist.

• for (var i = 0; i < orders.length; i++)Sie sind in der Lage, alle unvollendeten Bestellungen zu durchsuchen.

• exchange.CancelOrder(orders[i].Id)：使用exchange.CancelOrder函数取消每个未完成的订单。

    var account = _C(exchange.GetAccount);
    var opAmount = _N(account.Stocks - InitAccount.Stocks);
    if (opAmount < 0.001) {
        Counter.f++;
        Counter.i++;
        continue;
    }
    updateStatus("买单得手: " + opAmount + ", 开始出手...");
    exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
    var success = true;
    while (true) {
        var depth = _C(exchange.GetDepth);
        if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))) {
            success = false;
            updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
            CancelAll();
            account = _C(exchange.GetAccount);
            var opAmount = _N(account.Stocks - InitAccount.Stocks);
            if (opAmount < 0.001) {
                break;
            }
            exchange.Sell(depth.Bids[0].Price, opAmount);
        }
        var orders = _C(exchange.GetOrders);
        if (orders.length === 0) {
            break;
        }
        Sleep(CheckInterval);
    }
    if (success) {
        Counter.w++;
    } else {
        Counter.f++;
    }
    Counter.i++;
    var account = _C(exchange.GetAccount);
    LogProfit(account.Balance - InitAccount.Balance, account);
}

• var account = _C(exchange.GetAccount)Sie können sich die Informationen über das aktuelle Konto ansehen.

• var opAmount = _N(account.Stocks - InitAccount.Stocks): Berechnen Sie die Veränderung der Vermögenswerte in Ihrem Konto nach dem Kauf eines Pferdes. Wenn die Veränderung kleiner als 0.001 ist, bedeutet dies, dass der Kauf fehlgeschlagen ist, erhöht sich die Anzahl der Fehler und geht in den nächsten Kreislauf weiter.

• updateStatus("买单得手: " + opAmount + ", 开始出手...")In den letzten zehn Jahren hat sich die Zahl der erfolgreichen Käufe von Elefantenhalm erhöht, und die Zahl der Käufe ist ebenfalls gestiegen.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): Verkaufe erfolgreich gekaufte Elefantenfische mit der Exchange.Sell-Funktion, um einen Gewinn zu erzielen. Verkaufspreis: elephant.Price + (PennyTick * ProfitTick)

Ein neuer, unbegrenzter Kreislauf, der für die Ausführung von Pending Sales-Orders verwendet wird.

• var depth = _C(exchange.GetDepth)Sie sind in der Lage, sich zu informieren und sich zu informieren.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick)))Überprüfen Sie die Markttiefe und führen Sie eine Stop-Loss-Operation aus, wenn der Marktpreis bereits auf den Stop-Loss-Preis gesunken ist.

• CancelAll()Die Funktion: "CancelAll" wird aufgerufen, um alle nicht ausgeführten Bestellungen zu stornieren, um das Lagerrisiko zu vermeiden.

• if (opAmount < 0.001): Überprüfen Sie die Anzahl der Käufe erneut, wenn sie kleiner als 0.001 ist, bedeutet dies, dass der Kauf gescheitert ist und aus dem Kreislauf springt.

• exchange.Sell(depth.Bids[0].Price, opAmount)Das Unternehmen hat sich in den vergangenen Monaten mit dem Verkauf von Aktien in den USA beschäftigt.

Schließlich wird die Anzahl der erfolgreichen und fehlgeschlagenen Transaktionen aktualisiert und der Gewinn aufgezeichnet, je nachdem, ob die Transaktion erfolgreich war oder nicht.

Das ist eine Zeile-für-Zeile-Erklärung der gesamten Strategie. Die Kernidee der Strategie ist es, auf dem Markt nach Elefantenzähnen zu suchen (viel zu zahlen), zu kaufen und zu verkaufen, um einen winzigen Gewinn zu erzielen. Es umfasst mehrere wichtige Parameter, wie die Anzahl der Käufe (Lot), das Intervall von Fehlern, den Elefantenwert (ElephantAmount) und die Entfernung von Elefanten (ElephantSpace), um das Verhalten der Strategie anzupassen.

Im Allgemeinen ist diese Strategie eine Hochfrequenz-Handelsstrategie, die darauf abzielt, Markttiefen zu nutzen, große Anzahl von Zahlungen zu identifizieren und in kurzer Zeit zu kaufen und zu verkaufen. Sie erfordert die ständige Überwachung des Marktes und die Durchführung von Kauf- und Verkaufsaktionen, um schnell winzige Gewinne zu erzielen.

Bitte beachten Sie, dass die Strategie auf einem bestimmten Markt und einer bestimmten Handelsplattform basiert und für verschiedene Märkte und Börsen angemessen angepasst und optimiert werden muss. In der Praxis müssen Investoren die Performance der Strategie sorgfältig testen und bewerten, um sicherzustellen, dass sie den Anlagezielen und der Risikobereitschaft entspricht.

Wenn Sie weiter mit der Ausführung der Politik arbeiten, wird sie die folgenden Aktionen laufend ausführen:

1. Zunächst untersucht die Strategie tiefgreifende Informationen über den Markt, um die aktuellen Verkaufs- und Kaufbedingungen zu verstehen.

2. Als nächstes versucht die Strategie, qualifizierte Aufträge zu finden, wobei die spezifische Bedingung ist, dass die Anzahl der Aufträge größer oder gleich dem Lot ist. Wenn qualifizierte Aufträge gefunden werden, wird der Preis der Aufträge als AskPrice aufgezeichnet.

3. Dann geht die Strategie weiter auf der Suche nach der Schlange ("große Anzahl von Zahlungen"); sie durchläuft die Märkte und überspringt die erste Zahlung ("normalerweise die mit dem höchsten Preis bezahlte").

4. Wenn eine ausreichende Anzahl von Elefanten-Zähnen in Folge gefunden wird (beherrscht durch den LockCount-Parameter), führt die Strategie die folgenden Aktionen aus:

• Die Funktion update Status wird eingesetzt, um den Status und die entsprechenden Informationen zu den Schildkröten zu erfassen.
• Mit der exchange.Buy-Funktion kaufen Sie Elefanten-Elefanten mit dem Kaufpreis Elephant.Price + PennyTick mit dem Kaufvolumen Lot.
• Ein neuer, unbegrenzter Kreislauf beginnt, der für die Ausführung von Purchase-Orders verwendet wird.
• Überprüfen Sie den Status der Bestellung und springen Sie aus dem Kreislauf, wenn die Bestellung abgeschlossen ist.
• Wenn die Wartezeit die festgelegte Wartezeit ("Wait Interval") überschreitet, werden alle nicht abgeschlossenen Bestellungen storniert.
• Berechnet die Veränderung des Kontovermögens nach erfolgreichem Kauf, wenn die Veränderung kleiner als 0.001 ist, bedeutet der Kauf einen Misserfolg, erhöht die Anzahl der Misserfolge und setzt den nächsten Kreislauf fort.
• Die Informationen über die erfolgreichen Käufe von Elfenbein, einschließlich der Anzahl der Käufe, werden aufgezeichnet.

5. Dann geht die Strategie in einen neuen, unendlichen Kreislauf, in dem sie auf die Ausführung der Verkaufsaktion wartet. In diesem Kreislauf führt sie folgende Aktionen aus:

• Sie erhalten tiefe Marktinformationen, um zu überprüfen, ob der Marktpreis seinen Stop-Loss erreicht hat.
• Wenn der Marktpreis den Stop-Loss-Preis erreicht oder darunter liegt, wird eine Stop-Loss-Operation durchgeführt, d.h. der Restvermögen wird verkauft.
• Die Funktion "CancelAll" wird eingesetzt, um alle nicht ausgeführten Bestellungen zu stornieren, um das Lagerrisiko zu reduzieren.
• Überprüfen Sie erneut die Veränderung der Kontowerte nach erfolgreichem Kauf. Wenn die Veränderung kleiner als 0.001 ist, bedeutet dies, dass der Kauf gescheitert ist und aus dem Kreislauf springt.
• Schließlich wird erfasst, ob die Transaktion erfolgreich war, und die Anzahl der erfolgreichen und fehlgeschlagenen Transaktionen wird entsprechend aktualisiert.

Die ganze Strategie läuft im Kreislauf, um die oben genannten Operationen durchzuführen, um so viele Schilddrüsen wie möglich zu fangen und winzige Gewinne zu erzielen. Es ist eine Hochfrequenz-Handelsstrategie, die schnell auf Marktveränderungen reagieren muss, während Risikomanagement und Stop-Loss-Mechanismen berücksichtigt werden, um das Kapital zu schützen.

Abschluss

Die Penny Jump-Strategie ist ein typisches Beispiel für Hochfrequenz-Trading, das subtile Spielereien und Konkurrenz zwischen den Marktteilnehmern zeigt. In den Kryptowährungsmärkten ist diese Strategie besonders hervorzuheben, da der Markt stark schwankt und sowohl institutionelle Investoren als auch Hochfrequenz-Händler nach schnellen Profitzahlen streben.