資源の読み込みに... 荷物...
  1. 消化する
  2. 原作
  3. 高周波取引戦略分析 - ペニージャンプ

高周波取引戦略分析 - ペニージャンプ

作者: リン・ハーンFMZ~リディア作成日:2023年11月07日 10:44:20 更新日:2024年1月01日 12:19:43

img

高周波取引は,迅速な取引実行と市場の微小構造への敏感な洞察力に依存する挑戦的で競争的な分野である.注目すべき戦略の一つはペニージャンプである.ペニージャンプ戦略は,市場における"象"を搾取して小規模な但し頻繁な利益を得ることに焦点を当てている.この記事では,ペニージャンプ戦略がどのように機能するかを詳細に説明し,そのコードの詳細を掘り下げ,初心者がどのように動作するかを理解できるようにします.

ペニー ジャンプ の 戦略 を 理解 する

株式市場では,大多数の株式を購入または売却したいが,市場価格で取引することを望まない機関投資家を指す.その代わりに,彼らは市場に多くの制限オーダー,すなわち待機中のオーダーを掲示することを選択し,彼らの意図を示す.この行動は,大きな取引が市場に大きな影響を与える可能性があるため,市場で広範な注目を集めている.

例えば,株市場の元の深さはこうだったとします. 200 ∙$1.01 x $1.03 ∙$200. それから,象が入り,それぞれ1.01 ドルで 3000 株の購入オーダーをします. この時点で,市場の深さは 3,200 ∙$1.01 x $1.03 ∙$200 に変わります. この行動は,象を導入するのと同じで,それは市場の他の参加者の注目を集めます.

  • 競争市場 高周波トレーダーは,他のトレーダーの意図を推測するために市場微細構造の分析から利益を得ている.大きなプレイヤーが現れたら,高周波トレーダーはわずかな価格変動を把握するために迅速にポジションを確立する.彼らの目標は短い時間で頻繁に取引し,小さくも累積的な利益を得ることです.

  • ゾウ の 難題 象は市場において大規模に活動したいと考えても,その行動によって取引の意図も明らかになり,高周波トレーダーのターゲットとなる.高周波トレーダーは,より早くポジションを確立し,価格変動から利益を得ようとする.市場における象の存在は競争力のある市場での反応を引き起こし,それによって取引戦略に影響を与える.

  • 市場 で の 欺瞞 実際,大規模な機関投資家は,通常,大量に市場に買取または売却の注文を公然と行わない.そのような行動は,他の市場参加者が対策をとり,市場を操るに至る可能性があるため,幻想を生み出す戦略を採用し,高周波トレーダーをフィールドに誘致し,価格変動から利益を得るために迅速に販売または購入する可能性があります.

ペニー ジャンプ 戦略 の 基本 理念

ペニージャンプ戦略の核心理念は,市場に"ビッグプレイヤー"が現れ,特定の価格 (例えば1.01ドル) をサポートすると,高周波トレーダーはすぐにオファーを1セントで,例えば1.02ドルに上げます.これは,高周波トレーダーは,この価格レベルで大きなプレイヤーが現れることが強い購入サポートがあることを理解しているため,価格上昇の希望で注意深く追跡しようとします.価格が実際に1.03ドル×1.05ドルに上昇すると,高周波トレーダーは迅速に販売し,0.01ドルの利益を得ることができます.

高周波トレーダーは 価格が上昇しない場合でも 購入後に利益を得ることができます なぜなら 大手株主が ベース価格を支えていることを 知っているからです そのため 株をこの大手株主に 迅速に売却して わずかな利息を得ることができます

ペニージャンプ戦略コードを分析する

戦略のソースコード:https://www.fmz.com/strategy/358

上記の戦略コードは,ペニージャンプ戦略を実装するために使用される例です.以下は,コードの詳細な説明で,初心者がどのように動作するかを理解することができます:

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

戦略コードを一行一行解析して 詳細に理解できるようにします

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

このコードはCounterというオブジェクトを初期化し,戦略の取引統計情報を追跡するために使用されます.具体的には,3つの属性を含みます.

  • i: 取引総数を表します.
  • w: 成功した取引の数を表します.
  • f: 失敗した取引の数を表します.

これらの属性は,戦略実行プロセス中に記録され更新されます.

var InitAccount = null;

このコード行では InitAccount という変数を初期化し,戦略が実行開始時にアカウント情報を格納します.

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

この関数はCancelAll()市場でのすべての未履行注文をキャンセルする目的です. その機能を段階的に説明しましょう:

  • while (true): これは無限のループで,未完成の注文がなくなるまで実行し続けます.
  • var orders = _C(exchange.GetOrders): このコード行は,Exchange.GetOrders関数を使って,現在口座のすべての待機中の注文を取得し,注文変数に保存します.
  • if (orders.length == 0): このコード行では,未完成の注文をチェックします.注文配列の長さが0である場合は,未完成の注文がないことを意味し,ループは中断されます (break).
  • for (var i = 0; i < orders.length; i++): これはすべての未完了命令を繰り返す for ループです.
  • exchange.CancelOrder(orders[i].Id): このコード行は,各注文のIDでキャンセルするために,exchange.CancelOrder() 関数を使用します.
  • Sleep(Interval): このコードラインでは,キャンセル注文の操作が頻繁すぎないようにするために,一定の時間 (ミリ秒で) の間断で待ち期間を導入します.

このコードラインでは,キャンセルオーダーの操作が頻繁すぎないようにするために,一定の時間 (ミリ秒) の間,一時停止する等待期間を導入します.

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

この関数はupdateStatus(msg), これは取引状況情報を更新および記録するために使用されます. 通常,現在の市場状況に関する情報を含むmsgパラメータを受け入れます. 機能の特定の操作には以下が含まれます:

システムを使用LogStatus()戦略実行中にステータスバーに表示される情報を記録する機能.取引数,成功数,失敗数に関するテキストを表示します. についてmsgこのパラメータには,現在の市場状況に関する情報が含まれています. 現在のタイムスタンプ (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);
    }
}

これは主要な実行機能ですmain()戦略の基本論理をまとめており,その操作を一行一行説明します.

  • if (DisableLog): このコード行では, DisableLog 変数が真であるかどうかをチェックし,そうであれば,ログの記録を無効にする.これは,戦略によって不必要なログが記録されないことを確保するためです.

  • CancelAll(): 先ほど説明した CancelAll() 関数を呼び出し,未完成の注文がないことを確認します.

  • InitAccount = _C(exchange.GetAccount): このコード行は,現在の口座情報を取得し,InitAccount変数に保存します.これは,戦略が実行開始時にアカウントの状態を記録するために使用されます.

  • var i = 0;そしてvar locks = 0;次の戦略論理で使用される2つの変数,iとlocksを初期化します.

  • while (true): これは無限のループで,主に戦略の継続的な実行に使用されます.

戦略の論理について説明します.while (true)ループのラインごとに

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): このコード行は,戦略の実行頻度を制御するために,戦略を一定期間眠らせます.Intervalパラメータは睡眠間隔 (ミリ秒で) を定義します.

  • var depth = _C(exchange.GetDepth): 販売注文や購入注文の価格と量を含む現在の市場深度情報を取得します.この情報は深度変数に保存されます.

  • if (depth.Asks.length === 0 || depth.Bids.length === 0): このコード行は,市場深度情報をチェックし,売り注文と買い注文の両方が存在していることを確認します. どちらかが存在しない場合,市場は十分な取引情報を持っていないことを示します.したがって戦略は待機し続けます.

  • updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ", Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks): このコード行は,updateStatus関数を呼び出し,戦略の状態情報を更新します.最高入札価格,最低入札価格,以前にロックされた時間 (ロック) を含む現在の市場状態を記録します.

    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;条件を満たす販売注文の価格を保存するために使用されます.

  • for (i = 0; i < depth.Asks.length; i++)これは,市場販売注文の価格と量情報を横断するために使用されるフォアループです.

  • if (depth.Asks[i].Amount >= Lot): ループの中で,各セールオーダーの量が指定されたロット (手数) よりも大きいか等しいかを確認します.そうであれば,そのセールオーダーの価格を askPrice に保存し,ループを終了します.

  • if (askPrice === 0):条件を満たすセールオーダーが見つからない場合 (askPriceはまだ0である) は,戦略は待機を続け,次の操作をスキップします.

  • var elephant = null;購入注文情報を保存するために使用されます.

    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;

市場購入注文の価格と量情報を通過し続け,最初の購入注文 (オファー[0]) をスキップします.

  • if ((askPrice - depth.Bids[i].Price) > ElephantSpace): 現在の入札価格と askPrice の間のギャップが ElephantSpace よりも大きいかどうかを確認します.そうであれば,それは elephant から十分に遠くにあることを示し,戦略はもはや検索を続けません.

  • if (depth.Bids[i].Amount >= ElephantAmount): 現在の購入注文の量が ElephantAmount よりも大きいか等しいかを確認します.そうであれば,購入注文情報を elephant 変数に保存します.

  • if (!elephant): 象が見つからない場合は 鍵数を0にリセットし,待機を続けます.

  • locks++: 象が見つかった場合,ロック数を増加します.これは,ある期間中に複数回象の存在を確認した後でのみ戦略を実行することを保証します.

  • if (locks < LockCount): 鍵回数が要件を満たしているかどうかを確認します (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)): updateStatus関数を呼び出し,見つかった"ゾウ"のギア位置および関連する情報を含む戦略の現在の状態を記録します.これは戦略の状態バーに表示されます.

  • exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): 交換.購入関数を用いて見つけた"ゾウ"を購入します. 購入価格は"ゾウ".価格+ペニーティック,購入量は"ロット"で,購入操作を"入札[ + i + ]"と記述します.

  • var ts = new Date().getTime(): 時間の間隔の後の計算のために現在の時間のタイムスタンプを取得します.

  • while (true)象購入注文の実行を待つために使用される新しい無限ループを入力します.

  • Sleep(CheckInterval): 戦略は,注文の状態のチェックの頻度を制御するためにしばらく休眠します.

  • var orders = _C(exchange.GetOrders)流通口座のすべての注文情報を取得します.

  • if (orders.length == 0):未完成の注文があるか確認します. そうでない場合は,ループを壊します.

  • (new Date().getTime() - ts) > WaitInterval: 現在の時間と"ゾウ"が購入された時の間隔を計算します.もしWaitIntervalを超えると,待機が終了しました.

  • for (var i = 0; i < orders.length; i++)完成していない注文をすべて調べる

  • 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("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)■ 経金口座の情報を入手する.

  • var opAmount = _N(account.Stocks - InitAccount.Stocks)象を購入した後の口座資産の変化を計算します.変化が0.001未満であれば,購入が失敗したことを示します.失敗数を増加して次のループに続きます.

  • updateStatus("Successful payment: " + opAmount + ", Start taking action...")象の購入成功の情報を記録し,購入量を含みます.

  • exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): 交換.販売機能を使用して,成功して購入した"ゾウ"を利益を得るために販売します.販売価格は"ゾウ".価格+ (ペニーティック*プロフィットティック).

新しい無限ループを入力します 売り注文の実行を待つために使われます

  • var depth = _C(exchange.GetDepth): 市場に関する詳細な情報を得る.

  • if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): 市場の深度情報をチェックし,市場価格が既にストップ・ロスのレベルに下落しているかどうかを確認し,ストップ・ロスの操作を実行します.

  • CancelAll(): ポジションリスクを回避するために,すべての未完了注文をキャンセルするために,CancelAll() 関数を呼び出します.

  • if (opAmount < 0.001): 購入量を再確認します. 0.001未満なら,購入が失敗したことを示します. ループを外します.

  • exchange.Sell(depth.Bids[0].Price, opAmount)ストップ・ロスを実行し,残った資産を現在の市場の最低価格で売却します.

最後に,取引が成功したか否かに基づいて,成功した取引と失敗した取引の数を更新し,取引利益を記録します.

この戦略は,全体的な戦略の一行一行説明です.この戦略の核心構想は,市場で"大買い注文" (elephants) を見つけ,小利益を得るためにそれらを購入して売却することです.戦略を調整するために,ロット,エラー再試行間隔 (Interval),ElephantAmount,ElephantSpaceなどいくつかの重要なパラメータが含まれています.

一般的には,この戦略は,大きな買い注文を特定し,短い期間で買い売り取引を行うために市場深度情報を活用することを目的とした高周波取引戦略である.それは,市場を常に監視し,小さな利益を迅速に獲得するために買い売り操作を実行する必要がある.しかし,それは,重大な損失を避けるためにリスク管理とストップロスのメカニズムを検討しながら,市場の変動に迅速な対応を必要とするため,高リスクの戦略でもある.

戦略は特定の市場や取引プラットフォームに基づいていることに注意してください.異なる市場や取引所では,適切な調整と最適化が必要かもしれません.実用的な応用では,投資家は戦略のパフォーマンスを慎重にテストし,評価し,投資目標とリスク耐性と一致していることを確認する必要があります.

戦略を実行し続けると,次のような操作を繰り返し実行します.

  1. まず,この戦略は,販売注文と購入注文の現状を理解するために,市場の詳細な情報を検証します.

  2. 次に,戦略は,基準を満たす販売注文,特にロットよりも大きいまたはそれと同等の量を持つ販売注文を見つけようとします. 適格な販売注文が見つかった場合,販売注文の価格は askPrice として記録されます.

  3. この戦略は,市場全体で1つ目の購入注文 (通常は最も高い価格の購入注文) を跳ね出して,市場全体で1つ目の購入注文 (通常は最も高い価格の購入注文) を横断します.基準を満たす"象"を見つけると,その象に関する情報を記録し,ロックを増やします.

  4. 連続して十分な数の"ゾウ"が見つかった場合 (LockCountパラメータによって制御される),戦略は次の操作を実行します.

  • updateStatus関数を呼び出し,象の道具と関連情報を記録します.
  • エレファントの購入価格 + ペニーティックとロットの数値で,エレファントを購入するには,交換.購入機能を使用します.
  • 新しい無限ループを起動して 購入命令の実行を待っています
  • 命令の状態を確認します. 完了した場合,ループから抜けます.
  • 待ち時間が設定された間隔 (WaitInterval) を超えると,未完了の注文をすべてキャンセルします.
  • 成功した購入後に口座資産の変化を計算します.変更が0.001未満であれば,購入が失敗したことを示します.失敗数を増加して次のループを継続します.
  • 象の成功購入に関する情報を記録し,購入量も含む.
  1. 次に,戦略は新しい無限ループに入り,セールオペレーションの実行を待っています.このループでは,次のアクションを実行します:
  • 市場の深度情報を取得し,市場価格が既にストップ・ロスのレベルに達しているかどうかを確認します.
  • 市場価格がストップ・ロスの値に達するか,またはその値を下回った場合,ストップ・ロスの取引が行われ,つまり残った資産が売却されます.
  • CancelAll関数を呼び出し,完了していない注文をすべてキャンセルし,ポジションリスクを減らす.
  • 購入が成功した後,アカウント資産の変更を再確認します.変更が0.001未満である場合は,購入が失敗したことを示し,ループを終了します.
  • 最後に,取引が成功したか否かを記録し,取引結果に基づいて成功や失敗の数を更新します.

この戦略は,できるだけ多くの"象"を捕獲し,小利益を得るために,上記の操作を継続的に実行する.これは市場変化に迅速な対応を必要とする高頻度取引戦略であり,同時に資本を保護するためのリスク管理とストップ損失メカニズムも考慮する必要があります.投資家は,特に不安定な市場で,この戦略を使用することを慎重に検討する必要があります.

概要

ペニージャンプ戦略は,高周波取引における典型的な例であり,市場参加者の間の微妙なゲームと競争を示している.この戦略は,機関投資家と高周波トレーダーがすべて迅速な利益を追求している大きな変動のため,仮想通貨市場で特に顕著である.しかし,これはまた,競争優位性を維持するために戦略の継続的な適応と調整を必要とする課題に満ちた市場にもなっている.この激烈な競争の世界では,市場の微細構造を識別し,迅速に対応するのが良いトレーダーだけが成功を収める.

もっと

2019 FMZ - すべての権利は保護されています.