Analyse des stratégies de trading à haute fréquence - Penny Jump

La négociation à haute fréquence est un domaine difficile et compétitif qui repose sur une exécution rapide des transactions et une sensibilité à la microstructure du marché. Une des stratégies les plus populaires est le Penny Jump, qui se concentre sur l'utilisation d'un " éléphant " du marché pour réaliser des bénéfices minimes mais fréquents. Dans cet article, nous expliquerons en détail le fonctionnement de la stratégie Penny Jump, tout en explorant les détails du code de la stratégie afin de permettre aux débutants de comprendre comment elle fonctionne.

Comprendre la stratégie de Penny Jump

Dans les marchés boursiers, " éléphant " désigne généralement les investisseurs institutionnels qui souhaitent acheter ou vendre une grande quantité d'actions, mais qui ne sont pas disposés à négocier au prix du marché. Au lieu de cela, ils choisissent d'afficher un grand nombre de listes de prix limitées sur le marché pour montrer leur intention.

Par exemple, supposons que la profondeur de marché d'une action ait été 200 $1.01 x $1.03 200. Ensuite, un éléphant est entré et a accroché une facture de 3 000 actions à 1,01 $.

• Le marché du jeu Pour les traders à haute fréquence, leurs profits proviennent principalement de l'analyse de la structure microscopique du marché pour deviner les intentions des autres traders. Une fois qu'un éléphant apparaît, les traders à haute fréquence vont rapidement établir des positions pour obtenir de minuscules fluctuations de prix. Leur objectif est de trader fréquemment dans un court laps de temps et d'accumuler des profits minimes mais cumulés.

• Le problème des éléphants Bien que les éléphants puissent vouloir opérer massivement sur le marché, leur comportement expose également leurs intentions de trading, ce qui les rend la cible des traders à haute fréquence. Les traders à haute fréquence tentent de construire des positions à l'avance pour ensuite profiter des fluctuations de prix. La présence d'éléphants sur le marché peut déclencher une réaction concurrentielle du marché, ce qui influence leur stratégie de trading.

• La tromperie sur le marché En réalité, les grands investisseurs institutionnels ne sont généralement pas enclins à afficher ouvertement de nombreux ordres d'achat ou de vente sur le marché, car ce comportement peut entraîner des contre-mesures, voire la manipulation du marché, par d'autres acteurs du marché. Ils peuvent donc adopter des stratégies visant à créer un faux, à attirer des traders à haute fréquence, puis à vendre ou à acheter rapidement pour tirer profit des fluctuations des prix.

L'idée centrale de la stratégie Penny Jump

L'idée centrale de la stratégie de Penny Jump est que, une fois qu'un éléphant apparaît dans le marché et soutient un prix spécifique (par exemple, 1.01 $), les traders à haute fréquence augmenteront rapidement leur offre d'un centime, par exemple, à 1.02 $.

De plus, les traders à haute fréquence peuvent réaliser un profit après l'achat, même si le prix n'est pas en hausse. Comme ils savent que l'éléphant soutient le prix inférieur, ils peuvent rapidement vendre des actions à cet éléphant pour un profit marginal minime.

Déchiffrer le code de la stratégie Penny Jump

Le code source de la stratégie:https://www.fmz.com/strategy/358

Le code de stratégie fourni ci-dessus est un exemple d'une stratégie de Penny Jump. Voici une explication détaillée du code pour aider les débutants à comprendre comment cela fonctionne:

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

Je vais parcourir le code de stratégie que vous avez fourni par étape pour vous aider à comprendre en détail comment il fonctionne.

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

Ce code initie un objet appelé Counter, qui est utilisé pour suivre les statistiques de transaction des stratégies. Plus précisément, il comprend trois attributs:

• i: indique le nombre total de transactions.
• w: indique le nombre de transactions réussies.
• f: indique le nombre de transactions qui ont échoué.

Ces attributs seront enregistrés et mis à jour au cours de l'exécution de la politique.

var InitAccount = null;

Cette ligne de code initie une variable appelée initAccount qui stocke les informations de l'account au moment où la politique commence à s'exécuter.

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

Il s'agit d'unCancelAll()La fonctionnalité qui permet d'annuler toutes les commandes en suspens sur le marché.

• while (true): c'est un cycle sans fin qui va continuer à fonctionner jusqu'à ce qu'il n'y ait plus d'ordres en suspens.
• var orders = _C(exchange.GetOrders)：这一行代码使用exchange.GetOrders函数获取当前账户所有挂出的订单，并将它们存储在orders变量中。
• if (orders.length == 0): Cette ligne de code vérifie s'il y a des commandes en suspens. Si la longueur de l'array de commandes est de 0, cela signifie qu'il n'y a pas d'ordres en suspens, le cycle est interrompu.
• for (var i = 0; i < orders.length; i++): c'est un for cycle qui traverse toutes les commandes non terminées.
• exchange.CancelOrder(orders[i].Id): Cette ligne de code utilise la fonction exchange.CancelOrder (), pour annuler chaque commande à l'aide de l'ID de la commande.
• Sleep(Interval): Cette ligne de code introduit un cycle d'attente, pendant lequel il faut attendre un certain temps (en millisecondes) pour s'assurer que l'opération d'annulation d'une commande n'est pas trop fréquente.

Le but de cette fonction est de s'assurer qu'aucune commande inachevée n'existe avant l'exécution de la politique principale, afin d'éviter d'interférer avec l'exécution de la politique principale.

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

Il s'agit d'unupdateStatus(msg)Une fonction utilisée pour mettre à jour les informations sur l'état des transactions et les enregistrer. Elle accepte un paramètre msg, qui contient généralement des informations sur l'état actuel du marché.

UtilisationLogStatus()La fonction enregistre les informations affichées dans la barre d'état lorsque la stratégie est exécutée. Elle affiche le texte concernant le nombre de transactions, le nombre de succès et le nombre de défaillances. AjoutéemsgParamètres qui contiennent des informations sur l'état actuel du marché. Ajout d'une barre d'heure actuellenew Date()Le temps est indiqué par le bouton de connexion. La fonction vise à enregistrer et à mettre à jour les informations sur l'état des transactions afin de permettre la surveillance et l'analyse pendant l'exécution de la stratégie.

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

C'est la principale fonction d'exécution de la stratégie.main()Il contient la logique de base de la stratégie. Expliquons-le ligne par ligne:

• if (DisableLog): Cette ligne de code vérifie si la variable DisableLog est vraie et, si oui, désactive les journaux enregistrés. Ceci est fait pour s'assurer que la politique n'enregistre pas de journaux inutiles.

• CancelAll(): appeler la fonction CancelAll (() expliquée précédemment pour s'assurer qu'il n'y a pas d'ordre en suspens.

• InitAccount = _C(exchange.GetAccount): Cette ligne de code obtient des informations sur le compte actuel et les stocke dans une variable initAccount.

• var i = 0;etvar locks = 0;: initialement deux variables i et locks, qui seront utilisées dans la logique de stratégie suivante.

• while (true): c'est un cycle sans fin, principalement utilisé pour l'exécution continue de la stratégie.

Nous allons vous expliquer ceci, ligne par ligne.while (true)La logique stratégique principale dans le cercle.

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): cette ligne de code laisse la stratégie en sommeil pendant un certain temps pour contrôler la fréquence d'exécution de la politique.

• var depth = _C(exchange.GetDepth)Les informations de profondeur sont stockées dans les variables de profondeur.

• if (depth.Asks.length === 0 || depth.Bids.length === 0): Cette ligne de code vérifie les informations de profondeur du marché pour s'assurer que les ordres de vente et d'achat sont présents. Si l'un d'eux n'existe pas, cela signifie que le marché n'a peut-être pas suffisamment d'informations de transaction, la stratégie continue d'attendre.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks): Cette ligne de code appelle la fonction update Status, qui permet de mettre à jour la politique. Elle enregistre l'état actuel du marché, y compris le prix d'achat, le prix de vente et le nombre de verrouillages précédents.

    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;: Initializez la variable AskPrice, qui sera utilisée pour stocker le prix des offres de vente qui répondent aux conditions.

• for (i = 0; i < depth.Asks.length; i++): Il s'agit d'une boucle for, qui est utilisée pour traverser le marché pour obtenir des informations sur le prix et la quantité des enchères.

• if (depth.Asks[i].Amount >= Lot): dans le cycle, vérifie si le nombre de commandes est supérieur ou égal à la quantité de lot (numéro de mains) indiquée. Si c'est le cas, stockez le prix de la commande dans AskPrice et terminez le cycle.

• if (askPrice === 0): Si aucune offre de vente ne s'affiche (askPrice est toujours 0), la stratégie continue d'attendre et saute les opérations suivantes.

• var elephant = null;: Initializez la variable elephant, qui sera utilisée pour stocker les informations de paiement identifiées comme étant de l'ivoire.

    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;

Continuez à parcourir les informations sur le prix et la quantité des offres sur le marché, en sautant la première offre (Bids[0]) ;

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): Vérifiez si l'écart entre le prix d'achat actuel et le prix d'achat est plus grand que ElephantSpace. Si oui, indiquez que vous êtes suffisamment éloigné de l'éléphant de l'œuf pour que la stratégie ne continue pas de chercher.

• if (depth.Bids[i].Amount >= ElephantAmount): vérifie si le montant de la facture en cours est supérieur ou égal à ElephantAmount, et si oui, stocke l'information de la facture dans la variable elephant.

• if (!elephant): Si le bouchon d'éléphant n'est pas trouvé, le verrouillage des verrous numériques est réinitialisé à 0 et continue d'attendre.

locks++: Si l'on trouve une alligator, le nombre de verrouillages est augmenté. Ceci est fait pour s'assurer que la politique est exécutée après plusieurs confirmations de l'existence de l'alligator sur une période de temps.

• if (locks < LockCount): Vérifiez que le nombre de verrouillages est atteint. Si ce n'est pas le cas, continuez à attendre.

    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)): appeler la fonction Update Status, qui enregistre l'état actuel de la politique, y compris le classement et les informations relatives à l'écorce d'ivoire trouvée.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): utilisez la fonction exchange.Buy pour acheter une souris trouvée. Le prix d'achat est elephant.Price + PennyTick, la quantité d'achat est Lot, et l'opération d'achat est décrite comme "Bids[" + i + ] souris".

• var ts = new Date().getTime(): Obtenez le timestamp de l'heure actuelle afin de calculer l'intervalle de temps ultérieurement.

• while (true): entrer dans un nouveau cycle sans fin pour l'exécution des commandes en attente d'achat d'éléphants.

• Sleep(CheckInterval)La stratégie est en sommeil pendant un certain temps pour contrôler la fréquence de vérification de l'état des commandes.

• var orders = _C(exchange.GetOrders)Vous pouvez consulter les informations sur les commandes effectuées sur votre compte en cours.

• if (orders.length == 0): vérifie s'il y a des commandes en suspens ou, si ce n'est pas le cas, quitte le cycle.

• (new Date().getTime() - ts) > WaitInterval: calculer l'intervalle entre l'heure actuelle et l'heure d'achat de l'oie d'ivoire, si elle est supérieure à l'intervalle d'attente, cela signifie que l'attente est dépassée.

• for (var i = 0; i < orders.length; i++)Le site Web de l'entreprise est en ligne:

• 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)Vous pouvez consulter les informations de votre compte en ligne:

• var opAmount = _N(account.Stocks - InitAccount.Stocks): calculer les changements d'actifs dans le compte après l'achat de l'éléphant-garou. Si le changement est inférieur à 0,001, indique que l'achat a échoué, augmente le nombre de défaillances et continue le cycle suivant.

• updateStatus("买单得手: " + opAmount + ", 开始出手...")Les informations sur les achats réussis d'ivoire, y compris le nombre d'achats, sont enregistrées.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): utilisez l'exchange.Sell pour vendre les œillets d'éléphants que vous avez achetés avec succès et obtenir un profit.

L'exécution des commandes en attente de vente s'insère dans un nouveau cycle indéfini.

• var depth = _C(exchange.GetDepth)Le blogueur a également publié un article intitulé:

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick)))L'opérateur peut également vérifier la profondeur du marché et exécuter des opérations de stop-loss si le prix du marché est déjà tombé au niveau du stop-loss.

• CancelAll()Pour éviter le risque d'entreposage, appeler la fonction CancelAll (//) pour annuler toutes les commandes en suspens.

• if (opAmount < 0.001): Vérifiez à nouveau le nombre d'achats, si moins de 0.001, cela signifie que l'achat a échoué et qu'il est sorti du cercle.

• exchange.Sell(depth.Bids[0].Price, opAmount)Les investisseurs ont décidé d'effectuer des opérations de stop-loss pour vendre les actifs restants au prix le plus bas du marché.

Enfin, le nombre de transactions réussies et non réussies est mis à jour en fonction de la réussite de la transaction et le profit de la transaction est enregistré.

C'est l'explication de l'ensemble de la stratégie. L'idée de base de cette stratégie est de trouver des éléphants dans le marché (payant beaucoup) et de les acheter et de les vendre pour obtenir un petit profit. Elle comprend plusieurs paramètres importants, tels que le nombre d'achats (Lot), l'intervalle de répétition des erreurs (Interval), le niveau des éléphants (ElephantAmount) et la distance des éléphants (ElephantSpace) pour ajuster le comportement de la stratégie.

Dans l'ensemble, cette stratégie est une stratégie de négociation à haute fréquence qui vise à tirer parti de l'information profonde du marché, à identifier un grand nombre de paiements et à effectuer des transactions à la vente dans un court laps de temps. Elle nécessite de surveiller en permanence le marché et d'effectuer des opérations de vente pour obtenir rapidement de minuscules profits. Cependant, c'est aussi une stratégie à haut risque car elle nécessite de réagir rapidement aux fluctuations du marché, tout en tenant compte de la gestion des risques et des mécanismes d'arrêt des pertes afin d'éviter des pertes importantes.

Veuillez noter que cette stratégie est basée sur des marchés et des plateformes spécifiques et peut nécessiter des ajustements et des optimisations appropriés pour différents marchés et échanges. Dans les applications pratiques, les investisseurs doivent tester et évaluer soigneusement la performance de la stratégie pour s'assurer qu'elle correspond à leurs objectifs d'investissement et à leur capacité à supporter les risques.

Si vous continuez à exécuter la politique, elle exécute en boucle les actions suivantes:

1° Tout d'abord, la stratégie examine des informations approfondies sur le marché pour connaître les conditions actuelles des ventes et des achats.

2, la stratégie va ensuite essayer de trouver les bons de vente éligibles, en particulier si le nombre de bons de vente est supérieur ou égal à Lot (nombre de mains). Si les bons de vente éligibles sont trouvés, le prix des bons de vente est enregistré comme AskPrice.

3, puis, la stratégie continue à chercher le bouchon d'éléphant (une quantité importante de paiements); elle parcourt les paiements sur le marché, en sautant le premier paiement (généralement le paiement le plus élevé); si un bouchon d'éléphant de bouchon éligible est trouvé, l'information sur le bouchon d'éléphant de bouchon est enregistrée et le nombre de verrouillages est augmenté (blocs).

4, si une quantité suffisante de chiffres d'éléphants est trouvée (contrôlée par le paramètre LockCount), la stratégie effectue les opérations suivantes:

• Appelle la fonction update Status pour enregistrer le classement et les informations relatives à l'écorce d'éléphant.
• Utilisez l'exchange.Buy pour acheter des œufs d'éléphant, au prix de l'éléphant.Price + PennyTick, au nombre de lots.
• Une nouvelle boucle indéfinie est lancée pour l'exécution des commandes en attente.
• Vérifiez l'état de la commande et sautez la boucle si celle-ci est terminée.
• Si le temps d'attente dépasse l'intervalle d'attente défini, toutes les commandes non terminées sont annulées.
• Calculer la variation de l'actif du compte après un achat réussi, si la variation est inférieure à 0,001, indique que l'achat a échoué, augmente le nombre de défaillances et continue le cycle suivant.
• Les informations sur les achats réussis d'ivoire, y compris le nombre d'achats, sont enregistrées.

5. Ensuite, la stratégie continue dans une nouvelle boucle infinie, en attendant l'exécution de l'opération de vente. Dans cette boucle, elle exécute les opérations suivantes:

• Il s'agit d'un outil qui permet d'obtenir des informations détaillées sur le marché et de vérifier si le prix du marché a atteint son niveau de stop-loss.
• Si le prix du marché atteint ou est inférieur au prix d'arrêt, une opération d'arrêt est effectuée, c'est-à-dire la vente de l'actif restant.
• Appelle la fonction CancelAll pour annuler toutes les commandes en suspens afin de réduire le risque de stockage.
• Vérifiez à nouveau la variation de l'actif du compte après l'achat réussi, si la variation est inférieure à 0.001, cela signifie que l'achat a échoué et qu'il a quitté le cycle.
• Enfin, il enregistre la réussite de la transaction et met à jour le nombre de transactions réussies et non réussies en fonction des résultats.

L'ensemble de la stratégie consiste à exécuter les opérations ci-dessus en cycles pour capturer le plus grand nombre possible d'éléphants et réaliser de minuscules profits. C'est une stratégie de trading à haute fréquence qui nécessite une réponse rapide aux changements du marché, tout en tenant compte de la gestion des risques et des mécanismes de stop-loss pour protéger les capitaux. Les investisseurs devraient envisager prudemment d'utiliser cette stratégie, en particulier dans des marchés très volatiles.

Le mot de la fin

La stratégie Penny Jump est un exemple typique du trading à haute fréquence, qui montre le jeu subtil et la concurrence entre les acteurs du marché. Dans le marché de la crypto-monnaie, cette stratégie est particulièrement remarquable car le marché est très volatil et les investisseurs institutionnels et les traders à haute fréquence recherchent des profits rapides. Cependant, cela rend également le marché difficile et nécessite une adaptation et un ajustement constants des stratégies pour maintenir un avantage concurrentiel.