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

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

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

उदाहरण के लिए, मान लीजिए कि किसी स्टॉक की बाजार गहराई मूल रूप से इस प्रकार थी: 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++): यह एक फॉर लूप है जो सभी बकाया ऑर्डरों को दोहराता है।
• exchange.CancelOrder(orders[i].Id): कोड की यह पंक्ति प्रत्येक ऑर्डर को उसके ऑर्डर आईडी के आधार पर रद्द करने के लिए exchange.CancelOrder() फ़ंक्शन का उपयोग करती है।
• 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): कोड की यह पंक्ति रणनीति की निष्पादन आवृत्ति को नियंत्रित करने के लिए रणनीति को कुछ समय के लिए निष्क्रिय रहने की अनुमति देती है। अंतराल पैरामीटर मिलीसेकंड में नींद अंतराल को परिभाषित करता है।

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

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

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + 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;: askPrice चर को प्रारंभ करें, जिसका उपयोग शर्तों को पूरा करने वाले विक्रय आदेश मूल्य को संग्रहीत करने के लिए किया जाएगा।

• for (i = 0; i < depth.Asks.length; i++)यह एक फॉर लूप है जिसका उपयोग बाजार विक्रय आदेश की कीमत और मात्रा की जानकारी को दोहराने के लिए किया जाता है।

• if (depth.Asks[i].Amount >= Lot)लूप में, जाँच करें कि प्रत्येक विक्रय आदेश की मात्रा निर्दिष्ट लॉट से अधिक है या उसके बराबर है। यदि ऐसा है, तो विक्रय आदेश का मूल्य askPrice में संग्रहीत करें और लूप को समाप्त करें।

• if (askPrice === 0)यदि कोई संतोषजनक विक्रय आदेश नहीं मिलता है (पूछ मूल्य अभी भी 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): जाँच करें कि क्या वर्तमान खरीद मूल्य और पूछ मूल्य के बीच का अंतर एलिफेंटस्पेस से अधिक है। यदि ऐसा है, तो इसका अर्थ है कि यह “हाथी” से काफी दूर है और रणनीति खोज जारी नहीं रखेगी।

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

• if (!elephant)यदि “हाथी” नहीं मिलता है, तो लॉक गिनती को 0 पर रीसेट करें और प्रतीक्षा जारी रखें।

ताले++: यदि “हाथी” पाया जाता है, तो ताले की संख्या बढ़ जाएगी। इसका उद्देश्य यह सुनिश्चित करना है कि रणनीति का क्रियान्वयन तब किया जाए जब एक निश्चित समयावधि में “हाथी” के अस्तित्व की कई बार पुष्टि हो जाए।

• 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)): रणनीति की वर्तमान स्थिति को रिकॉर्ड करने के लिए updateStatus फ़ंक्शन को कॉल करें, जिसमें पाए गए “हाथी” की गियर स्थिति और संबंधित जानकारी शामिल है। इसका संकेत पॉलिसी के स्थिति कॉलम में दिया जाएगा।

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): पाए गए “हाथी” को खरीदने के लिए एक्सचेंज.बाय फ़ंक्शन का उपयोग करें। खरीद मूल्य है elephant.Price + PennyTick, खरीद मात्रा है lot, तथा खरीद संचालन को “Bids” के रूप में वर्णित किया गया है[” + 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): एक्सचेंज.कैंसलऑर्डर फ़ंक्शन का उपयोग करके प्रत्येक खुले ऑर्डर को रद्द करें।

    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): लाभ कमाने के लिए सफलतापूर्वक खरीदे गए “हाथी” को बेचने के लिए एक्सचेंज.सेल फ़ंक्शन का उपयोग करें। विक्रय मूल्य हाथी मूल्य + (पेनी टिक * प्रॉफिट टिक) है।

विक्रय आदेश के निष्पादन की प्रतीक्षा में एक नए अनंत लूप में प्रवेश करता है।

• 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. यदि लगातार पर्याप्त “हाथी” पाए जाते हैं (लॉककाउंट पैरामीटर द्वारा नियंत्रित), तो रणनीति आगे निम्नलिखित ऑपरेशन करेगी:

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

1. इसके बाद, रणनीति एक नए अनंत लूप में प्रवेश करना जारी रखेगी, बिक्री ऑपरेशन के निष्पादन की प्रतीक्षा करेगी। इस लूप में, यह निम्नलिखित कार्य करता है:

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

पूरी रणनीति लगातार उपरोक्त परिचालनों के माध्यम से चक्रित होती है ताकि अधिक से अधिक “हाथियों” को �