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

तबपिछली सामग्रीव्याख्या करना।

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

    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("开始平衡", 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("开始平衡", 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)) {...}यह कोड निर्धारित करता है कि वर्तमान टाइमस्टैम्प और अंतिम रिकॉर्ड किए गए टाइमस्टैम्प के बीच का अंतर पैरामीटर से अधिक है या नहींCalcNetInterval * 1000इसका मतलब यह है कि पिछले अपडेट से लेकर अब तक, 100 से अधिक अपडेट हुए हैं।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यदि सत्य है, तो उपयोग करेंnetशुद्ध मूल्य के गुणों को रिकॉर्ड करने के लिए चर अद्यतन का उपयोग किया जाता हैself.preNet. फिर इसे प्रिंट करेंnetआविष्कारक के मात्रात्मक व्यापार मंच रोबोट के लाभ वक्र चार्ट के लिए कुल निवल मूल्य डेटा (FMZ API दस्तावेज़ में पूछताछ की जा सकती है)LogProfitयह फ़ंक्शन)।

यदि निर्धारित मुद्रण राजस्व सक्रिय नहीं होता है, तो निम्नलिखित प्रक्रिया जारी रखें।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.GetOrders()                  # 获取当前所有挂单，存在orders变量
        if (orders) {                                      # 如果获取当前挂单数据的变量orders不为null
            for (var i = 0; i < orders.length; i++) {      # 循环遍历orders，逐个取消订单
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)     # 调用exchange.CancelOrder，根据orders[i].Id取消订单
                }
            }
        }

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

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

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

        var burstPrice = self.prices[self.prices.length-1] * BurstThresholdPct   # 计算爆发价格
        var bull = false             # 声明牛市标记的变量，初始为假
        var bear = false             # 声明熊市标记的变量，初始为假
        var tradeAmount = 0          # 声明交易数量变量，初始为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: यह फ़ंक्शन जावास्क्रिप्ट ऐरे ऑब्जेक्ट का एक सदस्य फ़ंक्शन है। इसका कार्य इंडेक्स के अनुसार ऐरे के एक भाग को इंटरसेप्ट करना और उसे वापस करना है। उदाहरण के लिए:

  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))    // 会截取 4 ~ 1 这几个元素，返回一个新数组：[4,3,2,1]
  }

यहां भालू और बैल का आकलन करने की शर्तें इस प्रकार हैं:

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

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

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

        if (self.vol < BurstThresholdVol) {
            tradeAmount *= self.vol / BurstThresholdVol   // 缩减计划交易量，缩减为之前量的self.vol / BurstThresholdVol 倍
        }
        
        if (self.numTick < 5) {
            tradeAmount *= 0.8      // 缩减为计划的80%
        }
        
        if (self.numTick < 10) {    // 缩减为计划的80%
            tradeAmount *= 0.8
        }

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

        if ((!bull && !bear) || tradeAmount < MinStock) {   # 如果非牛市并且也非熊市，或者计划交易的量tradeAmount小于参数设置的最小交易量MinStock，poll函数直接返回，不做交易操作
            return
        }

उपरोक्त निर्णय के पश्चात्,var tradePrice = bull ? self.bidPrice : self.askPriceचाहे मंदी का बाजार हो या तेजी का बाजार, उसके अनुसार लेनदेन का मूल्य निर्धारित करें तथा संबंधित बिल ऑफ लैडिंग मूल्य के साथ मूल्य निर्दिष्ट करें।

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

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

                var order = null           // 声明一个变量用于保存订单数据
                while (true) {             // 一个while循环
                    order = exchange.GetOrder(orderId)    // 调用GetOrder查询订单ID为 orderId的订单数据
                    if (order) {                          // 如果查询到订单数据，查询失败order为null，不会触发当前if条件
                        if (order.Status == ORDER_STATE_PENDING) {   // 判断订单状态是不是正在挂单中
                            exchange.CancelOrder(orderId)            // 如果当前正在挂单，取消该订单
                            Sleep(200)
                        } else {                                     // 否则执行break跳出当前while循环
                            break
                        }
                    }
                }

फिर नीचे दी गई प्रक्रिया का पालन करें:

                self.tradeOrderId = 0              // 重置self.tradeOrderId
                tradeAmount -= order.DealAmount    // 更新tradeAmount，减去提单的订单已经成交的数量
                tradeAmount *= 0.9                 // 减小下单力度
                if (order.Status == ORDER_STATE_CANCELED) {     // 如果订单已经是取消了
                    self.updateOrderBook()                      // 更新订单薄等数据
                    while (bull && self.bidPrice - tradePrice > 0.1) {   // 牛市时，更新后的提单价格超过当前交易价格0.1就减小交易力度，略微调整交易价格
                        tradeAmount *= 0.99
                        tradePrice += 0.1
                    }
                    while (bear && self.askPrice - tradePrice < -0.1) {  // 熊市时，更新后的提单价格超过当前交易价格0.1就减小交易力度，略微调整交易价格
                        tradeAmount *= 0.99
                        tradePrice -= 0.1
                    }
                }

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

LeeksReaper()कन्स्ट्रक्टर अंततः निष्पादित होता हैselfलौटाई गई वस्तु हैvar reaper = LeeksReaper()जब इसे वापस किया गयाreaper。

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