संतुलित लंबित आदेश रणनीति (शिक्षण रणनीति)

संतुलित लंबित आदेश रणनीति (शिक्षण रणनीति)

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

• रणनीति तर्क समावेशन रनटाइम पर कुछ डेटा और टैग चर (ऑब्जेक्ट के रूप में कैप्सूलित) के साथ रणनीति तर्क को कैप्सूल करें.

• रणनीति प्रसंस्करण आरंभ करने के लिए कोड प्रारंभिक खाता जानकारी लाभ गणना के लिए प्रारंभिक रन में दर्ज की जाती है. प्रारंभिक रनटाइम पर, आप चुन सकते हैं कि पैरामीटर के अनुसार डेटा को पुनर्स्थापित करना है या नहीं.

• रणनीति बातचीत प्रसंस्करण के लिए कोड विराम और फिर से शुरू करने के लिए एक सरल इंटरैक्टिव प्रसंस्करण को डिज़ाइन किया गया है।

• रणनीति लाभ की गणना के लिए कोड लाभ की गणना के लिए मुद्रा मानक गणना विधि का प्रयोग किया जाता है।

• रणनीति में प्रमुख डेटा की निरंतरता का तंत्र डाटा रिकवरी के लिए तंत्रों का डिजाइन करना।

• रणनीति प्रसंस्करण जानकारी प्रदर्शित करने के लिए कोड स्थिति पट्टी डेटा प्रदर्शन.

रणनीति कोड

var Shannon = {
    // member
    e : exchanges[0],
    arrPlanOrders : [],
    distance : BalanceDistance,
    account : null,
    ticker : null, 
    initAccount : null,
    isAskPending : false,
    isBidPending : false,

    // function 
    CancelAllOrders : function (e) {
        while(true) {
            var orders = _C(e.GetOrders)
            if(orders.length == 0) {
                return 
            }
            Sleep(500)
            for(var i = 0; i < orders.length; i++) {
                e.CancelOrder(orders[i].Id, orders[i])
                Sleep(500)
            }
        }
    },

    Balance : function () {
        if (this.arrPlanOrders.length == 0) {
            this.CancelAllOrders(this.e)
            var acc = _C(this.e.GetAccount)
            this.account = acc
            var askPendingPrice = (this.distance + acc.Balance) / acc.Stocks
            var bidPendingPrice = (acc.Balance - this.distance) / acc.Stocks
            var askPendingAmount = this.distance / 2 / askPendingPrice
            var bidPendingAmount = this.distance / 2 / bidPendingPrice

            this.arrPlanOrders.push({tradeType : "ask", price : askPendingPrice, amount : askPendingAmount}) 
            this.arrPlanOrders.push({tradeType : "bid", price : bidPendingPrice, amount : bidPendingAmount})
        } else if(this.isAskPending == false && this.isBidPending == false) {
            for(var i = 0; i < this.arrPlanOrders.length; i++) {
                var tradeFun = this.arrPlanOrders[i].tradeType == "ask" ? this.e.Sell : this.e.Buy
                var id = tradeFun(this.arrPlanOrders[i].price, this.arrPlanOrders[i].amount)
                if(id) {
                    this.isAskPending = this.arrPlanOrders[i].tradeType == "ask" ? true : this.isAskPending
                    this.isBidPending = this.arrPlanOrders[i].tradeType == "bid" ? true : this.isBidPending
                } else {
                    Log("Pending order failed, clear!")
                    this.CancelAllOrders(this.e)
                    return 
                }
            }
        }

        if(this.isBidPending || this.isAskPending) {
            var orders = _C(this.e.GetOrders)
            Sleep(1000)
            var ticker = _C(this.e.GetTicker)
            this.ticker = ticker
            if(this.isAskPending) {
                var isFoundAsk = false 
                for (var i = 0; i < orders.length; i++) {
                    if(orders[i].Type == ORDER_TYPE_SELL) {
                        isFoundAsk = true
                    }
                }
                if(!isFoundAsk) {
                    Log("Selling order filled, cancel the order, reset")
                    this.CancelAllOrders(this.e)
                    this.arrPlanOrders = []
                    this.isAskPending = false 
                    this.isBidPending = false 
                    LogProfit(this.CalcProfit(ticker))
                    return 
                }
            }
            if(this.isBidPending) {
                var isFoundBid = false 
                for(var i = 0; i < orders.length; i++) {
                    if(orders[i].Type == ORDER_TYPE_BUY) {
                        isFoundBid = true
                    }
                }
                if(!isFoundBid) {
                    Log("Buying order filled, cancel the order, reset")
                    this.CancelAllOrders(this.e)
                    this.arrPlanOrders = []
                    this.isAskPending = false 
                    this.isBidPending = false 
                    LogProfit(this.CalcProfit(ticker))
                    return 
                }
            }        
        }
    }, 
    ShowTab : function() {
        var tblPlanOrders = {
            type : "table", 
            title : "Plan pending orders", 
            cols : ["direction", "price", "amount"], 
            rows : []
        }
        for(var i = 0; i < this.arrPlanOrders.length; i++) {
            tblPlanOrders.rows.push([this.arrPlanOrders[i].tradeType, this.arrPlanOrders[i].price, this.arrPlanOrders[i].amount])
        }

        var tblAcc = {
            type : "table", 
            title : "Account information", 
            cols : ["type", "Stocks", "FrozenStocks", "Balance", "FrozenBalance"], 
            rows : []            
        }
        tblAcc.rows.push(["Initial", this.initAccount.Stocks, this.initAccount.FrozenStocks, this.initAccount.Balance, this.initAccount.FrozenBalance])
        tblAcc.rows.push(["This", this.account.Stocks, this.account.FrozenStocks, this.account.Balance, this.account.FrozenBalance])
        
        return "Time:" + _D() + "\n `" + JSON.stringify([tblPlanOrders, tblAcc]) + "`" + "\n" + "ticker:" + JSON.stringify(this.ticker)
    },
    CalcProfit : function(ticker) {
        var acc = _C(this.e.GetAccount)
        this.account = acc
        return (this.account.Balance - this.initAccount.Balance) + (this.account.Stocks - this.initAccount.Stocks) * ticker.Last
    },
    Init : function() {
        this.initAccount = _C(this.e.GetAccount)
        if(IsReset) {
            var acc = _G("account")
            if(acc) {
                this.initAccount = acc 
            } else {
                Log("Failed to restore initial account information! Running in initial state!")
                _G("account", this.initAccount)
            }
        } else {
            _G("account", this.initAccount)
            LogReset(1)
            LogProfitReset()
        }
    },
    Exit : function() {
        Log("Cancel all pending orders before stopping...")
        this.CancelAllOrders(this.e)
    }
}

function main() {
    // Initialization
    Shannon.Init()

    // Main loop
    while(true) {
        Shannon.Balance()        
        LogStatus(Shannon.ShowTab())
        // Interaction
        var cmd = GetCommand()
        if(cmd) {
            if(cmd == "stop") {
                while(true) {
                    LogStatus("Pause", Shannon.ShowTab())
                    cmd = GetCommand()
                    if(cmd) {
                        if(cmd == "continue") {
                            break
                        }
                    }
                    Sleep(1000)
                }
            }
        }
        Sleep(5000)
    }
}

function onexit() {
    Shannon.Exit()
}

बैकटेस्टिंग

अनुकूलन और विस्तार

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

रणनीतियाँ केवल शैक्षिक उद्देश्यों के लिए हैं और वास्तविक बॉट ट्रेडिंग में सावधानी के साथ उपयोग की जानी चाहिए। रणनीतिक पता:https://www.fmz.com/strategy/225746