मैकबुक सेब कटाई मशीन से उच्च आवृत्ति रणनीति डिजाइन की खोज करें

मैकबुक सेब कटाई मशीन से उच्च आवृत्ति रणनीति डिजाइन की खोज करें

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

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

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

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

एक जादूगरनी सेब कटाई मशीन

var TickInterval = 100

function LeeksReaper() {
    var self = {}
    self.numTick = 0
    self.lastTradeId = 0
    self.vol = 0
    self.askPrice = 0
    self.bidPrice = 0
    self.orderBook = {
        Asks: [],
        Bids: []
    }
    self.prices = []
    self.tradeOrderId = 0
    self.account = null
    self.buyPrice = 0
    self.sellPrice = 0
    self.state = 0
    self.depth = null

    self.updateTrades = function() {
        var trades = _C(exchange.GetTrades)
        if (self.prices.length == 0) {
            while (trades.length == 0) {
                trades = trades.concat(_C(exchange.GetTrades))
            }
            for (var i = 0; i < 15; i++) {
                self.prices[i] = trades[trades.length - 1].Price
            }
        }
        self.vol = 0.7 * self.vol + 0.3 * _.reduce(trades, function(mem, trade) {
            // Huobi not support trade.Id
            if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
                self.lastTradeId = Math.max(trade.Id == 0 ? trade.Time : trade.Id, self.lastTradeId)
                mem += trade.Amount
            }
            return mem
        }, 0)

    }
    self.updateOrderBook = function() {
        var orderBook = _C(exchange.GetDepth)
        self.depth = orderBook
        self.buyPrice = orderBook.Bids[pendingLevel].Price
        self.sellPrice = orderBook.Asks[pendingLevel].Price
        self.orderBook = orderBook
        if (orderBook.Bids.length < 3 || orderBook.Asks.length < 3) {
            return
        }
        self.bidPrice = orderBook.Bids[0].Price * 0.618 + orderBook.Asks[0].Price * 0.382 + 0.01
        self.askPrice = orderBook.Bids[0].Price * 0.382 + orderBook.Asks[0].Price * 0.618 - 0.01
        self.prices.shift()
        self.prices.push(_N((orderBook.Bids[0].Price + orderBook.Asks[0].Price) * 0.15 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.1 +
            (orderBook.Bids[3].Price + orderBook.Asks[3].Price) * 0.075 +
            (orderBook.Bids[4].Price + orderBook.Asks[4].Price) * 0.05 +
            (orderBook.Bids[5].Price + orderBook.Asks[5].Price) * 0.025))
    }

    self.updateAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        LogProfit(parseFloat(account.Info.totalWalletBalance), account)
    }

    self.CancelAll = function() {
        while (1) {
            var orders = _C(exchange.GetOrders)
            if (orders.length == 0) {
                break
            }
            for (var i = 0; i < orders.length; i++) {
                exchange.CancelOrder(orders[i].Id)
            }
            Sleep(100)
        }
    }

    self.poll = function() {
        self.numTick++
        self.updateTrades()
        self.updateOrderBook()
        var pos = _C(exchange.GetPosition)

        var burstPrice = self.prices[self.prices.length - 1] * burstThresholdPct
        var bull = false
        var bear = false
        LogStatus(_D(), "\n", 'Tick:', self.numTick, 'self.vol:', self.vol, ', lastPrice:', self.prices[self.prices.length - 1], ', burstPrice: ', burstPrice)

        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
        } 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            
        }

        if (pos.length != 0) {
            if (pos[0].Type == PD_LONG) {
                self.state = 1
            } else {
                self.state = 2
            }
        } else {
            self.state = 0
        }


        if ((!bull && !bear)) {
            return
        }

        if (bull) {
            var price = (self.state == 0 || self.state == 1) ? self.buyPrice : self.depth.Bids[coverPendingLevel].Price
            var amount = (self.state == 0 || self.state == 1) ? pendingAmount : pos[0].Amount
            exchange.SetDirection("buy")
            exchange.Buy(price, amount)
        } else if (bear) {
            var price = (self.state == 0 || self.state == 2) ? self.sellPrice : self.depth.Asks[coverPendingLevel].Price
            var amount = (self.state == 0 || self.state == 2) ? pendingAmount : pos[0].Amount
            exchange.SetDirection("sell")
            exchange.Sell(price, amount)                    
        }
        self.numTick = 0
        Sleep(TickInterval)
        self.CancelAll()
        self.updateAccount()
    }

    while (!self.account) {
        self.updateAccount()
        Sleep(500)
    }
    Log("self.account:", self.account)

    return self
}

function main() {
    LogProfitReset()
    exchange.SetPrecision(pricePrecision, amountPrecision)
    exchange.SetContractType("swap")
    var reaper = LeeksReaper()  
    while (true) {
        reaper.poll()
        Sleep(100)
    }
}

रणनीतिक बदलाव

रणनीति का उपयोग करने के लिए योजना बनाई गई है विनान USDT अनुबंध बाजार में व्यापार, विनान अनुबंध का समर्थन करता है एकतरफा होल्डिंग। इसलिए रणनीति को एकतरफा होल्डिंग की विशेषताओं के अनुसार संशोधित किया गया है (एकतरफा होल्डिंग अधिक सुविधाजनक रणनीति संशोधन) ।

रणनीति मूल रूप से मूल संस्करण को बनाए रखने के लिए अल्पकालिक मूल्य प्रवृत्ति के माध्यम से पार करने के लिए निर्धारित मानदंडों, अल्पकालिक मूल्य पार की चौड़ाई पैरामीटर द्वारा निर्धारित किया जाता हैburstThresholdPctनियंत्रण, इस शर्त के आधार पर, अल्पकालिक मूल्य का निर्धारण करने के लिएbull(गाय) याbear(घी) ।

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

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

एक पल के लिए चलें

जैसा कि आप देख सकते हैं, जब बाजार सक्रिय नहीं होता है, तो पोजीशन खोलना मुश्किल होता है।

रणनीतिक अनुकूलन

वर्तमान में, अनुकूलन के लिए कोई अच्छी दिशा नहीं मिली है। यदि आप रुचि रखते हैं, तो कृपया एक साथ चर्चा करने के लिए अपनी राय दें।

इस रणनीति का पताःhttps://www.fmz.com/strategy/260806

इस रणनीति का उपयोग केवल सीखने के लिए किया जाता है, क्योंकि बाजार में एक सपाट वास्तविक स्थिति में नुकसान हो सकता है।