1. वर्ग
  2. द्वि-दिशात्मक अनुबंध ग्रिड लेनदेन v1.0.2

द्वि-दिशात्मक अनुबंध ग्रिड लेनदेन v1.0.2

लेखक:हवा, दिनांक: 2021-06-24 15:37:17
टैगःग्रिड

द्वि-दिशात्मक अनुबंध ग्रिड लेनदेन v1.0.2

फ़ंक्शन

अनुबंध जाल लेनदेन और फिर भी, यह काम करने के लिए अधिक समय देता है दो-तरफा रणनीति के कारण, यह बहुत कम संभावना है।

  • समय से पहले खरीदें
  • दोगुना
  • स्वचालित खाता
  • ट्रेंडिंग ओपन पे ((विकास के लिए, शुल्क संस्करण)
  • तेजी से गिरती गति गतिशील रूप से बदलती संख्या (विकसित, शुल्क संस्करण)
  • गोल्ड फोर्क डेड फोर्क ट्रेंड शामिल हो गया ((विकसित, भुगतान संस्करण)

पुनः परीक्षण डेटा

img

img

साल 2000 के मध्य में दोगुना हुआ लाभ स्पष्ट है, और यह वृद्धि या गिरावट के बावजूद बरकरार रहेगा।

रखरखाव

निरंतर अनुकूलन


/*backtest
start: 2021-01-01 00:00:00
end: 2021-06-21 23:59:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":2000}]
*/

// 首次买入
let FIRST_BUY = true;
// 已存在买涨订单
let MANY_BUYING = false;
// 已存在做空订单
let SHORT_BUYING = false;
// 买涨订单创建时间
let MANY_BUY_TIME = null;
// 做空订单创建时间
let SHORT_BUY_TIME = null;
// 买涨空仓时间
let MANY_EMPTY_STEP_TIME = null;
// 做空空仓时间
let SHORT_EMPTY_STEP_TIME = null;
// 校验空仓时间
let CHECK_TIME = null;

let QUANTITY = [0.001, 0.002, 0.004, 0.008, 0.016, 0.032, 0.064];
// 下次购买价格(多仓)
let MANY_NEXT_BUY_PRICE = 0;
// 下次购买价格(空仓)
let SHORT_NEXT_BUY_PRICE = 0;
// 当前仓位(多仓)
let MANY_STEP = 0;
// 当前仓位(空仓)
let SHORT_STEP = 0;
// 止盈比率
let PROFIT_RATIO = 1;
// 补仓比率
let DOUBLE_THROW_RATIO = 1.5;
// 卖出后下次购买金额下浮比率
let BUY_PRICE_RATIO = 1;
// 交易订单列表(多仓)
let MANY_ORDER_LIST = [];
// 交易订单列表(空仓)
let SHORT_ORDER_LIST = [];

function getManyQuantity() {
    if (MANY_STEP < QUANTITY.length) {
        return QUANTITY[MANY_STEP]
    }
    return QUANTITY[0]
}

function getShortQuantity() {
    if (SHORT_STEP < QUANTITY.length) {
        return QUANTITY[SHORT_STEP]
    }
    return QUANTITY[0]
}

function firstManyBuy(ticker) {
    if (MANY_BUYING) {
        return
    }
    exchange.SetDirection("buy")
    let orderId = exchange.Buy(ticker.Last, getManyQuantity())
    if (!orderId) {
        return
    }
    MANY_BUYING = true
    while (true) {
        exchange.SetDirection("buy") 
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        if (1 === order.Status || 2 === order.Status) {
            MANY_NEXT_BUY_PRICE = order.Price * ((100 - DOUBLE_THROW_RATIO) / 100)
            MANY_STEP = MANY_STEP + 1
            MANY_BUYING = false
            MANY_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 + PROFIT_RATIO) / 100)
            MANY_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
    }
}

function firstShortBuy(ticker) {
    if (SHORT_BUYING) {
        return
    }
    exchange.SetDirection("sell")
    let orderId = exchange.Sell(ticker.Last, getShortQuantity())
    if (!orderId) {
        return
    }
    SHORT_BUYING = true
    while (true) {
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        if (1 === order.Status || 2 === order.Status) {
            SHORT_NEXT_BUY_PRICE = order.Price * ((100 + DOUBLE_THROW_RATIO) / 100)
            SHORT_STEP = SHORT_STEP + 1
            SHORT_BUYING = false
            SHORT_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 - PROFIT_RATIO) / 100)
            SHORT_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
    }
}

function manyBuy(ticker) {
    if (MANY_BUYING) {
        return
    }
    Log('ticker: ' + ticker.Last + ' MANY_NEXT_BUY_PRICE: ' + MANY_NEXT_BUY_PRICE)
    if (ticker.Last > MANY_NEXT_BUY_PRICE) {
        return
    }
    exchange.SetDirection("buy")
    let orderId = exchange.Buy(ticker.Last, getManyQuantity())
    if (!orderId) {
        return
    }
    MANY_BUYING = true
    MANY_BUY_TIME = Unix()
    while (true) {
        let now = Unix()
        let order = exchange.GetOrder(orderId)
        let expire = MANY_BUY_TIME + (60 * 30)
        if (null === order) {
            continue
        }
        // 买入成功处理
        if (1 === order.Status || 2 === order.Status) {
            MANY_NEXT_BUY_PRICE = order.Price * ((100 - DOUBLE_THROW_RATIO) / 100)
            MANY_STEP = MANY_STEP + 1
            MANY_BUYING = false
            MANY_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 + PROFIT_RATIO) / 100)
            MANY_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
        // 买入超时处理
        if (now >= expire) {
            exchange.CancelOrder(orderId)
            MANY_BUYING = false
            MANY_BUY_TIME = null
            MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - DOUBLE_THROW_RATIO) / 100)
            return
        }
    }
}

function shortBuy(ticker) {
    if (SHORT_BUYING) {
        return
    }
    Log('ticker: ' + ticker.Last + ' SHORT_NEXT_BUY_PRICE: ' + SHORT_NEXT_BUY_PRICE)
    if (ticker.Last < SHORT_NEXT_BUY_PRICE) {
        return
    }
    exchange.SetDirection("sell")
    let orderId = exchange.Sell(ticker.Last, getShortQuantity())
    if (!orderId) {
        return
    }
    SHORT_BUYING = true
    SHORT_BUY_TIME = Unix()
    while (true) {
        let now = Unix()
        let expire = SHORT_BUY_TIME + (60 * 30)
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        // 买入成功处理
        if (1 === order.Status || 2 === order.Status) {
            SHORT_NEXT_BUY_PRICE = order.Price * ((100 + DOUBLE_THROW_RATIO) / 100)
            SHORT_STEP = SHORT_STEP + 1
            SHORT_BUYING = false
            SHORT_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 - PROFIT_RATIO) / 100)
            SHORT_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
        // 买入超时处理
        if (now >= expire) {
            exchange.CancelOrder(orderId)
            SHORT_BUYING = false
            SHORT_BUY_TIME = null
            SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + DOUBLE_THROW_RATIO) / 100)
            return
        }
    }
}


function manySell(ticker) {
    // 遍历卖出订单
    for (let item of MANY_ORDER_LIST) {
        if (item.isSell) {
            continue
        }
        if (ticker.Last >= item.sellPrice) {
            item.isSell = true;
            exchange.SetDirection("closebuy")
            let orderId = exchange.Sell(ticker.Last, item.quantity)
            if (!orderId) {
                return
            }
            while (true) {
                let order = exchange.GetOrder(orderId)
                if (null === order) {
                    continue
                }
                if (1 === order.Status || 2 === order.Status) {
                    MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - BUY_PRICE_RATIO) / 100)
                    MANY_STEP = MANY_STEP - 1
                    if (0 === MANY_STEP) {
                        MANY_EMPTY_STEP_TIME = Unix()
                    }
                    break
                }
            }
        }
    }
}

function shortSell(ticker) {
    // 遍历卖出订单
    for (let item of SHORT_ORDER_LIST) {
        if (item.isSell) {
            continue
        }
        if (ticker.Last <= item.sellPrice) {
            item.isSell = true;
            exchange.SetDirection("closesell")
            let orderId = exchange.Buy(ticker.Last, item.quantity)
            if (!orderId) {
                return
            }
            while (true) {
                let order = exchange.GetOrder(orderId)
                if (null === order) {
                    continue
                }
                if (1 === order.Status || 2 === order.Status) {
                    SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + BUY_PRICE_RATIO) / 100)
                    SHORT_STEP = SHORT_STEP - 1
                    if (0 === SHORT_STEP) {
                        SHORT_EMPTY_STEP_TIME = Unix()
                    }
                    break
                }
            }
        }
    }
}

function check(ticker) {
    let now = Unix()
    if (null !== CHECK_TIME) {
        let expire = CHECK_TIME + (60 * 10)
        if (now < expire) {
            return
        }
    }
    CHECK_TIME = now

    if (null !== MANY_EMPTY_STEP_TIME) {
        let expire = MANY_EMPTY_STEP_TIME + (60 * 30)
        if (now >= expire) {
            MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - DOUBLE_THROW_RATIO) / 100)
            Log('没有买涨持仓, 调整买入价: ' + MANY_NEXT_BUY_PRICE)
        }
    }
    
    if (null !== SHORT_EMPTY_STEP_TIME) {
        let expire = SHORT_EMPTY_STEP_TIME + (60 * 30)
        if (now >= expire) {
            SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + DOUBLE_THROW_RATIO) / 100)
            Log('没有做空持仓, 调整买入价: ' + SHORT_NEXT_BUY_PRICE)
        }
    }
}

function onTick() {
    // 在这里写策略逻辑，将会不断调用，例如打印行情信息
    let ticker = exchange.GetTicker()
    if (!ticker) {
        return
    }
    if (FIRST_BUY) {
        // 首次做多购买
        firstManyBuy(ticker)
        // 首次做空购买
        firstShortBuy(ticker)
        FIRST_BUY = false
        return
    }
    
    // 做多买入
    manyBuy(ticker)
    // 做空买入
    shortBuy(ticker)
    // 做多卖出
    manySell(ticker)
    // 做空卖出
    shortSell(ticker)
    // 空仓检测
    check(ticker)
}

function main() {
    // 开合约
    exchange.SetContractType("swap")

    while(true){
        onTick()
        // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁
        Sleep(60000)
    }
}
संबंधित
अधिक

हेक्सी8क्या बहु मुद्राओं का विकास संभव है?

रिच_रोरीcheck का क्या मतलब है...... नियमित रूप से बढ़ना / घटाना खरीद सीमा? इसका क्या अर्थ है?

आर्ट्रोनयह नीति पैरामीटर सेट क्यों नहीं है?

Exodus[संपादित करें]यह भी पता चला है कि 2020-1-1 से 2020-6 के बीच के समय में, 3-30 तक सभी रोबोट बंद हो जाते हैं, इसके अलावा, 2021-1-1 से 201-6-21 तक के परीक्षण के दौरान ईटीएच परीक्षण 1-2 पर बंद हो जाता है, मुझे नहीं पता कि यह एफएमजेड की समस्या है या रोबोट की समस्या है। लेखक स्वयं परीक्षण कर सकते हैं।

इवनयह वास्तविक बहु-अवकाश हेजिंग नहीं है, यह अनुबंध जाल की तरह है।

Exodus[संपादित करें]इसके अलावा लेखक वीक्यूएस ने कोई प्रतिक्रिया नहीं दी है, केवल यहां आने के लिए कुछ शब्द कह सकते हैं, 7 दिनों के लिए 200 चाकू और 70 चाकू। बहुत अच्छा है, लेकिन मैंने कुछ समस्याओं का पता लगाया। 1. दो-तरफा एकल विकल्प सामान्य है? देखें कि रणनीति में कहा गया है कि दो-तरफा विकल्प, उछाल की संभावना बहुत कम है, लेकिन सात दिनों के भीतर रोबोट को शुरू करने के अलावा दो-तरफा विकल्प खोला गया, लगभग कोई दो-तरफा विकल्प नहीं है, मेरे शोध के बाद पाया गया कि 10 मिनट में एक बार विकल्प की स्थिति को अद्यतन करना, जो धीमी गति से परिवर्तन का कारण बनता है, कोई अर्थ नहीं है, और न ही दो-तरफा विकल्प खोला गया है, जैसे कि आज बीटीसी में 5% की गिरावट नहीं है? क्या यहां अनुकूलन की आवश्यकता है? उदाहरण के लिए, विस्तारित जांच अंतराल? इसके अलावा, यदि बड़े बाजार में एक ही विकल्प खोला गया है, तो एक ही विकल्प खोला गया है, तो यह बहुत समझ में नहीं आता है। या क्या दो-तरफा विकल्प खोलने का मतलब है कि दो-तरफा विकल्पों को खाना है, और यह एक ही विकल्प को रोक सकता है? 2. डिफ़ॉल्ट जमा राशि के बारे में, मुझे 1000 चाकू से 2000 चाकू से अधिक की गारंटी देने की आवश्यकता है, मेरे पास दो सौ चाकू हैं, अगर मैं आज अचानक जाग गया हूं तो मैं पहले से ही जमा कर चुका हूं, अस्थायी रूप से अतिरिक्त गारंटी राशि। यदि पर्याप्त धन नहीं है, तो आप स्वयं जमा राशि की मात्रा को मैन्युअल रूप से समायोजित कर सकते हैं, यहां याद दिलाएं, ताकि कोड के जमा राशि को न देखें। 3. कृपया पूछें, क्योंकि नुकसान कभी नहीं रुकता है, तो क्या पूंजी पर्याप्त होने पर कभी भी ब्लास्ट नहीं होगा, लेकिन पुनर्मूल्यांकन में नुकसान क्यों होगा? सैद्धांतिक रूप से नुकसान ब्लास्ट है, या पैसा शून्य है, ठीक है, मैं गलत कहां समझता हूं, संकेत मांगें। यह रणनीति मुझे बहुत पसंद है, आप दिशा की परवाह किए बिना लाभ प्राप्त कर सकते हैं, बढ़ोतरी को समायोजित करने और पूंजी के बारे में बोलने के लिए जोखिम कम है, यह महसूस करने के लिए कि खुले और अधिक कीमतों को समायोजित करने के लिए अनुकूलित किया जा सकता है, पूंजी के आधार पर अनुकूलित बढ़ोतरी आदि।

हाँXबड़े भाई ने ट्वीट किया

Exodus[संपादित करें]यह ठीक है, और यह बिनान के लिए काम करता है।

Exodus[संपादित करें]पुनः परीक्षण करना अच्छा लगता है, लेकिन क्या ऐसा लगता है कि यह वास्तविक डिस्क पर उपयोग नहीं किया जा सकता है? मेरे टोकन को खोलने पर bch त्रुटि देता है, Sell ((490.14, 0.001): map[err_code:1067 err_msg:The volume field is illegal. Please re-enter. status:error ts:1.625132342294e+12]. अनुबंध के पीछे अंक नहीं है, क्यों अंश है?

वब्सीकोई वास्तविक प्लेट नहीं?

Exodus[संपादित करें]यह एक भयानक लाभ है, 120% से अधिक खो गया है।

शराबी ने लाइट उठाई और तलवार को देखामुझे मारने के लिए मुस्कुराया।

Exodus[संपादित करें]दुख की बात है, आज हम घाटे में हैं, हम 2.0 की प्रतीक्षा कर रहे हैं, कृपया पूछें कि हम नई रणनीति का अनुभव कैसे कर सकते हैं।

हवाविकास 2.0 में ये समस्याएं सामने आईं। और यह इसलिए है क्योंकि यह एक निश्चित प्रतिशत है, यानी एक प्रतिशत की वृद्धि, एक प्रतिशत की गिरावट, एक प्रतिशत की गिरावट, एक प्रतिशत की गिरावट, एक प्रतिशत की गिरावट। चूंकि गिरावट एक प्रतिशत है, गिरावट में खरीद प्रतिशत एक समान है, 1000 टन से 1500 तक, 1000 प्रतिशत और 1500 प्रतिशत में अंतर है, इसलिए खाली करना खरीदना मुश्किल है, और कीमतों में बदलाव बहुत बार होता है और इससे खाली करना संभव नहीं है स्टॉप-लॉस समस्या, 2.0 संस्करण में एक निश्चित प्रसंस्करण किया गया है, एक बहुत ही सरल स्टॉप-लॉस प्रसंस्करण है, लेकिन बैक-टेस्ट डेटा से यह भी संभव है, जब आप एक निश्चित थ्रेशोल्ड तक पहुंचते हैं, तो आप एक स्टॉक खरीदते हैं या एक खाली स्थिति बनाते हैं, 1.0 में कोई प्रसंस्करण नहीं होता है, इसलिए कुछ ऑर्डर कभी भी लेनदेन नहीं कर सकते हैं, जैसे कि बीटीसी 65000 में खरीदारों की संख्या 0.001 है, तो बीटीसी गिर जाता है यह सूची कभी नहीं निकल सकती है /upload/asset/2034c4ec56c423120b9c6.png /upload/asset/203032c94e60a3915cc9f.png /upload/asset/2030b880b030476977f4b.png /upload/asset/2030d89e9fd59f528be4c.png

हवामैं बिनान का उपयोग कर रहा हूं और परीक्षण कर रहा हूं कि अन्य प्लेटफार्मों पर चल रहे वास्तविक डिस्क में कुछ त्रुटियां हो सकती हैं।

हवावास्तविक डिस्क अभी भी चल रही है, समय चाहिए

हवाऔर अब आप देख सकते हैं कि क्या यह एक त्रुटि है जो अभी लिखा गया है।

2019 FMZ - सभी अधिकार सुरक्षित