गुड़ काटने की मशीन की रणनीति का विश्लेषण (2)

गुड़ काटने की मशीन की रणनीति का विश्लेषण (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यह पिछले अपडेट के बाद से अब तक की तुलना में अधिक है।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 एपीआई दस्तावेज पर जांच की जा सकती है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()क्या यह एक फलन है, जहां हम एक समय अनुक्रम का निर्माण करने के लिए एक भारित औसत एल्गोरिथ्म का उपयोग करते हैं?pricesArrays. इस कोड में तीन नए फ़ंक्शन का उपयोग किया गया है_.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()निर्माण कार्य इस कपास काटने की मशीन ऑब्जेक्ट को कैसे बनाते हैं और कपास काटने की मशीन ऑब्जेक्ट के विभिन्न तरीकों, मुख्य तार्किक कार्यों के निष्पादन प्रक्रियाओं का विश्लेषण करते हैं, हम मानते हैं कि इस लेख को पढ़ने के बाद आपको इस उच्च-आवृत्ति रणनीति एल्गोरिथ्म प्रक्रिया की स्पष्ट समझ होनी चाहिए।