लीक्सरीपर रणनीति विश्लेषण (2)

लीक्सरीपर रणनीति विश्लेषण (2)

आइए पिछले अध्याय की सामग्री की व्याख्या करते हैं (https://www.fmz.com/bbs-topic/9725).

तीसरा जोड़ा गया कार्यः

    self.balanceAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        var now = new Date().getTime()
        if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {
            self.preCalc = now
            var net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))
            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }
        }
        self.btc = account.Stocks
        self.cny = account.Balance
        self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)
        var balanced = false
        
        if (self.p < 0.48) {
            Log ( \"\" Start Balance \"\", self. P)
            self.cny -= 300
            if (self.orderBook.Bids.length >0) {
                exchange.Buy(self.orderBook.Bids[0].Price + 0.00, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.01, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.02, 0.01)
            }
        } else if (self.p > 0.52) {
            Log ( \"\" Start Balance \"\", self. P)
            self.btc -= 0.03
            if (self.orderBook.Asks.length >0) {
                exchange.Sell(self.orderBook.Asks[0].Price - 0.00, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.01, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.02, 0.01)
            }
        }
        Sleep(BalanceTimeout)
        var orders = exchange.GetOrders()
        if (orders) {
            for (var i = 0; i < orders.length; i++) {
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)
                }
            }
        }
    }

जब निर्माताLeeksReaper ()एक वस्तु का निर्माण करता है,balanceAccount ()ऑब्जेक्ट में जोड़ा गया फ़ंक्शन खाते में संग्रहीत संपत्ति की जानकारी को अद्यतन करता हैself.account, यानी,accountनिर्मित वस्तु की विशेषता. राजस्व मूल्य की गणना करें और इसे समय पर प्रिंट करें. फिर, नवीनतम खाता परिसंपत्ति जानकारी के अनुसार, स्पॉट मुद्रा संतुलन अनुपात (स्पॉट स्थिति संतुलन) की गणना करें, जब ऑफसेट थ्रेशोल्ड को ट्रिगर करते हैं, तो एक छोटे आदेश के साथ स्थिति को बंद करें, ताकि मुद्रा (स्थिति) संतुलन की स्थिति में वापस आ जाए. कुछ समय इंतजार करें, फिर सभी निर्माताओं को रद्द करें, फ़ंक्शन के निष्पादन के अगले दौर में, यह शेष राशि की जांच करेगा और फिर से संबंधित प्रसंस्करण करेगा।

चलिए इस फंक्शन के कोड को वाक्य से वाक्य में देखते हैंः सबसे पहले, पहला वाक्यvar account = exchange.GetAccount ()स्थानीय चर घोषित करता हैaccountऔर के कार्य को कॉल करता हैexchange.GetAccountएफएमजेड एपीआई इंटरफ़ेस पर. चालू खाते के नवीनतम डेटा प्राप्त करें और चर के लिए यह असाइनaccount. फिर चर का न्याय करेंaccount. यदि चर हैnull(उदाहरण के लिए, टाइमआउट, नेटवर्क, एक्सचेंज इंटरफेस अपवाद, आदि), यह वापस आ जाएगा (अनुरूपif (!account) {...}) सीधे।

self.account = accountस्थानीय चर असाइन करने के लिए हैaccountके लिएaccountनिर्मित वस्तु की विशेषता जो निर्मित वस्तु में नवीनतम खाता जानकारी दर्ज करती है।

Var now = new Date().getTime ()स्थानीय चर घोषित करता हैnowऔर बुलाता हैgetTime()जावास्क्रिप्ट भाषा के समय दिनांक ऑब्जेक्ट का कार्य वर्तमान टाइमस्टैम्प वापस करने के लिए। चर को एक मान असाइन करता हैnow.

if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)){...}निर्धारित करता है कि यदि वर्तमान समयस्टैम्प और पिछली बार दर्ज समयस्टैम्प के बीच का अंतर पैरामीटर से अधिक हैCalcNet Interval * 1000, इसका मतलब है कि यह पिछली बार से अद्यतन किया गया है।CalcNetInterval * 1000मिलीसेकंड (CalcNetIntervalसेकंड), जो नियमित समय पर मुद्रण आय के कार्य को महसूस करता है। क्योंकि एक खरीदने की कीमत का उपयोग आय की गणना करने के लिए किया जाता है, मुद्रण की स्थिति के रूप में, एक मुद्रण के लिए एक मुद्रण मूल्य का उपयोग किया जाता है।self.orderBook.Bids.length > 0स्थिति में भी परिभाषित है (गहनता डेटा, आदेश सूची में मान्य स्तर की जानकारी होनी चाहिए) जब if कथन की स्थिति ट्रिगर की जाती है, तोself.PreCalc = nowसबसे हाल ही में मुद्रित रिटर्न के टाइमस्टैम्प चर को अद्यतन करने के लिए निष्पादित किया जाता हैself.preCalcवर्तमान समय-स्टैम्प परnowयहाँ, शुद्ध मूल्य गणना विधि का उपयोग रिटर्न सांख्यिकी में किया जाता है। कोड हैvar net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks)), यानी मुद्रा को मुद्रा में परिवर्तित करें (मुद्रा में तब्दील करें) वर्तमान खरीद मूल्य के अनुसार, और फिर इसे खाते में धनराशि में जोड़ें और इसे घोषित स्थानीय चर को असाइन करेंnetयह आंकलन करें कि वर्तमान कुल शुद्ध मूल्य पिछली बार दर्ज कुल शुद्ध मूल्य के अनुरूप है या नहीं:

            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }

यदि यह सुसंगत नहीं है, कि है,net! = self.preNetसच है, की विशेषता अद्यतन करेंself.preNetचर के साथ शुद्ध मूल्य को रिकॉर्ड करने के लिए प्रयोग किया जाता हैnet. फिर कुल नेट का प्रिंट करेंnetएफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म रोबोट (एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म रोबोट) के उपज वक्र चार्ट के लिए डेटाLogProfitFMZ एपीआई दस्तावेज में क्वेरी किया जा सकता है) ।

यदि आय की नियमित छपाई शुरू नहीं होती है, तो निम्न प्रक्रिया को जारी रखें।account.Stocks(चालू खाता में उपलब्ध मुद्रा) औरaccount.Balance(चालू खाता में उपलब्ध मुद्रा)self.BTCऔरself.CNY. ऑफसेट स्केल की गणना करें और असाइनमेंट को रिकॉर्ड करेंself.p.

self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)

एल्गोरिथ्म भी बहुत सरल है, जो मुद्रा के वर्तमान मूल्य का प्रतिशत खाते के कुल शुद्ध मूल्य में गणना करने के लिए है।

धन संतुलन (स्थिति) को कब ट्रिगर करना है, इसका निर्णय लेने के बारे में क्या? यहाँ, मैं ले 50% प्लस या माइनस 2 प्रतिशत अंक बफर के रूप में, और बफर से परे संतुलन निष्पादित करता है, कि अगर हैself.p < 0.48, धन संतुलन विचलन से ट्रिगर किया जाता है। यदि धन कम है, तो मूल्य बाजार के उद्घाटन पर खरीदने की स्थिति से हर बार 0.01 बढ़ जाएगा, और तीन छोटे आदेश व्यवस्थित किए जाएंगे। इसी तरह, धन संतुलन में वृद्धि होगी।self.p > 0.52, यदि मुद्रा अधिक है, एक बेचने और छोटे आदेश जारी. अंत में, सभी आदेश रद्द करने के लिए प्रतीक्षा करने के बादSleep(BalanceTimeout)पैरामीटर सेटिंग्स के अनुसार एक निश्चित समय के लिए।

        Var orders = exchange. Get Orders () # Get all current makers, with orders variable
        If (orders) { # If the variable orders used to obtain the current order data is not null
            for (var i = 0; i < orders.length; I + +) { # Loop through orders and cancel orders one by one
                if (orders[i].Id != self.tradeOrderId) {
                    Exchange. CancelOrder (orders [I]. Id) # Call exchange. CancelOrder to cancel orders based on orders [I]. Id
                }
            }
        }

चौथा जोड़ा गया कार्यः

रणनीति के मूल भाग में, यहाँ मुख्य खेल आता है।self.poll = function(){...}जैसा कि हमने पिछले लेख में कहा था,main()समारोह निष्पादित करने के लिए शुरू होता है और अंतहीन में प्रवेश करता हैwhileलूप, हम उपयोग करते हैंvar reaper = LeeksReaper()leeksreaper ऑब्जेक्ट का निर्माण करने के लिए, और फिर के पाश कॉल निष्पादित करने के लिएreaper.poll()मेंmain() function.

..self.pollप्रत्येक लूप से पहले कुछ प्रारंभिक कार्य करते हुए कार्य निष्पादित करना शुरू कर देता है।self.numTick++बढ़ जाती है।self.updateTrades()हाल के बाजार व्यापार रिकॉर्ड को अद्यतन करता है और प्रासंगिक उपयोग डेटा की गणना करता है।self.updateOrderBook()आदेश डेटा को अद्यतन करता है और प्रासंगिक डेटा की गणना करता है।self.balanceAccount()मौद्रिक (स्थिति) शेष की जाँच करें।

        Var burstPrice = self. Prices [self. Prices. Length-1] * BurstThresholdPct # Calculate Burst Price
        Var bull = false                   # Declare a bull-marked variable, initially false
        Var bear = false                  # Declare a bear marked variable, initially false
        Var tradeAmount = 0         # Declare the transaction amount variable, initially 0

अगला कदम यह न्याय करना है कि वर्तमान अल्पकालिक बाजार बैल है या भालू।

        if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -1)) > burstPrice ||
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -2)) > burstPrice && self.prices[self.prices.length-1] > self.prices[self.prices.length-2]
            )) {
            bull = true
            tradeAmount = self.cny / self.bidPrice * 0.99
        } else if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -1)) < -burstPrice ||
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -2)) < -burstPrice && self.prices[self.prices.length-1] < self.prices[self.prices.length-2]
            )) {
            bear = true
            tradeAmount = self.btc
        }

क्या आपको याद है किself.updateOrderBook()पिछले लेख से समारोह जहां हम एक समय क्रमबद्ध बनाने के लिए एक भारित औसत एल्गोरिथ्म का इस्तेमाल कियाpricesतीन नए कार्यः_.min, _.max, औरsliceकोड में उपयोग किया जाता है और वे समझने में आसान हैं।

· _. min: फंक्शन पैरामीटर सरणी में न्यूनतम मान ढूँढना है.

· _.max: फंक्शन पैरामीटर सरणी में अधिकतम मान ढूँढना है.

· slice: यह फंक्शन एक सदस्य फंक्शन हैJavaScriptarray ऑब्जेक्ट. यह सूचकांक के अनुसार array के एक हिस्से को वापस करने के लिए प्रयोग किया जाता है. उदाहरण के लिएः

function main() {
    // index     .. -8 -7 -6 -5 -4 -3 -2 -1
    var arr = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    Log (arr. Slice (-5, -1))   // it will intercept the elements from 4 to 1 and return a new array: [4,3,2,1]
}

भालू या बैल बाजार का आकलन करने की शर्तें निम्नलिखित हैंः

· दself.numTick > 2सच होना चाहिए, यानी जब पता लगाने की कीमत का एक नया दौर शुरू होता है, तो इसे पता लगाने के कम से कम तीन दौरों के बाद ट्रिगर किया जाना चाहिए, ताकि शुरुआत में ट्रिगर होने से बचा जा सके। · अंतिम आंकड़ों के बीच का अंतरself.pricesमूल्य अनुक्रम का, अर्थात नवीनतम डेटा, और पिछले सीमा में अधिकतम या न्यूनतम मूल्यself.pricesarray के फट मूल्य से अधिक होना चाहिएburstPrice.

यदि सभी शर्तें सही हैं, चिह्नित करेंbullयाbearसच के रूप में, और चर के लिए एक मूल्य असाइनtradeAmountस्टड लेनदेन की योजना बनाने के लिए।

फिर, के अनुसारself.volअद्यतन और पिछले वर्ष में गणना की गईself.updateTrades()कार्य,BurstThresholdVolपैरामीटर यह निर्धारित करता है कि लेनदेन की तीव्रता को कम करना है या नहीं (नियोजित लेनदेन की मात्रा को कम करना) ।

        if (self.vol < BurstThresholdVol) {
            TradeAmount * = self. Vol/BurstThresholdVol      //Reduce the planned volume by self. Vol/BurstThresholdVol times of the previous volume
        }
        
        if (self.numTick < 5) {
            TradeAmount * = 0.8      // reduced to 80% of the plan
        }
        
        If (self. NumTick < 10) {       // reduce to 80% of the plan
            tradeAmount *= 0.8
        }

इसके बाद, निर्णय लें कि क्या ट्रेडिंग सिग्नल और वॉल्यूम आवश्यकताओं को पूरा करते हैं:

        If ( (!Bull && !Bear) | | tradeAmount < MinStock) {     # If it is not a bull market and not a bear market, or the amount tradeAmount planned to trade is less than the minimum trading volume MinStock set by the parameter, the poll function returns without trading operations directly
            return
        }

उपरोक्त निर्णय के बाद, निष्पादितvar tradePrice = bull ? self.bidPrice: self.askPriceलेन-देन की कीमत निर्धारित करता है कि क्या यह एक भालू बाजार है या एक बैल बाजार, और मूल्य को संबंधित बोनस मूल्य के साथ असाइन करता है।

अंत में, एकwhileलूप में प्रवेश किया जाता है, और लूप की एकमात्र स्टॉप शर्त यह है कि योजनाबद्ध व्यापारिक मात्राtradeAmount > = MinStockन्यूनतम ट्रेडिंग वॉल्यूम से कम है। लूप में, आदेश वर्तमान बाजार की स्थिति के अनुसार निष्पादित किया जाता है. और चर में आदेश आईडी रिकॉर्डorderId. Sleep(200)प्रत्येक लूप में एक आदेश रखने के बाद 200 मिलीसेकंड के लिए इंतजार करता है। लूप तब निर्धारित करता है कि क्या लूप में एक आदेश रखा गया है या नहीं।orderIdtrue है (यदि आदेश विफल रहता है, तो आदेश आईडी वापस नहीं किया जाएगा, और यदि शर्त ट्रिगर नहीं की जाएगी). यदि शर्त सही है. आदेश आईडी प्राप्त करें और इसे आदेश आईडी को असाइन करेंself.tradeOrderId.

चर घोषित करेंorderआदेश डेटा को संग्रहीत करने के लिए प्रयोग किया जाता है, जिसका प्रारंभिक मान हैnull. फिर आईडी का आदेश डेटा एक लूप में प्राप्त किया जाता है, और यह न्याय करता है कि क्या आदेश निर्माता राज्य है, यदि हां, तो आईडी का आदेश रद्द कर दिया जाता है, और यदि नहीं, तो पता लगाने का लूप समाप्त हो जाता है।

                Var order = null         // Declare a variable to hold the order data
                While (true) {             // a while loop
                    Order = exchange. GetOrder (orderId)          // Call GetOrder to query the order data whose order ID is orderId
                    If (order) {                                                   // If the order data is queried and the query fails and the order is null, the current if condition will not be triggered
                        If (order. Status = = ORDER _ STATE _ PENDING) {              // Judge whether the order status is maker
                            Exchange. CancelOrder (orderId)                                    // If the order is maker, cancel the order
                            Sleep(200)
                        } else {                                                                               // otherwise execute break to end the current while loop
                            break
                        }
                    }
                }

फिर निम्नलिखित प्रक्रिया की जाती है:

                Self. TradeOrderId = 0                         // Reset self. TradeOrderId.
                TradeAmount-= order. DealAmount    // Update tradeAmount, subtract the quantity of the order on the bill of lading that has been completed
                TradeAmount * = 0.9                          //Decrease the order amount
                If (order. Status = = ORDER _ STATE _ CANCELED) {                   // if the order is already cancelled
                    Self. UpdateOrderBook ()                                                      // Update data such as order book
                    While (bull & & self. BidPrice-tradePrice > 0.1) {               // In a bull market, if the updated bill of lading price exceeds the current trading price by 0.1, the trading amount will be reduced and the trading price will be adjusted slightly
                        tradeAmount *= 0.99
                        tradePrice += 0.1
                    }
                    While (bear & & self. AskPrice-tradePrice < -0.1) {             // In a bear market, if the updated bill of lading price exceeds the current trading price by 0.1, the trading amount will be reduced and the trading price will be adjusted slightly
                        tradeAmount *= 0.99
                        tradePrice -= 0.1
                    }
                }

जब कार्यक्रम प्रक्रिया के लूप के अंतwhile (tradeAmount > = MinStock){...}, यह दर्शाता है कि इस मूल्य विस्फोट लेनदेन प्रक्रिया का निष्पादन पूरा हो गया है। निष्पादित करेंself.numTick = 0, यानी, रीसेट करेंself.numTick0 तक।

..LeeksReaper()निर्माणकर्ता लौटाता हैselfनिष्पादन के अंत में वस्तु, यानी जबvar reaper = LeeksReaper(), यह वापस कर दिया जाता हैreaper.

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