उच्च आवृत्ति ट्रेडिंग रणनीति विश्लेषण - पेनी जंप

उच्च आवृत्ति व्यापार एक चुनौतीपूर्ण और प्रतिस्पर्धी क्षेत्र है जो तेजी से लेनदेन निष्पादन और बाजार की सूक्ष्म संरचना के बारे में संवेदनशील अंतर्दृष्टि पर निर्भर करता है। एक लोकप्रिय रणनीति पेनी कूद है, जो बाजार में "छोटे लेकिन लगातार लाभ" के लिए "छोटे हाथियों" का उपयोग करने पर केंद्रित है। इस लेख में हम पेनी कूद रणनीति के कामकाज के बारे में विस्तार से बताएंगे, साथ ही रणनीति कोड के विवरण में गहराई से प्रवेश करेंगे ताकि शुरुआती लोग समझ सकें कि यह कैसे काम करता है।

पेनी जंप रणनीति को समझें

शेयर बाजारों में, "सिपाही" आमतौर पर उन संस्थागत निवेशकों को संदर्भित करता है जो बड़ी मात्रा में शेयर खरीदना या बेचना चाहते हैं, लेकिन बाजार मूल्य पर व्यापार करने के लिए तैयार नहीं हैं। इसके बजाय, वे बाजार में बड़ी संख्या में सीमा सूची, या लटकन सूची, को अपने इरादे का संकेत देने के लिए चुनते हैं। यह व्यवहार बाजारों में व्यापक रूप से ध्यान आकर्षित करता है क्योंकि बड़े पैमाने पर लेनदेन से बाजार पर महत्वपूर्ण प्रभाव पड़ सकता है।

उदाहरण के लिए, मान लीजिए कि एक शेयर की बाजार गहराई इस तरह थीः 200 $1.01 x $1.03 $200; फिर एक हाथी आया और $1.01 के लिए 3,000 शेयरों का भुगतान किया; अब बाजार गहराई 3,200 हो जाएगी; $1.01 x $1.03 $200; यह एक हाथी को लाने जैसा है, जो बाजार के अन्य खिलाड़ियों के लिए ध्यान का केंद्र बन जाता है।

• प्रतियोगिता बाजार उच्च आवृत्ति व्यापारियों के लिए, उनका लाभ मुख्य रूप से बाजार की सूक्ष्म संरचना के विश्लेषण से आता है ताकि अन्य व्यापारियों के इरादों पर अनुमान लगाया जा सके। एक बार जब कोई हाथी दिखाई देता है, तो उच्च आवृत्ति व्यापारी तेजी से स्थिति स्थापित करेंगे ताकि सूक्ष्म मूल्य उतार-चढ़ाव प्राप्त किया जा सके। उनका लक्ष्य कम समय में बार-बार व्यापार करना है, छोटे लेकिन संचयी लाभ अर्जित करना है।

• हाथियों की समस्या यद्यपि हाथी बाजार में बड़े पैमाने पर संचालन करना चाहते हैं, लेकिन उनके व्यवहार से उनके व्यापारिक इरादे भी सामने आते हैं, जिससे वे उच्च आवृत्ति वाले व्यापारियों के लिए लक्ष्य बन जाते हैं। उच्च आवृत्ति वाले व्यापारी पहले से ही स्थिति बनाने का प्रयास करते हैं और फिर मूल्य में उतार-चढ़ाव के दौरान लाभ प्राप्त करते हैं। हाथी के बाजार में उपस्थिति प्रतिस्पर्धी बाजार प्रतिक्रिया को ट्रिगर कर सकती है, जिससे उनकी व्यापारिक रणनीति प्रभावित होती है।

• बाजार में धोखा वास्तविकता यह है कि बड़े संस्थागत निवेशक आमतौर पर खुले तौर पर बाजार में बड़ी मात्रा में खरीद या बिक्री के आदेश नहीं देते हैं, क्योंकि ऐसा करने से बाजार के अन्य प्रतिभागियों को प्रतिवाद करने और यहां तक कि बाजार में हेरफेर करने का जोखिम होता है। इसलिए, वे उच्च आवृत्ति वाले व्यापारियों को आकर्षित करने के लिए एक मिथक बनाने की रणनीति अपना सकते हैं और फिर तेजी से बेच या खरीद सकते हैं ताकि मूल्य में उतार-चढ़ाव से लाभ प्राप्त किया जा सके।

पेनी जंप रणनीति के मूल विचार

पेनी जंप की रणनीति का मूल विचार यह है कि एक बार जब बाजार में एक हाथी दिखाई देता है और एक निश्चित मूल्य (जैसे $1.01) का समर्थन करता है, तो उच्च आवृत्ति वाले व्यापारी अपनी बोली को तेजी से एक पैसा बढ़ा देंगे, उदाहरण के लिए $1.02 तक। यह इसलिए है क्योंकि उच्च आवृत्ति वाले व्यापारी समझते हैं कि हाथी के दिखाई देने से इस मूल्य का एक मजबूत खरीदार समर्थन होता है, इसलिए वे इसके बाद बढ़ने की उम्मीद करते हैं। जब कीमत वास्तव में $1.03 x $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("调戏次数:", 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);
    }
}

मैं आपके द्वारा प्रदान किए गए रणनीति कोड का चरण-दर-चरण विश्लेषण करूंगा ताकि आपको यह समझने में मदद मिल सके कि यह कैसे काम करता है।

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

यह कोड काउंटर नामक एक वस्तु को आरंभ करता है जिसका उपयोग रणनीति को ट्रैक करने के लिए लेनदेन के सांख्यिकीय जानकारी के लिए किया जाता है; विशेष रूप से, इसमें तीन गुण शामिल हैंः

• 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函数获取当前账户所有挂出的订单，并将它们存储在orders变量中。
• if (orders.length == 0): इस कोड पंक्ति से जांच की जाती है कि क्या कोई अधूरा आदेश है. यदि आदेश सरणी की लंबाई 0 है, तो इसका मतलब है कि कोई अधूरा आदेश नहीं है, तो लूप टूट जाएगा.
• for (var i = 0; i < orders.length; i++): यह एक for लूप है, जो सभी अधूरे आदेशों पर चलता है.
• exchange.CancelOrder(orders[i].Id): इस कोड पंक्ति का उपयोग एक्सचेंज.कैंसलऑर्डर () फ़ंक्शन द्वारा आदेश के आईडी के माध्यम से प्रत्येक आदेश को रद्द करने के लिए किया जाता है।
• Sleep(Interval): इस कोड की पंक्ति में एक प्रतीक्षा चक्र पेश किया गया है, जिसमें कुछ समय के लिए प्रतीक्षा की जाती है (मिलीसेकंड में) यह सुनिश्चित करने के लिए कि ऑर्डर रद्द करने का ऑपरेशन बहुत बार नहीं होता है।

इस फ़ंक्शन का उद्देश्य यह सुनिश्चित करना है कि मुख्य नीति को निष्पादित करने से पहले कोई अधूरा आदेश मौजूद न हो, ताकि मुख्य नीति के निष्पादन में हस्तक्षेप न हो।

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", 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("搜索大象中.... 买一: " + 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);
    }
}

यह रणनीति का मुख्य निष्पादन कार्य है।main()यह रणनीति के मूल तर्क को शामिल करता है. आइए इसके संचालन को पंक्ति-दर-पंक्ति समझाएंः

• if (DisableLog): इस कोड की पंक्ति की जाँच करता है कि क्या DisableLog चर सच है, और यदि ऐसा है, तो लॉग रिकॉर्डिंग को अक्षम कर देता है. यह सुनिश्चित करने के लिए है कि नीति अनावश्यक लॉग रिकॉर्ड नहीं करती है.

• CancelAll(): पहले बताए गए CancelAll () फ़ंक्शन को कॉल करें ताकि यह सुनिश्चित हो सके कि कोई अधूरा ऑर्डर मौजूद नहीं है।

• InitAccount = _C(exchange.GetAccount): इस कोड की पंक्ति वर्तमान खाते की जानकारी प्राप्त करती है और इसे InitAccount चर में संग्रहीत करती है. यह खाता स्थिति को रिकॉर्ड करने के लिए उपयोग किया जाएगा जब नीति निष्पादित होती है.

• var i = 0;औरvar locks = 0;: दो चर 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("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);

• Sleep(Interval): इस कोड की पंक्ति में नीति को निष्पादन की आवृत्ति को नियंत्रित करने के लिए कुछ समय के लिए निष्क्रिय कर दिया गया है. Interval पैरामीटर निष्क्रिय होने के समय के अंतराल को परिभाषित करता है (मिलिसकंड में) ।

• var depth = _C(exchange.GetDepth): वर्तमान बाजार की गहराई से जानकारी प्राप्त करें, जिसमें बिक्री और खरीद के आदेशों के मूल्य और मात्रा शामिल हैं। यह जानकारी गहराई चर में संग्रहीत की जाती है।

• if (depth.Asks.length === 0 || depth.Bids.length === 0): यह कोड लाइन बाजार की गहराई की जानकारी की जांच करती है, यह सुनिश्चित करती है कि ऑर्डर और ऑर्डर दोनों मौजूद हैं। यदि इनमें से कोई भी मौजूद नहीं है, तो यह संकेत देता है कि बाजार में पर्याप्त व्यापार जानकारी नहीं हो सकती है, तो रणनीति इंतजार करती रहती है।

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks): यह कोड पंक्ति update Status फ़ंक्शन को कॉल करती है, जो नीति को अपडेट करने की स्थिति की जानकारी देती है. यह वर्तमान बाजार की स्थिति को रिकॉर्ड करती है, जिसमें एक खरीद, एक बिक्री और पहले लॉक किए गए लॉक की संख्या शामिल है.

    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;: आरंभिक askPrice चर, जिसका उपयोग शर्तों को पूरा करने के लिए बिक्री की कीमतों को संग्रहीत करने के लिए किया जाएगा।

• for (i = 0; i < depth.Asks.length; i++): यह एक for लूप है, जो बाजार में बिकने वाले ऑर्डर के मूल्य और मात्रा के बारे में जानकारी के लिए उपयोग किया जाता है.

• 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;

बाजार में बोली के मूल्य और मात्रा के बारे में जानकारी प्राप्त करने के लिए, पहले बोली (Bids[0]) को छोड़ दें।

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): जांचें कि क्या वर्तमान खरीद मूल्य और पूछ मूल्य के बीच का अंतर ElephantSpace से बड़ा है; यदि हां, तो यह इंगित करता है कि आप हाथी की टांग से पर्याप्त दूर हैं और रणनीति आगे नहीं देख रही है।

• if (depth.Bids[i].Amount >= ElephantAmount): यह जांचता है कि क्या वर्तमान भुगतान की संख्या ElephantAmount से अधिक या उसके बराबर है, यदि हां, तो भुगतान की जानकारी को elephant चर में संग्रहीत किया जाता है।

• if (!elephant): यदि कोई अंडे का हाथी नहीं मिला, तो संख्यात्मक ताले को 0 पर रीसेट कर दिया जाएगा और इंतजार करना जारी रखा जाएगा.

locks++: यदि कोई भैंस का भैंस पाया जाता है, तो तालाबंदी की संख्या में वृद्धि होगी. यह सुनिश्चित करने के लिए है कि एक समय में कई बार भैंस के भैंस के अस्तित्व की पुष्टि करने के बाद नीति को फिर से निष्पादित किया जाए।

• if (locks < LockCount): जाँच करें कि लॉक काउंट की आवश्यकता पूरी हो गई है या नहीं; यदि नहीं, तो प्रतीक्षा जारी रखें.

    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)): अद्यतन स्थिति फ़ंक्शन को कॉल करें, जो नीति के वर्तमान स्थिति को रिकॉर्ड करता है, जिसमें पाया गया गिलहरी का ग्रिड और संबंधित जानकारी शामिल है। यह नीति के स्थिति टैब में दिखाई देगा।

• 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): जांचें कि क्या कोई अधूरा आदेश है, यदि नहीं, तो लूप से बाहर निकलें.

• (new Date().getTime() - ts) > 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("买单得手: " + 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)इस लेख में आप अपने खाते की जानकारी प्राप्त कर सकते हैं।

• var opAmount = _N(account.Stocks - InitAccount.Stocks): खरीद के बाद खाते में परिसंपत्तियों में परिवर्तन की गणना करें. यदि परिवर्तन 0.001 से कम है, तो खरीदारी विफल हो जाती है, विफलता की संख्या बढ़ जाती है और अगले चक्र को जारी रखती है.

• updateStatus("买单得手: " + opAmount + ", 开始出手...")इस लेख में, हम आपके लिए कुछ महत्वपूर्ण जानकारी साझा करते हैं।

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): लाभ के लिए सफलतापूर्वक खरीदे गए हाथी के पंखों को बेचने के लिए exchange.Sell फ़ंक्शन का उपयोग करें.

यह एक नए असीमित चक्र में प्रवेश करता है, जिसका उपयोग बिक्री के आदेशों के निष्पादन के इंतजार में किया जाता है।

• 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): स्टॉप-लॉस ऑपरेशन निष्पादित करें और शेष परिसंपत्तियों को वर्तमान बाजार में सबसे कम कीमत पर बेचें.

अंत में, सफल या असफल लेनदेन के आधार पर, सफल और असफल लेनदेन की संख्या को अपडेट किया जाता है और लेनदेन लाभ दर्ज किया जाता है।

यह पूरी रणनीति की एक पंक्ति-दर-पंक्ति व्याख्या है। इस रणनीति का मूल विचार बाजार में हाथी के हाथी (बहुत अधिक भुगतान) की तलाश करना है, और एक मामूली लाभ प्राप्त करने के लिए खरीदना और बेचना है। इसमें कई महत्वपूर्ण पैरामीटर शामिल हैं, जैसे कि खरीद संख्या (लॉट), त्रुटि पुनः परीक्षण अंतराल (अंतराल), हाथी का स्तर (एलिफेंट एमाउंट), हाथी की दूरी (एलिफेंट स्पेस) आदि, जो रणनीति के व्यवहार को समायोजित करते हैं।

कुल मिलाकर, यह रणनीति एक उच्च आवृत्ति वाली ट्रेडिंग रणनीति है, जिसका उद्देश्य बाजार की गहराई की जानकारी का उपयोग करना है, बड़ी मात्रा में भुगतान की पहचान करना है और कम समय में खरीद-फरोख्त करना है। इसे बाजार की लगातार निगरानी करने और छोटे लाभ के लिए तेजी से खरीद-फरोख्त करने की आवश्यकता है। हालांकि, यह एक उच्च जोखिम वाली रणनीति भी है क्योंकि इसे बाजार में उतार-चढ़ाव के लिए तेजी से प्रतिक्रिया करने की आवश्यकता है, जबकि जोखिम प्रबंधन और स्टॉप-लॉस तंत्र को ध्यान में रखना आवश्यक है ताकि बड़े नुकसान से बचा जा सके।

कृपया ध्यान दें कि यह रणनीति विशिष्ट बाजारों और ट्रेडिंग प्लेटफार्मों पर आधारित है और विभिन्न बाजारों और एक्सचेंजों के लिए उचित समायोजन और अनुकूलन की आवश्यकता हो सकती है। व्यावहारिक अनुप्रयोगों में, निवेशकों को सावधानीपूर्वक परीक्षण और रणनीति के प्रदर्शन का आकलन करने की आवश्यकता होती है ताकि यह सुनिश्चित हो सके कि यह निवेश उद्देश्यों और जोखिम को स्वीकार करने में सक्षम है।

जब आप नीति को निष्पादित करते हैं, तो यह निम्न कार्य करता हैः

1. सबसे पहले, रणनीति बाजार के बारे में गहराई से जानकारी की जांच करती है ताकि वर्तमान बिक्री और खरीद की स्थिति को समझा जा सके।

2, इसके बाद, रणनीति योग्य ऑर्डर खोजने का प्रयास करेगी, विशेष रूप से यदि ऑर्डर की संख्या लॉट (हाथों की संख्या) से अधिक या बराबर है; यदि एक योग्य ऑर्डर पाया जाता है, तो ऑर्डर की कीमत askPrice के रूप में दर्ज की जाती है।

3. फिर रणनीति हाथी के पंखों की तलाश करती रहती है (बहुत सारे भुगतान) ⇒ यह बाजार में सभी भुगतानों को पार करती है और पहले भुगतान को छोड़ देती है (आमतौर पर उच्चतम मूल्य का भुगतान) ⇒ यदि योग्य हाथी के पंख पाए जाते हैं, तो हाथी के पंखों के बारे में जानकारी दर्ज की जाती है और लॉक की संख्या बढ़ जाती है ⇒

4. यदि लगातार पर्याप्त संख्या में एलीफेंट एलीफेंट मिलते हैं (लॉककाउंट पैरामीटर द्वारा नियंत्रित), तो नीति आगे चलती हैः

• अद्यतन स्थिति फ़ंक्शन को कॉल करें, जो हाथी के घोंसले की स्थिति और संबंधित जानकारी दर्ज करता है।
• एक्सचेंज.बुक फ़ंक्शन का उपयोग करके हाथी के लिए हाथी के लिए हाथी खरीदें। मूल्य + पेनीटिक, खरीद की मात्रा के लिए लोट।
• एक नया असीमित चक्र शुरू होता है, जिसका उपयोग खरीद आदेशों के निष्पादन के इंतजार में किया जाता है।
• ऑर्डर की स्थिति की जांच करें, यदि ऑर्डर पूरा हो गया है, तो लूप से बाहर निकलें.
• यदि प्रतीक्षा समय निर्धारित प्रतीक्षा अंतराल ("Wait Interval") से अधिक हो जाता है, तो सभी अधूरे आदेश रद्द कर दिए जाते हैं।
• सफलतापूर्वक खरीदे जाने के बाद खाते की संपत्ति में परिवर्तन की गणना करें, यदि परिवर्तन 0.001 से कम है, तो खरीदारी विफल हो जाती है, विफलता की संख्या बढ़ जाती है और अगले चक्र पर जारी रहती है।
• इस रिपोर्ट के अनुसार, इस रिपोर्ट में सभी अंडे की संख्या के बारे में जानकारी दी गई है।

5. इसके बाद, नीति एक नए असीमित चक्र में आगे बढ़ती है, जिसका उपयोग बिक्री ऑपरेशन के निष्पादन का इंतजार करने के लिए किया जाता है। इस चक्र में, यह निम्नलिखित कार्य करता हैः

• बाजार की गहराई से जानकारी प्राप्त करें और जांचें कि क्या बाजार की कीमतें स्टॉप-लॉस तक पहुंच गई हैं।
• यदि बाजार मूल्य स्टॉप-लॉस मूल्य तक पहुंच जाता है या उससे कम हो जाता है, तो स्टॉप-लॉस ऑपरेशन किया जाता है, यानी शेष संपत्ति बेची जाती है।
• CancelAll फ़ंक्शन का उपयोग करके, सभी अधूरे आदेशों को रद्द करें ताकि भंडारण जोखिम को कम किया जा सके।
• फिर से खरीदारी के सफल होने के बाद खाता संपत्ति में परिवर्तन की जांच करें, यदि परिवर्तन 0.001 से कम है, तो खरीदारी विफल हो गई है और चक्र से बाहर निकल गई है।
• अंत में, ट्रेडों की सफलता या असफलता दर्ज की जाती है, और ट्रेडों के परिणामों के आधार पर सफल और असफल संख्या अपडेट की जाती है।

यह एक उच्च आवृत्ति वाली ट्रेडिंग रणनीति है, जिसमें बाजार में तेजी से बदलाव के लिए तेजी से प्रतिक्रिया करने की आवश्यकता होती है, जबकि पूंजी की सुरक्षा के लिए जोखिम प्रबंधन और स्टॉप-लॉस तंत्र पर विचार किया जाना चाहिए। निवेशकों को इस रणनीति का उपयोग करने पर सावधानीपूर्वक विचार करना चाहिए, खासकर अत्यधिक अस्थिर बाजारों में।

समापन

पेनी जंप रणनीति उच्च आवृत्ति व्यापार में एक आदर्श उदाहरण है, जो बाजार के प्रतिभागियों के बीच सूक्ष्म खेल और प्रतिस्पर्धा का प्रदर्शन करती है। क्रिप्टोकरेंसी बाजार में, यह रणनीति विशेष रूप से प्रमुख है क्योंकि बाजार में भारी उतार-चढ़ाव होता है और संस्थागत निवेशक और उच्च आवृत्ति वाले व्यापारी तेजी से लाभ की तलाश करते हैं। हालांकि, यह बाजार को चुनौतीपूर्ण भी बनाता है और प्रतिस्पर्धात्मक लाभ बनाए रखने के लिए रणनीति को लगातार अनुकूलित और समायोजित करने की आवश्यकता होती है। इस तीव्र प्रतिस्पर्धी दुनिया में, केवल वे व्यापारी जो बाजार की सूक्ष्म संरचना को अच्छी तरह से समझते हैं और जल्दी से प्रतिक्रिया करते हैं, सफल हो सकते हैं।