संसाधन लोड हो रहा है... लोड करना...

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

लेखक:FMZ~Lydia, बनाया गयाः 2023-11-07 10:44:20, अद्यतनः 2024-01-01 12:19:43

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

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

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

उदाहरण के लिए, मान लीजिये शेयर बाजार की मूल गहराई इस प्रकार थी: 200 ∙ $1.01 x $1.03 ∙ 200. फिर एक हाथी अंदर आता है और 3000 शेयरों के लिए $1.01 प्रति शेयर पर खरीद ऑर्डर देता है. इस बिंदु पर, बाजार की गहराई 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("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
};

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

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 है, तो इसका मतलब है कि कोई अधूरे आदेश नहीं हैं और लूप बाधित हो जाएगा (ब्रेक) ।
for (var i = 0; i < orders.length; i++): यह एक फोर लूप है जो सभी अधूरे आदेशों के माध्यम से पुनरावृत्ति करता है.
exchange.CancelOrder(orders[i].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;: दो चर, i और ताले, जो बाद की रणनीति तर्क में इस्तेमाल किया जाएगा आरंभ.
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): यह कोड लाइन रणनीति के निष्पादन आवृत्ति को नियंत्रित करने के लिए, समय की एक अवधि के लिए नींद की अनुमति देता है। अंतराल पैरामीटर नींद अंतराल (मिलीसेकंड में) को परिभाषित करता है।
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;: askPrice चर को आरंभ करें, इसका उपयोग शर्तों को पूरा करने वाले बिक्री आदेशों की कीमत को संग्रहीत करने के लिए किया जाएगा.
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 से अधिक या बराबर है. यदि हां, तो खरीद आदेश की जानकारी को हाथी चर में संग्रहीत करें.
if (!elephant): यदि हाथी नहीं मिला है, तो लॉक गिनती को 0 पर रीसेट करें और प्रतीक्षा जारी रखें.
locks++: यदि हाथी पाया जाता है, तो लॉक की संख्या में वृद्धि करें। यह सुनिश्चित करने के लिए है कि हाथी के अस्तित्व की पुष्टि करने के बाद ही रणनीति निष्पादित की जाती है।
if (locks < 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): स्टॉप-लॉस ऑपरेशन निष्पादित करें, शेष परिसंपत्तियों को वर्तमान बाजार की सबसे कम कीमत पर बेचें।

अंत में, सफल और असफल लेनदेन की संख्या को अद्यतन करें, यह देखते हुए कि लेनदेन सफल था या नहीं, और ट्रेडिंग लाभ दर्ज करें।

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

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

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

जैसा कि आप रणनीति को निष्पादित करना जारी रखते हैं, यह बार-बार निम्नलिखित संचालन करेगाः

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

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

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

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

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

सारांश

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

अधिक

2019 FMZ - सभी अधिकार सुरक्षित