2. 程式人生 > >跨期布林對衝策略研究-基於發明者量化平臺

跨期布林對衝策略研究-基於發明者量化平臺

阿新 • • 發佈：2018-11-25

（Boll）指標是股市技術分析的常用工具之一，通過計算股價的“標準差”，再求股價的“信賴區間”。該指標在圖形上畫出三條線，其中上下兩條線可以分別看成是股價的壓力線和支撐線，而在兩條線之間還有一條股價平均線，布林線指標的引數最好設為20。一般來說，股價會執行在壓力線和支撐線所形成的通道中。

與MACD、RSI、KDJ等指標一樣，BOLL指標也是股票市場最實用的技術分析參考指標。

 

但是這些指標也都是對於歷史資料的統計計算形成的，客觀的講是不能絕對預測未來標的物的走勢行情的。根據歷史的行情資料，計算出的指標，可以作為參考、輔助決策，最終會發現一切都是圍繞著概率。

 

那麼 BOLL 指標的實際意義是 標的物價格的 標準差，期貨的不同合約之間都有一定的價差，通常情況下 行情平穩的時候價差是保持一定趨勢緩慢變動的，遇到“不理性”的訂單的時候往往會出現短暫的波動，試想如何抓住這些“不理性”的訂單呢？

 

我們考慮構建一個 《跨期布林對衝策略》 ，從底層擼程式碼、造車輪 太慢了， 使用 BotVS 分分鐘實現你的各種交易思路。

 

實現這個策略，我們選擇標的物為 ： OKEX 的 BTC 合約， 稍後我也會寫出 標的物 為： 商品期貨 合約的該策略 （為什麼用BTC 合約？ 因為好實現，方便快速寫出來 測試！標的物只是一方面，關鍵是思路 、策略！）

 

跨期布林對衝策略

var P_isSetOneKLine = true;
var isShowChart = true;
var retrySlidePrice = 2;

// 全域性變數
var KPeriod = [PERIOD_M1, PERIOD_M5, PERIOD_M15, PERIOD_M30, PERIOD_H1, PERIOD_D1][P_KPeriod];
var DiffData = {       // 差價K線資料
    plusKLine : [],      // 差價K線陣列
    minusKLine : [],
    KPeriod : KPeriod,    // 差價K線週期
};

var distance = 0;                     // 距離
var IDLE = 0;
var PLUS = 1;
var MINUS = 2;
var State = IDLE;                     // 策略 執行狀態狀態
var perState = IDLE;

var OPEN = 3;                         // 用於區分  是那種操作  在 BuyA_SellB 、 SellA_BuyB  函式中
var COVER = 4;
var isTradeOnThisBar = false;         // 是否在當前Bar 交易了   廢棄
var isCoverOnthisBar = false;         //                     廢棄
var upRatio = 0;
var downRatio = 0;

var P = null;                         // 交易控制物件
var ManagerData = {                   // 控制物件
    initAccount : null,               // 初始賬戶 資訊
    Account : null,                   // 當前賬戶 資訊
    perAccount : null,
    MaxUsedRatio : MaxUsedRatio,      // 最大 保證金使用率
    MaxUsedMargin : 0,                // 每次 平倉後 重新計算的 最大保證金使用量
    APosition : null,                 // 多頭 倉位資訊
    BPosition : null,                 // 空頭 倉位資訊 
    floatProfit : 0,                  // 浮動盈虧 
    CoverProfit : 0,                  // 平倉盈虧
    MarginLevel : MarginLevel,        // 槓桿數
    Margin : 0,                       // 當前保證金使用

    // 行情資料
    DepthA : null,                    // A 合約的 深度資料
    DepthB : null,                    // B 合約的 深度資料

    // 錯誤資訊
    ErrorStr : "",                    // 錯誤資訊字串
    ErrorTimeStamp : 0,               // 錯誤資訊 時間戳
}

var DiffDataOneKLine = {              // K線結構
    KLine : [],                       // K線陣列 ，整理後的差價
    KPeriod : KPeriod,                // K線週期
}
var test = {                          // 測試 模式 使用的結構
    amount : 4,
    ProfitDiff : 0,
    ID : 0,
    OpenDiff : 0,
};
var perRecordsTime = 0;               // 合成的 K線 上一個bar 的時間戳

var PeriodBeginTime = 0;              // 週期起始時間

function UpdateDiffData(DepthA, DepthB, RecordsA, RecordsB){ // 處理差價K線資料的更新
    var plusDiff = DepthA.Bids[0].Price - DepthB.Asks[0].Price;
    var minusDiff = DepthA.Asks[0].Price - DepthB.Bids[0].Price;
    if(P_isSetOneKLine){
        var Diff = _N((plusDiff + minusDiff) / 2 , 4);
    }
    if(RecordsA[RecordsA.length - 1].Time == RecordsB[RecordsB.length - 1].Time && RecordsB[RecordsB.length - 1].Time !== PeriodBeginTime){
        if(!P_isSetOneKLine){
            // 新K線週期出現
            var plusBar = {
                Open : plusDiff,
                Close : plusDiff,
                High : plusDiff,
                Low : plusDiff,
                Time : 0,
            };

            var minusBar = {
                Open : minusDiff,
                Close : minusDiff,
                High : minusDiff,
                Low : minusDiff,
                Time : 0,
            };

            PeriodBeginTime = RecordsB[RecordsB.length - 1].Time;
            plusBar.Time = PeriodBeginTime;
            minusBar.Time = PeriodBeginTime;
            DiffData.plusKLine.push(plusBar);
            DiffData.minusKLine.push(minusBar);
        }else{
            var Bar = {
                Open : Diff,
                Close : Diff,
                High : Diff,
                Low : Diff,
                Time : 0,
            };
            PeriodBeginTime = RecordsB[RecordsB.length - 1].Time;
            Bar.Time = PeriodBeginTime;
            DiffDataOneKLine.KLine.push(Bar);
        }
    }else{
        if(!P_isSetOneKLine){
            if(plusDiff > DiffData.plusKLine[DiffData.plusKLine.length - 1].High){
                DiffData.plusKLine[DiffData.plusKLine.length - 1].High = plusDiff;
            }else if(plusDiff < DiffData.plusKLine[DiffData.plusKLine.length - 1].Low){
                DiffData.plusKLine[DiffData.plusKLine.length - 1].Low = plusDiff;
            }
            DiffData.plusKLine[DiffData.plusKLine.length - 1].Close = plusDiff;

            if(minusDiff > DiffData.minusKLine[DiffData.minusKLine.length - 1].High){
                DiffData.minusKLine[DiffData.minusKLine.length - 1].High = minusDiff;
            }else if(minusDiff < DiffData.minusKLine[DiffData.minusKLine.length - 1].Low){
                DiffData.minusKLine[DiffData.minusKLine.length - 1].Low = minusDiff;
            }
            DiffData.minusKLine[DiffData.minusKLine.length - 1].Close = minusDiff;
        }else{
            if(Diff > DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].High){
                DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].High = Diff;
            }else if(Diff < DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Low){
                DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Low = Diff;
            }
            DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close = Diff;
        }
    }

    if(!P_isSetOneKLine){
        if(DiffData.plusKLine.length > 100){
            DiffData.plusKLine.shift();
        }

        if(DiffData.minusKLine.length > 100){
            DiffData.minusKLine.shift();
        }
    }else{
        if(DiffDataOneKLine.KLine.length > 100){
            DiffDataOneKLine.KLine.shift();
        }
    }
}

function UseAPI(fun, symbol, param){
    exchange.SetContractType(symbol);
    if(typeof(param) == "undefined"){
        return fun();
    }else{
        return fun(param);
    }
}

function GetPositions(){
    var positions = _C(exchange.GetPosition);
    for(var i = 0; i < positions.length; i++){
        if(positions[i].ContractType == P_SymbolA){
            ManagerData.APosition = positions[i];
        }else if(positions[i].ContractType == P_SymbolB){
            ManagerData.BPosition = positions[i];
        }else if(i == 2){
            throw "error:" + JSON.stringify(positions);
        }
    }
    if(positions.length == 0){
        ManagerData.APosition = null;
        ManagerData.BPosition = null;
    }
    return positions;
}

function SellA_BuyB(DiffPrice, Action){
    // GetBestAmount
    var Piece = P_piece;
    if(Action == OPEN){
        // 檢查 是否超出 保證金
        var MarginAndAmount_A = CalcPieceEqualAmount(ManagerData.DepthA.Bids[0].Price, Piece);
        var MarginAndAmount_B = CalcPieceEqualAmount(ManagerData.DepthB.Asks[0].Price, Piece);
        if(MarginAndAmount_A.NeedMargin + MarginAndAmount_B.NeedMargin + ManagerData.Margin > ManagerData.MaxUsedMargin){
            ManagerData.ErrorStr = "超過最大可用保證金：" + ManagerData.MaxUsedMargin;
            ManagerData.ErrorTimeStamp = new Date().getTime();
            return false;
        }
        // 交易
        _C(exchange.SetContractType, P_SymbolA);
        var infoA = P.OpenShort(P_SymbolA, Piece, ManagerData.DepthA.Bids[0].Price);
        if(infoA.amount == 0){
            return false;
        }
        _C(exchange.SetContractType, P_SymbolB);
        var dealAmount = infoA.amount;
        var infoB = P.OpenLong(P_SymbolB, dealAmount, ManagerData.DepthB.Asks[0].Price);
        var slidePrice = retrySlidePrice;  
        while((dealAmount -= infoB.amount) > 0){
            infoB = P.OpenLong(P_SymbolB, dealAmount, ManagerData.DepthB.Asks[0].Price + slidePrice);
            slidePrice += retrySlidePrice;
            LogStatus("while(), P_SymbolB:", P_SymbolB, infoB, dealAmount, slidePrice);
        }

        // 更新資料
        ManagerData.perAccount = ManagerData.Account;
        ManagerData.Account = _C(exchange.GetAccount);
        ManagerData.Margin += (ManagerData.perAccount.Stocks - ManagerData.Account.Stocks);
        Log("持倉資訊：", GetPositions(), "本次使用保證金：", (ManagerData.perAccount.Stocks - ManagerData.Account.Stocks));
        perState = State;
        State = PLUS;
    }else if(Action == COVER){
        // 全平
        _C(exchange.SetContractType, P_SymbolA);
        var infoA = P.Cover(P_SymbolA, ManagerData.DepthA.Bids[0].Price, Math.min(ManagerData.APosition.Amount, Math.max(_N(ManagerData.APosition.Amount * CoverRatio, 0), minCoverAmount)), PD_LONG);
        if(infoA == 0){
            return false;
        }
        _C(exchange.SetContractType, P_SymbolB);
        var dealAmount = infoA;
        var infoB = P.Cover(P_SymbolB, ManagerData.DepthB.Asks[0].Price, dealAmount, PD_SHORT);
        var slidePrice = retrySlidePrice;
        while((dealAmount -= infoB) > 0){
            infoB = P.Cover(P_SymbolB, ManagerData.DepthB.Asks[0].Price + slidePrice, dealAmount, PD_SHORT);  
            slidePrice += retrySlidePrice;
            LogStatus("while(), P_SymbolB:", P_SymbolB, infoB, dealAmount, slidePrice);
        }
        Log("持倉資訊：", GetPositions());
        if(ManagerData.APosition == null && ManagerData.BPosition == null){
            perState = State;
            State = IDLE;
            upRatio = 0;
            downRatio = 0;
            Log("完全平倉！#FF0000");
            Log("更新最大保證金使用量：", DealManagerData());
            LogProfit(ManagerData.Account.Stocks - ManagerData.initAccount.Stocks);  // ceshi 
        }else{
            ManagerData.perAccount = ManagerData.Account;
            ManagerData.Account = _C(exchange.GetAccount); 
            Log("部分平倉：", infoA);
        }
    }
    return true;
}

function BuyA_SellB(DiffPrice, Action){
    // GetBestAmount
    var Piece = P_piece;
    if(Action == OPEN){
        // 檢查 是否超出 保證金
        var MarginAndAmount_A = CalcPieceEqualAmount(ManagerData.DepthA.Asks[0].Price, Piece);
        var MarginAndAmount_B = CalcPieceEqualAmount(ManagerData.DepthB.Bids[0].Price, Piece);
        if(MarginAndAmount_A.NeedMargin + MarginAndAmount_B.NeedMargin + ManagerData.Margin > ManagerData.MaxUsedMargin){
            ManagerData.ErrorStr = "超過最大可用保證金：" + ManagerData.MaxUsedMargin;
            ManagerData.ErrorTimeStamp = new Date().getTime();
            return false;
        }
        // 交易
        _C(exchange.SetContractType, P_SymbolA);
        var infoA = P.OpenLong(P_SymbolA, Piece, ManagerData.DepthA.Asks[0].Price);
        if(infoA.amount == 0){
            return false;
        }
        _C(exchange.SetContractType, P_SymbolB);
        var dealAmount = infoA.amount;
        var infoB = P.OpenShort(P_SymbolB, dealAmount, ManagerData.DepthB.Bids[0].Price);
        var slidePrice = retrySlidePrice; 
        while((dealAmount -= infoB.amount) > 0){
            infoB = P.OpenShort(P_SymbolB, dealAmount, ManagerData.DepthB.Bids[0].Price - slidePrice);
            slidePrice += retrySlidePrice;
            LogStatus("while(), P_SymbolB:", P_SymbolB, infoB, dealAmount, slidePrice);
        }

        // 更新資料
        ManagerData.perAccount = ManagerData.Account;
        ManagerData.Account = _C(exchange.GetAccount);
        ManagerData.Margin += (ManagerData.perAccount.Stocks - ManagerData.Account.Stocks);
        Log("持倉資訊：", GetPositions(), "本次使用保證金：", (ManagerData.perAccount.Stocks - ManagerData.Account.Stocks));
        perState = State;
        State = MINUS;
    }else if(Action == COVER){
        // 全平
        _C(exchange.SetContractType, P_SymbolA);
        var infoA = P.Cover(P_SymbolA, ManagerData.DepthA.Asks[0].Price, Math.min(ManagerData.APosition.Amount, Math.max(_N(ManagerData.APosition.Amount * CoverRatio, 0), minCoverAmount)), PD_SHORT);
        if(infoA == 0){
            return false;
        }
        _C(exchange.SetContractType, P_SymbolB);
        var dealAmount = infoA;
        var infoB = P.Cover(P_SymbolB, ManagerData.DepthB.Bids[0].Price, dealAmount, PD_LONG);
        var slidePrice = retrySlidePrice;
        while((dealAmount -= infoB) > 0){
            infoB = P.Cover(P_SymbolB, ManagerData.DepthB.Bids[0].Price - slidePrice, dealAmount, PD_LONG);
            slidePrice += retrySlidePrice;
            LogStatus("while(), P_SymbolB:", P_SymbolB, infoB, dealAmount, slidePrice);
        }
        Log("持倉資訊：", GetPositions());
        if(ManagerData.APosition == null && ManagerData.BPosition == null){
            perState = State;
            State = IDLE;
            upRatio = 0;    // 重置
            downRatio = 0;  // 重置
            Log("完全平倉！#FF0000");
            Log("更新最大保證金使用量：", DealManagerData());
            LogProfit(ManagerData.Account.Stocks - ManagerData.initAccount.Stocks);  // ceshi 
        }else{
            ManagerData.perAccount = ManagerData.Account;
            ManagerData.Account = _C(exchange.GetAccount); 
            Log("部分平倉：", infoA);
        }
    }
    return true;
}

function DealManagerData(){                                                       // 處理 ManagerData
    ManagerData.perAccount = ManagerData.Account;
    ManagerData.Account = _C(exchange.GetAccount);                                // 獲取 平倉後的 賬戶資訊
    var Position = _C(exchange.GetPosition);                                      // 獲取 平倉後的持倉資訊
    if(Position.length == 0){                                                     // 如果 平倉完成 ，沒有持倉了 重置 ManagerData 的 持倉資訊屬性
        ManagerData.APosition = null;
        ManagerData.BPosition = null;
        ManagerData.Margin = 0;                                                   // 重置 當前使用的保證金 為 0
    }else{                                                                        // 如果有持倉 報錯，列印持倉
        Log("平倉後還有持倉！", Position, "#FF0000");
        throw "error!";
    }
    ManagerData.MaxUsedMargin = _N(ManagerData.Account.Stocks * ManagerData.MaxUsedRatio, 2);         // 計算下一輪 最大的 保證金使用量
    return ManagerData.MaxUsedMargin;
}

function CalcPieceEqualAmount(Price, Piece){
   return {
            EqualAmount : (100 / Price * Piece), 
            NeedMargin : (100 / Price * Piece) / ManagerData.MarginLevel,
        }
}

function Loop(nowTime){       // 主迴圈
    var DepthA = UseAPI(exchange.GetDepth, P_SymbolA);
    var DepthB = UseAPI(exchange.GetDepth, P_SymbolB);

    var RecordsA = UseAPI(exchange.GetRecords, P_SymbolA, KPeriod);
    var RecordsB = UseAPI(exchange.GetRecords, P_SymbolB, KPeriod);

    // 過濾資料
    if(!RecordsA || !RecordsB || !DepthA || !DepthB || DepthA.Bids.length == 0 || DepthA.Asks.length == 0 || 
            DepthB.Bids.length == 0 || DepthB.Asks.length == 0 || RecordsA.length == 0 || RecordsB.length == 0){
        return;
    }

    ManagerData.DepthA = DepthA;
    ManagerData.DepthB = DepthB;

    // 更新 差價K線資料
    UpdateDiffData(DepthA, DepthB, RecordsA, RecordsB);

    if(isShowChart == true){
        if(!P_isSetOneKLine){
            $.PlotRecords(DiffData.plusKLine, 'plus');
        }else{
            $.PlotRecords(DiffDataOneKLine.KLine, 'KLine');
        }
    }

    // BOLL
    if(P_isSetOneKLine && DiffDataOneKLine.KLine.length > 20){
        var boll = TA.BOLL(DiffDataOneKLine.KLine);
        var up = boll[0];
        var mid = boll[1];
        var down = boll[2];

        if(perRecordsTime !== DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time){
            if(isShowChart == true){
                $.PlotLine("up", up[up.length - 2], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 2].Time);
                $.PlotLine("mid", mid[mid.length - 2], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 2].Time);
                $.PlotLine("down", down[down.length - 2], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 2].Time);

                $.PlotLine("up", up[up.length - 1], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time);
                $.PlotLine("mid", mid[mid.length - 1], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time);
                $.PlotLine("down", down[down.length - 1], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time);

                // $.PlotHLine(up[up.length - 1], 'UpTrack', "red");
                // $.PlotHLine(down[down.length - 1], 'DownTrack', "green");
            }
            perRecordsTime = DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time;
            isTradeOnThisBar = false;       // 重置 是否當前Bar 交易的標記為 false
            isCoverOnthisBar = false;
        }else{
            if(isShowChart == true){
                $.PlotLine("up", up[up.length - 1], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time);
                $.PlotLine("mid", mid[mid.length - 1], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time);
                $.PlotLine("down", down[down.length - 1], DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time);

                // $.PlotHLine(up[up.length - 1], 'UpTrack', "red");
                // $.PlotHLine(down[down.length - 1], 'DownTrack', "green");
            }
        }


        // 突破判斷
        // 計算加倉距離
        distance = _N((up[up.length - 1] - down[down.length - 1]) * 0.5, 0);

        if(distance * 2 < 20 && (upRatio == 0 && downRatio == 0)){  // 計算安全間距
            return;
        }

        if(DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close > up[up.length - 1]){
            if((State == IDLE || State == PLUS) && (DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close > (up[up.length - 1] + upRatio * distance)) /*&& isTradeOnThisBar == false*/){  // Open PLUS
                if(P_isSetTest){
                    // 模擬
                    $.PlotFlag(nowTime, 'plus', 'P', 'flag', 'red');
                    State = PLUS;
                    exchange.Log(LOG_TYPE_SELL, test.ID++, DepthA.Bids[0].Price, test.amount, "Open:" + P_SymbolA);
                    exchange.Log(LOG_TYPE_BUY, test.ID++, DepthB.Asks[0].Price, test.amount, "Open:" + P_SymbolB);
                    test.OpenDiff = DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close;
                }else{
                    var info = SellA_BuyB(DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close, OPEN);
                    if(info == false){
                        return;
                    }
                    $.PlotFlag(nowTime, 'plus', 'P', 'flag', 'red');
                    isTradeOnThisBar = true;
                    upRatio += Add_lv;   
                }
            }else if(State == MINUS /*&& isCoverOnthisBar == false*/){  // Cover MINUS
                if(P_isSetTest){
                    // 模擬
                    $.PlotFlag(nowTime, 'Cover_Minus', 'CM', 'circlepin', 'blue');
                    State = IDLE;
                    exchange.Log(LOG_TYPE_SELL, test.ID++, DepthA.Bids[0].Price, test.amount, "Cover:" + P_SymbolA);
                    exchange.Log(LOG_TYPE_BUY, test.ID++, DepthB.Asks[0].Price, test.amount, "Cover:" + P_SymbolB);
                    test.ProfitDiff += DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close - test.OpenDiff;
                    Log("本次盈虧：" + (DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close - test.OpenDiff));
                    LogProfit(test.ProfitDiff);
                }else{
                    // SellA_BuyB    
                    var info = SellA_BuyB(DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close, COVER);
                    if(info == false){
                        Log("MINUS 平倉失敗！");
                        return;
                    }
                    $.PlotFlag(nowTime, 'Cover_Minus', 'CM', 'circlepin', 'blue');
                    isCoverOnthisBar = true;
                }
            }
        }else if(DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close < down[down.length - 1]){
            if((State == IDLE || State == MINUS) && (DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close < (down[down.length - 1] - downRatio * distance)) /*&& isTradeOnThisBar == false*/){
                if(P_isSetTest){
                    // 模擬
                    $.PlotFlag(nowTime, 'minus', 'M', 'circlepin', 'green'); // DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Time
                    State = MINUS;
                    exchange.Log(LOG_TYPE_BUY, test.ID++, DepthA.Asks[0].Price, test.amount, "Open:" + P_SymbolA);
                    exchange.Log(LOG_TYPE_SELL, test.ID++, DepthB.Bids[0].Price, test.amount, "Open:" + P_SymbolB);
                    test.OpenDiff = DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close;
                }else{
                    // BuyA_SellB
                    var info = BuyA_SellB(DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close, OPEN);
                    if(info == false){
                        return;
                    }
                    $.PlotFlag(nowTime, 'minus', 'M', 'circlepin', 'green');
                    isTradeOnThisBar = true;
                    downRatio += Add_lv; 
                }
            }else if(State == PLUS /*&& isCoverOnthisBar == false*/){
                if(P_isSetTest){
                    // 模擬
                    $.PlotFlag(nowTime, 'Cover_Plus', 'CP', 'flag', 'blue');
                    State = IDLE;
                    exchange.Log(LOG_TYPE_BUY, test.ID++, DepthA.Asks[0].Price, test.amount, "Cover:" + P_SymbolA);
                    exchange.Log(LOG_TYPE_SELL, test.ID++, DepthB.Bids[0].Price, test.amount, "Cover:" + P_SymbolB);
                    test.ProfitDiff += test.OpenDiff - DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close;
                    Log("本次盈虧：" + (test.OpenDiff - DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close));
                    LogProfit(test.ProfitDiff);
                }else{
                    // BuyA_SellB
                    var info = BuyA_SellB(DiffDataOneKLine.KLine[DiffDataOneKLine.KLine.length - 1].Close, COVER);
                    if(info == false){
                        Log("PLUS 平倉失敗！");
                        return;
                    }
                    $.PlotFlag(nowTime, 'Cover_Plus', 'CP', 'flag', 'blue');
                    isCoverOnthisBar = true;
                }
            }
        }
    }

}

function main(){
    // 初始化工作
    if(isLogReset){
        LogReset(1);
    }
    Log("最大保證金使用量：", DealManagerData());
    ManagerData.initAccount = ManagerData.Account;
    ManagerData.perAccount = ManagerData.Account;
    exchange.SetMarginLevel(ManagerData.MarginLevel); // 初始設定槓桿

    // 設定禁用匯率
    exchange.SetRate(1);
    Log("已禁用匯率，顯示價格為美元價格！");

    // 建立交易控制物件
    P = $.NewPositionManager(exchange);

    //主要迴圈
    while(true){
        var nowTime = new Date().getTime();
        Loop(nowTime);
        LogStatus("時間：", _D(nowTime), '\n', P_isSetTest ? JSON.stringify(test) : "Margin: " + ManagerData.Margin, '\n', ManagerData.ErrorStr, _D(ManagerData.ErrorTimeStamp), '\n', 
            ManagerData.initAccount, '\n', ManagerData.Account, '\n', ManagerData.APosition, '\n', ManagerData.BPosition, '\n', "upRatio:" + upRatio, '\n', "downRatio:" + downRatio, "distance:" + distance);
        Sleep(P_Interval);
    }
}

 

程式語言使用的是 JavaScript , 引用了 “ 模板-畫線類庫” 和 “ OKCoin期貨跨期對衝策略(模板測試使用)” 兩個模板， 策略公開地址： https://www.botvs.com/strategy/43049** 宣告：

 

該策略為平臺使用者 小小夢 分享，主要用於發明者量化平臺策略編寫學習， 實盤雖可用，風險自擔！ 歡迎大家討論，多交流，多學習，多提升！ 作者本人其實不喜歡閉門造車，進步就要互相學習！

 

上個回測：

回測

因為頻率挺高的，回測滑點等因素影響較小，所以回測僅供參考，策略應該可以進一步優化，小心引數撞車！原創文章，發明者量化版權所有。

相關推薦

跨期布林對衝策略研究-基於發明者量化平臺

（Boll）指標是股市技術分析的常用工具之一，通過計算股價的“標準差”，再求股價的“信賴區間”。該指標在圖形上畫出三條線，其中上下兩條線可以分別看成是股價的壓力線和支撐線，而在兩條線之間還有一條股價平均線，布林線指標的引數最好設為20。一般來說，股價會執行在壓力線和支撐線所形成的通道中。

量化對衝網格模型基於發明者平臺的比特幣OKCoin期貨交易策略

OKCoin期貨跨期對衝策略，季度、當週、次周 1、 季度-當週 2、 季度-次周 3、 當週-次周 4、在週五交割前5分鐘會自動 平倉， 鎖定15分鐘 後再正常執行。 作者本人呢 是菜鳥程式猿一個， 平時沒什麼愛好，就喜歡寫程式碼。最近一年在發明者量化上學到了不少

基於布林帶的股票量化擇時策略研究

策略介紹: 該布林策略經回測，2007-01-01 到 2017-01-01，選用滬深 300 前 100 只股作 為樣本，在聚寬平臺上回測結果如下： 該策略十年收益為 255.44%，策略年化收益為 13.92%，Alpha 是投資者獲得與市 場波動無關的回報， 即超額收益

【策略研究】跨品種價差套利策略（附原始碼）

跨品種價差套利簡介 套利原理 ​ 通俗地講，就是兩個合約相關性很好，突然市場出了一個bug，破壞了兩個合約之間的平衡狀態，進場套利；等待市場回覆，平倉出場。即均值回覆思想。 價差套利 ​ 價差套利的前提是做出商品期貨品種間同一月份的價格之間的價差，並且畫出價差的時

Ajax跨域、Json跨域、Socket跨域和Canvas跨域等同源策略限制的解決方法

b2c editor spec acache 查詢 方案 fin agent pla 同源是指同樣的協議、域名、port，三者都同樣才屬於同域。不符合上述定義的請求，則稱為跨域。 相信每一個開發者都曾遇到過跨域請求的情況，盡管情況不一樣，但問題的本質都能夠歸為瀏覽器出

【AD】【組策略】跨域轉移組策略&可導入的組策略

組策略 客戶端 文件夾 控制臺 下一步 跨域轉移組策略&可導入的組策略環境：AD PDC 均為: Win2012 R2客戶端：Win7 x64A 域：xifan.comB 域：abc.com需求：將A域的數個組策略，直接導入B域，簡化B域組策略設置操作步驟：打開A域的PDC主機。

Ajax跨域請求 同源策略與Jsonp

就是 pen 針對 api 自己的 發送請求 cdn esp 自己 同源策略（Same origin policy）是一種約定，它是瀏覽器最核心也最基本的安全功能，如果缺少了同源策略，則瀏覽器的正常功能可能都會受到影響。可以說Web是構建在同源策略基礎之上的，瀏覽器只是

MongoShake——基於MongoDB的跨數據中心的數據復制平臺

原理 成功 player 背景 16px and mgo val 一個 摘要： MongoShake是基於MongoDB的通用型平臺服務，作為數據連通的橋梁，打通各個閉環節點的通道。通過MongoShake的訂閱消費，可以靈活對接以適應不同場景，例如日誌訂閱、數據中心同步、

網頁中的跨域請求 同源策略、跨域解決方案

  品習知識點 簡單表述幾個概念，詳解@度娘。 1、同源策略，瀏覽器最核心的安全功能，在無授權情況下，只允許讀寫相同源的資源。其中源（Origin）指的是協議、域名、介面，同源即三者相同。 2、預檢請求，瀏覽器出於安全策略，在跨域請求資料時候預先發起請求，以知是否可跨域請求資料的請求。 關

基於Web開放平臺的應用的開發的一些研究

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

【看論文】之《西紅柿果實目標識別方法研究-基於模糊聚類演算法_王富春》

論文資訊 題目：西紅柿果實目標識別方法研究-基於模糊聚類演算法 論文作者：王富春等 作者單位：柳州職業技術學院 期刊：農機化研究 提交時間：2014-10-20 摘要 為識別成熟的西紅柿目標，提出了一種“模糊C-均值聚類演算法（Fuzzy Clustering Mea

Django之跨域請求同源策略

同源策略： 首先基於安全的原因，瀏覽器是存在同源策略這個機制的，同源策略阻止從一個源載入的文件或指令碼獲取或設定另一個源載入的文件的屬性。 而如果我們要跳過這個策略，也就是說非要跨域請求，那麼就需要通過JSONP或者CORS來實現了。   一個源的定義   如果兩個頁面的協議，

幾何建模相關多目標優化問題研究-基於正交流場的四邊形網格構造方法

基於正交流場的引數化方法 四邊形網格在有限元分析中應用的非常廣泛，它的每個面都是四邊形，絕大多數頂點的度都是4，這樣的頂點成為奇異點。 四邊形網格任何不包括奇異點的單連通區域內都可以與平面直角座標系的一部分建立同胚對映，使得頂點與座標系中橫縱座標都為整數的格點實現一一對應

研究基於spring通過對http請求資料的預處理（資料加解密、校驗、日誌）（2）過攔截器篇

上文已經詳細講解了如何對request進行處理，本文主要是案例演示 spring MVC 的寫法 新增攔截器 定義一個攔截器 public class AppRequestIntercept

策略路由-基於源地址控制實驗

-h fig 修改 match perm racer con 網段 route 實驗要求：R1的S0/0口帶寬設置為6000Kb/s，發現流量都走S0/0口出去，S0/1口閑置要求基於源地址進行路由控制，192.168.2.0網絡的流量走上面S0/0口，192.168.3

策略路由-基於目的地址控制實驗

proc 地址 圖片 process ospf協議 51cto any com ospf 實驗要求：OSPF協議選擇的路由是去往172.16.1.1的流量走S0/1下面鏈路到達，去往172.16.2.1的流量從S0/0口上面鏈路到達；要求基於目的地址進行路由控制，去往目的地

$Django 跨域問題(同源策略) vue專案(axios跨域請求資料)

1 跨域問題 #同源策略 #本站的只能請求本站域名的資料 #CORS實現（跨域資源共享) #實現CORS通訊的關鍵是伺服器。只要伺服器實現了CORS介面，就可以跨源通訊。 #CORS基本流程 #1_CORS請求分成兩類：簡單請求（simple request）和非簡

量化對衝投資基本策略解析：阿爾法對衝策略

根據國內一些公開的量化對衝類公募基金產品的歷史業績表現來看，該策略在國內A股市場的有效性已經得到了極大的實操驗證。另一方面，隨著股市擴容持續保持在較高節奏，中國經濟也步入降速轉型的長週期，未來市場個股因基本面等因素的持續大幅分化，也將是大概率事件。在此背景下，專業的量化對衝投資人，顯然很有必要對

單因子 & 多因子策略（基於JoinQuant）

## step1：匯入所需的庫import pandas as pdfrom pandas import Series, DataFrameimport numpy as npimport statsmodels.api as smimport scipy.stats as scsimport matplo

阿爾法：比特幣演算法交易策略研究，你與賺錢只需一個量化

數字貨幣演算法交易模型和策略並非易事。更糟糕的是，目前的數字貨幣狀態是高度不穩定和迅速變化的。由於美國證券交易委員會和各種政府針對數字貨幣交換的規定，市場已成為戰區。儘管存在所有負面訊息，但許多交易員在日內交易數字貨幣資產方面做得很好。 我是Charles，目前就職於阿爾法數字貨幣量化平臺(m.aicoin