Die Ressourcen sind geladen. Beförderung...

Analyse der Hochfrequenzhandelsstrategie - Penny Jump

Schriftsteller:FMZ~Lydia, Erstellt: 2023-11-07 10:44:20, Aktualisiert: 2024-01-01 12:19:43

Der High-Frequency-Trading ist ein herausforderndes und wettbewerbsorientiertes Feld, das sich auf schnelle Handelsdurchführung und sensible Einblicke in die Mikrostruktur des Marktes stützt. Eine bemerkenswerte Strategie ist Penny Jump, die sich auf die Ausbeutung von Elephants auf dem Markt konzentriert, um kleine, aber häufige Gewinne zu erzielen.

Die Penny-Jump-Strategie verstehen

Auf dem Aktienmarkt beziehen sich "Elefanten" in der Regel auf institutionelle Anleger, die eine große Anzahl von Aktien kaufen oder verkaufen möchten, aber nicht zum Marktpreis handeln möchten. Stattdessen hängen sie eine große Anzahl von Limit-Orders auf dem Markt, d.h. ausstehende Aufträge, um ihre Absichten anzuzeigen. Dieses Verhalten hat auf dem Markt große Aufmerksamkeit erregt, da große Transaktionen einen erheblichen Einfluss auf den Markt haben können.

Nehmen wir zum Beispiel an, die ursprüngliche Tiefe eines Aktienmarktes war so: 200 ∙ $1.01 x $1.03 ∙ 200. Dann tritt ein Elefant ein und platziert einen Kauf Auftrag für 3000 Aktien zu $1.01 pro Stück. An diesem Punkt ändert sich die Tiefe des Marktes auf 3.200 ∙ $1.01 x $1.03 ∙ 200. Diese Aktion ist wie die Einführung eines Elefanten, der der Fokus anderer Marktteilnehmer wird.

Wettbewerb Für Hochfrequenzhändler kommen ihre Gewinne hauptsächlich aus der Analyse der Marktmikrostruktur, um über die Absichten anderer Händler zu spekulieren. Sobald ein großer Player erscheint, werden Hochfrequenzhändler schnell Positionen einrichten, um kleine Preisschwankungen zu erfassen. Ihr Ziel ist es, häufig in kurzer Zeit zu handeln und kleine, aber kumulative Gewinne zu sammeln.
Das Dilemma des Elefanten Auch wenn Elefanten auf dem Markt in großem Maßstab tätig werden möchten, zeigen ihre Handlungen auch ihre Handelsabsichten, was sie zu Zielen für Hochfrequenzhändler macht. Hochfrequenzhändler versuchen, Positionen vor der Zeit zu etablieren und dann von Preisschwankungen zu profitieren. Die Anwesenheit von Elefanten auf dem Markt könnte Reaktionen in wettbewerbsfähigen Märkten auslösen und dadurch ihre Handelsstrategien beeinflussen.
Betrug auf dem Markt In Wirklichkeit platzieren große institutionelle Investoren in der Regel keine große Anzahl von Kauf- oder Verkaufsaufträgen auf dem Markt offensichtlich, da ein solches Verhalten andere Marktteilnehmer dazu führen könnte, Gegenmaßnahmen zu ergreifen oder sogar den Markt zu manipulieren. Daher können sie Strategien anwenden, um Illusionen zu schaffen, Hochfrequenzhändler ins Feld zu locken und dann schnell zu verkaufen oder zu kaufen, um von Preisschwankungen zu profitieren.

Die Kernidee der Penny-Jump-Strategie

Die Kernidee der Penny Jump Strategie ist, dass, sobald ein großer Player auf dem Markt erscheint und einen bestimmten Preis unterstützt (z. B. 1,01 USD), Hochfrequenzhändler ihr Angebot schnell um einen Cent erhöhen, zum Beispiel auf 1,02 USD. Dies liegt daran, dass Hochfrequenzhändler verstehen, dass das Auftreten eines großen Spielers bedeutet, dass es eine starke Kaufunterstützung auf diesem Preisniveau gibt, so dass sie versuchen, in der Hoffnung auf einen Preisanstieg genau zu folgen. Wenn der Preis tatsächlich auf 1,03 USD x 1,05 USD steigt, können Hochfrequenzhändler schnell verkaufen und einen Gewinn von 0,01 USD erzielen.

Nicht nur das, sondern Hochfrequenzhändler können auch nach dem Kauf Gewinne erzielen, auch wenn der Preis nicht steigt, weil sie wissen, dass der große Akteur den Basispreis unterstützt hat. Daher können sie ihre Aktien schnell an diesen großen Akteur verkaufen und winzige Arbitragegegeinnahmen erzielen.

Analysieren Sie den Penny Jump Strategie Code

Strategie-Quellcode:https://www.fmz.com/strategy/358

Der oben angegebene Strategiecode ist ein Beispiel, das zur Implementierung der Penny Jump-Strategie verwendet wird.

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("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", 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("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + 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("Debug the elephant... The elephant is in gear " + 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("Successful payment: " + opAmount +", Start taking action...");
        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("Didn't get it, start to stop loss, currently buying one: " + 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 Ihren bereitgestellten Strategiecode Zeile für Zeile analysieren, um Ihnen zu helfen, seinen Betrieb im Detail zu verstehen.

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

Dieser Code initialisiert ein Objekt mit dem Namen Counter, das verwendet wird, um die Handelsstatistiken einer Strategie zu verfolgen.

i: Die Gesamtzahl der Transaktionen.
w: Die Zahl der erfolgreichen Transaktionen.
f: Die Zahl der fehlgeschlagenen Transaktionen.

Diese Attribute werden während des Strategieausführungsprozesses erfasst und aktualisiert.

var InitAccount = null;

Diese Codezeile initialisiert eine Variable namens InitAccount, die Kontoinformationen speichert, wenn die Strategie 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 eine Funktion namensCancelAll(), dessen Zweck es ist, alle unerfüllten Aufträge auf dem Markt zu stornieren.

while (true): Dies ist eine unendliche Schleife, sie wird so lange laufen, bis es keine unvollendeten Aufträge mehr gibt.
var orders = _C(exchange.GetOrders): Diese Codezeile verwendet die Exchange.GetOrders-Funktion, um alle ausstehenden Aufträge auf dem Girokonto abzurufen und in der Ordervariable zu speichern.
if (orders.length == 0): Diese Codezeile überprüft alle unvollendeten Bestellungen. Wenn die Länge des Bestellungsarrays 0 ist, bedeutet dies, dass es keine unvollendeten Bestellungen gibt und die Schleife unterbrochen wird (Break).
for (var i = 0; i < orders.length; i++): Dies ist eine For-Schleife, die alle unvollendeten Aufträge durchläuft.
exchange.CancelOrder(orders[i].Id): Diese Codezeile verwendet die Exchange.CancelOrder() Funktion, um jede Bestellung mit ihrer ID zu stornieren.
Sleep(Interval): Diese Codezeile führt eine Wartezeit ein, die für eine bestimmte Zeit (in Millisekunden) pausiert, um sicherzustellen, dass die Annullierung von Aufträgen nicht zu häufig erfolgt.

Diese Codezeile führt eine Wartezeit ein, die für eine bestimmte Zeit (in Millisekunden) pausiert, um sicherzustellen, dass der Ablauf von Stornierungsaufträgen nicht zu häufig erfolgt.

function updateStatus(msg) {
    LogStatus("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", Counter.f, "\n" + msg + "#0000ff\n" + new Date());
}

Das ist eine Funktion namensupdateStatus(msg), die zur Aktualisierung und Aufzeichnung von Transaktionsstatusinformationen verwendet wird. Sie akzeptiert einen msg-Parameter, der normalerweise Informationen über den aktuellen Marktstatus enthält. Zu den spezifischen Operationen der Funktion gehören:

Mit Hilfe derLogStatus()Funktion, um die in der Statusleiste während der Strategieausführung angezeigten Informationen aufzuzeichnen. DiemsgDer Markt wird von der Kommission geprüft. Der aktuelle Zeitstempel (new Date()) ist beigefügt, um Zeitinformationen anzuzeigen. Zweck dieser Funktion ist die Erfassung und Aktualisierung von Informationen zum Transaktionsstatus zur Überwachung und Analyse während der Strategieausführung.

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("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + 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("Debug the elephant... The elephant is in gear " + 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("Successful payment: " + opAmount +", Start taking action...");
        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("Didn't get it, start to stop loss, currently buying one: " + 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);
    }
}

Dies ist die Hauptausführung Funktionmain()Die Strategie ist in der Tat eine strategische Strategie, die die Kernlogik der Strategie beinhaltet.

if (DisableLog): Diese Codezeile prüft, ob die Variable DisableLog wahr ist, und wenn ja, wird die Protokollaufzeichnung deaktiviert. Dies soll sicherstellen, dass unnötige Protokolle nicht von der Strategie aufgezeichnet werden.
CancelAll(): Die zuvor erläuterte Funktion CancelAll( rufen, um sicherzustellen, dass es keine unvollendeten Aufträge gibt.
InitAccount = _C(exchange.GetAccount): Diese Codezeile holt die Informationen zum Girokonto ab und speichert sie in der Variablen InitAccount.
var i = 0;undvar locks = 0;: Initialisieren Sie zwei Variablen, i und Locks, die in der nachfolgenden Strategie-Logik verwendet werden.
while (true): Dies ist eine unendliche Schleife, die hauptsächlich für die kontinuierliche Ausführung von Strategien verwendet wird.

Im Folgenden werden wir die wichtigste Strategie-Logik innerhalb derwhile (true)Schleife Linie für Linie.

while (true) {
    Sleep(Interval);
    var depth = _C(exchange.GetDepth);
    if (depth.Asks.length === 0 || depth.Bids.length === 0) {
        continue;
    }
    updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);

Sleep(Interval): Diese Codezeile ermöglicht es der Strategie, für einen bestimmten Zeitraum zu schlafen, um die Ausführungsfrequenz der Strategie zu steuern.
var depth = _C(exchange.GetDepth): Erhalten Sie die aktuellen Markttiefeninformationen, einschließlich der Preise und Mengen der Verkaufs- und Kaufbestellungen.
if (depth.Asks.length === 0 || depth.Bids.length === 0): Diese Codezeile überprüft die Markttiefeinformationen und stellt sicher, dass sowohl Verkaufs- als auch Kauforders vorhanden sind.
updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ", Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks): Diese Codezeile ruft die Funktion updateStatus auf, um die Statusinformationen der Strategie zu aktualisieren.

    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;: Initialisieren Sie die Variable askPrice, sie wird verwendet, um den Preis von Verkaufsbestellungen zu speichern, die die Bedingungen erfüllen.
for (i = 0; i < depth.Asks.length; i++): Dies ist eine For-Schleife, mit der die Preis- und Mengeninformationen von Marktverkaufsbestellungen durchlaufen werden.
if (depth.Asks[i].Amount >= Lot): In der Schleife überprüfen Sie, ob die Menge jedes Verkaufsorders größer oder gleich dem angegebenen Los (Handzählung) ist.
if (askPrice === 0): Wenn keine Verkaufsbestellungen gefunden werden, die die Bedingungen erfüllen (askPrice ist immer noch 0), wird die Strategie weiter warten und nachfolgende Operationen überspringen.
var elephant = null;: Initialisieren Sie die Variable elephant, sie wird verwendet, um die Bestellinformationen zu speichern, die als elephant identifiziert werden.

    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;

Weiterhin werden die Preis- und Mengeninformationen der Marktkaufbestellungen durchsucht, wobei die erste Kaufbestellung (Bids[0]) übersprungen wird.

if ((askPrice - depth.Bids[i].Price) > ElephantSpace): Überprüfen Sie, ob die Lücke zwischen dem aktuellen Angebotspreis und dem AskPrice größer ist als ElephantSpace.
if (depth.Bids[i].Amount >= ElephantAmount): Überprüfen Sie, ob die Menge der aktuellen Bestellung größer oder gleich ElephantAmount ist. Falls ja, speichern Sie die Bestellinformationen in der Variablen elephant.
if (!elephant): Wenn der elephant nicht gefunden wird, setzen Sie die Sperrzahl auf 0 zurück und warten Sie weiter.
locks++: Wenn der elephant gefunden wird, erhöhen Sie die Anzahl der Schlösser. Dies soll sicherstellen, dass die Strategie erst nach mehrfacher Bestätigung der Existenz des elephant über einen bestimmten Zeitraum ausgeführt wird.
if (locks < LockCount): Überprüfen Sie, ob die Anzahl der Sperrzeiten den Anforderungen entspricht (LockCount).

    updateStatus("Debug the elephant... The elephant is in gear " + 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("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant)): Die Funktion updateStatus wird aufgerufen, um den aktuellen Status der Strategie zu erfassen, einschließlich der Getriebeposition des elephant und der damit verbundenen Informationen.
exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): Verwenden Sie die Exchange.Buy-Funktion, um den gefundenen Elephant zu kaufen. Der Kaufpreis ist elephant.Price + PennyTick, die Kaufmenge ist Lot und beschreiben Sie die Kaufoperation als Bids[ + i + ].
var ts = new Date().getTime(): Erhalten Sie den Zeitstempel der aktuellen Zeit für die spätere Berechnung von Zeitintervallen.
while (true): Geben Sie eine neue unendliche Schleife ein, die verwendet wird, um auf die Ausführung von elephant Kaufbestellungen zu warten.
Sleep(CheckInterval): Die Strategie schläft eine Weile, um die Häufigkeit der Überprüfung des Auftragsstatus zu kontrollieren.
var orders = _C(exchange.GetOrders): Erhalten Sie alle Auftragsinformationen des Girokontos.
if (orders.length == 0): Überprüfen Sie, ob es noch unvollendete Bestellungen gibt, wenn nicht, brechen Sie die Schleife.
(new Date().getTime() - ts) > WaitInterval: Berechnen Sie das Zeitintervall zwischen der aktuellen Zeit und dem Zeitpunkt, zu dem der elephant gekauft wurde. Übersteigt er WaitInterval, bedeutet dies, dass das Warten abgelaufen ist.
for (var i = 0; i < orders.length; i++)Durchsuchen Sie alle unvollendeten Aufträge.
exchange.CancelOrder(orders[i].Id): Verwenden Sie die Funktion exchange.CancelOrder, um jede unvollendete Bestellung zu stornieren.

    var account = _C(exchange.GetAccount);
    var opAmount = _N(account.Stocks - InitAccount.Stocks);
    if (opAmount < 0.001) {
        Counter.f++;
        Counter.i++;
        continue;
    }
    updateStatus("Successful payment: " + opAmount + ", Start taking action...");
    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("Didn't get it, start to stop loss, currently buying one: " + 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): Erhalten Sie Informationen über das Girokonto.
var opAmount = _N(account.Stocks - InitAccount.Stocks): Berechnen Sie die Änderung der Kontovermögen nach dem Kauf des elefanten. Wenn die Änderung kleiner als 0,001 ist, bedeutet dies, dass der Kauf gescheitert ist, erhöhen Sie die Anzahl der Ausfälle und fahren Sie zur nächsten Schleife weiter.
updateStatus("Successful payment: " + opAmount + ", Start taking action..."): Die erfolgreichen Einkaufsinformationen für elephant, einschließlich der gekauften Menge, werden aufgezeichnet.
exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): Verwenden Sie die Exchange.Sell-Funktion, um den erfolgreich gekauften elephant gewinnbringend zu verkaufen. Der Verkaufspreis lautet elephant.Price + (PennyTick * ProfitTick).

Geben Sie eine neue unendliche Schleife ein, die verwendet wird, um auf die Ausführung von Verkaufsaufträgen zu warten.

var depth = _C(exchange.GetDepth): Gewinnen Sie detaillierte Marktinformationen.
if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): Überprüfen Sie die Markttiefeninformationen, wenn der Marktpreis bereits auf das Stop-Loss-Niveau gefallen ist, und führen Sie dann die Stop-Loss-Operation aus.
CancelAll(): Die Funktion CancelAll( aufrufen, um alle nicht abgeschlossenen Aufträge zu stornieren, um Positionsrisiken zu vermeiden.
if (opAmount < 0.001): Überprüfen Sie die Kaufmenge erneut, wenn sie kleiner als 0,001 ist, bedeutet dies, dass der Kauf fehlgeschlagen ist, brechen Sie aus der Schleife.
exchange.Sell(depth.Bids[0].Price, opAmount): Eine Stop-Loss-Operation ausführen, die verbleibenden Vermögenswerte zum niedrigsten Preis des aktuellen Marktes verkaufen.

Schließlich wird die Anzahl der erfolgreichen und fehlgeschlagenen Transaktionen auf der Grundlage der Tatsache, ob die Transaktion erfolgreich war oder nicht, aktualisiert und die Handelsgewinne erfasst.

Dies ist eine Zeile für Zeile Erklärung der gesamten Strategie. Die Kernidee dieser Strategie besteht darin, elephants (große Kaufbestellungen) auf dem Markt zu finden, sie zu kaufen und zu verkaufen, um kleine Gewinne zu erzielen. Es umfasst mehrere wichtige Parameter wie Lot, Fehlerwiederversuchsintervall (Intervall), ElephantAmount, ElephantSpace usw., um die Strategie anzupassen.

Im Allgemeinen ist diese Strategie eine Hochfrequenz-Handelsstrategie, die darauf abzielt, Markttiefeinformationen zu nutzen, um große Kaufbestellungen zu identifizieren und Kauf- und Verkaufstransaktionen in kurzer Zeit durchzuführen. Sie erfordert eine ständige Überwachung des Marktes und die Durchführung von Kauf- und Verkaufstransaktionen, um schnell kleine Gewinne zu erzielen. Es ist jedoch auch eine risikoreiche Strategie, da sie schnelle Reaktionen auf Marktschwankungen erfordert, während Risikomanagement und Stop-Loss-Mechanismen berücksichtigt werden, um erhebliche Verluste zu vermeiden.

Bitte beachten Sie, dass die Strategie auf bestimmten Märkten und Handelsplattformen basiert. Für verschiedene Märkte und Börsen können geeignete Anpassungen und Optimierungen erforderlich sein. In der Praxis müssen Anleger die Performance der Strategie sorgfältig testen und bewerten, um sicherzustellen, dass sie ihren Anlagezielen und ihrer Risikotoleranz entspricht.

Wenn Sie die Strategie weiter ausführen, wird sie wiederholt folgende Vorgänge ausführen:

Erstens wird die Strategie die detaillierten Informationen des Marktes überprüfen, um die aktuelle Situation der Verkaufs- und Kaufbestellungen zu verstehen.
Als nächstes wird die Strategie versuchen, Verkaufsbestellungen zu finden, die die Kriterien erfüllen, insbesondere Verkaufsbestellungen mit einer Menge, die größer oder gleich dem Lot ist.
Dann wird die Strategie weiter nach Elephants (große Menge an Kaufordern) suchen. Sie durchquert die Kauforders des Marktes und überspringt die erste (normalerweise die am höchsten bepreisende Kauforder). Wenn sie einen Elephant findet, der die Kriterien erfüllt, wird sie Informationen über den Elephant aufzeichnen und die Schlösser erhöhen.
Wird eine ausreichende Anzahl von Elephants in Folge gefunden (kontrolliert durch den LockCount-Parameter), wird die Strategie die folgenden Operationen ausführen:

Die Funktion updateStatus wird aufgerufen, um die Ausrüstung und die damit verbundenen Informationen des elefanten aufzuzeichnen.
Verwenden Sie die Exchange.Buy-Funktion, um einen elephant zu kaufen, mit einem Kaufpreis von elephant.Price + PennyTick und einer Menge von Lot.
Beginnen Sie eine neue unendliche Schleife, in der Sie auf die Ausführung des Kauforders warten.
Überprüfen Sie den Status des Auftrags.
Überschreitet die Wartezeit den eingestellten Intervall (WaitInterval), so werden alle nicht abgeschlossenen Aufträge storniert.
Berechnen Sie Änderungen der Kontovermögen nach erfolgreichem Kauf. Wenn die Änderung kleiner als 0,001 ist, bedeutet dies, dass der Kauf fehlgeschlagen ist; erhöhen Sie die Anzahl der Fehler und fahren Sie mit der nächsten Schleife fort.
Informationen über erfolgreiche Käufe von Elefanten, einschließlich der gekauften Menge, werden aufgezeichnet.

Als nächstes tritt die Strategie in eine neue unendliche Schleife ein und wartet auf die Ausführung der Verkaufsaktionen.

Erhalten Sie Markttiefeninformationen, überprüfen Sie, ob der Marktpreis bereits das Stop-Loss-Niveau erreicht hat.
Wenn der Marktpreis die Stop-Loss-Level erreicht oder unter sie fällt, wird eine Stop-Loss-Operation ausgeführt, d. h. die verbleibenden Vermögenswerte werden verkauft.
Die Funktion CancelAll wird aufgerufen, um alle nicht abgeschlossenen Aufträge zu stornieren und so das Positionsrisiko zu reduzieren.
Überprüfen Sie nach einem erfolgreichen Kauf erneut die Änderung der Kontovermögen. Wenn die Änderung kleiner als 0,001 ist, bedeutet dies, dass der Kauf fehlgeschlagen ist und die Schleife beendet wird.
Schließlich wird festgehalten, ob die Transaktion erfolgreich ist oder nicht, und die Anzahl der Erfolge und Misserfolge wird anhand der Transaktionsergebnisse aktualisiert.

Die gesamte Strategie führt die oben genannten Operationen kontinuierlich durch, um möglichst viele elefanten zu fangen und kleine Gewinne zu erzielen. Dies ist eine Hochfrequenz-Handelsstrategie, die schnelle Reaktionen auf Marktveränderungen erfordert und gleichzeitig Risikomanagement und Stop-Loss-Mechanismen zum Schutz des Kapitals berücksichtigt. Anleger sollten diese Strategie sorgfältig in Betracht ziehen, insbesondere in stark volatilen Märkten.

Zusammenfassung

Die Penny Jump-Strategie ist ein typisches Beispiel für den Hochfrequenzhandel und zeigt das subtile Spiel und den Wettbewerb zwischen den Marktteilnehmern. Diese Strategie ist aufgrund ihrer großen Schwankungen besonders im Kryptowährungsmarkt bekannt, wo institutionelle Investoren und Hochfrequenzhändler alle schnelle Gewinne anstreben. Dies macht den Markt jedoch auch voller Herausforderungen und erfordert ständige Anpassung und Anpassung von Strategien, um Wettbewerbsvorteile zu erhalten. In dieser hart umkämpften Welt können nur diejenigen Händler Erfolg haben, die die Mikrostruktur des Marktes gut erkennen und schnell reagieren.

Mehr