आइसबर्ग आयोग की रणनीति

आइसबर्ग आयोग की रणनीतिwww.fmz.comआइसबर्ग कमीशन निवेशक के बड़े पैमाने पर लेन-देन को संदर्भित करता है, ताकि बाजार पर अत्यधिक प्रभाव से बचा जा सके, बड़े एकल कमीशन को स्वचालित रूप से एक बड़े आदेश को कई छोटे आदेशों में विभाजित किया जाता है, वर्तमान नवीनतम खरीद / बिक्री मूल्य और ग्राहक सेटिंग मूल्य के अनुसार। रणनीति स्वचालित रूप से छोटे आदेश के प्रत्यायोजन को निष्पादित करती है, और स्वचालित रूप से आदेशों को फिर से रखती है जब पिछले आदेश को पूरी तरह से बेचा जाता है या नवीनतम मूल्य वर्तमान प्लेसिंग मूल्य से महत्वपूर्ण रूप से विचलित होता है।

उदाहरण: यदि एकल-औसत फ्लोटिंग पॉइंट 10 पर सेट किया गया है तोः

प्रत्येक प्लेसमेंट की संख्या एकल प्लेसमेंट के औसत मूल्य का 90%~110% है, और प्लेसमेंट की कीमत नवीनतम खरीद मूल्य है, हम कहते हैं 1 बार (माइनस 1 प्रतिनियुक्ति गहराई), और अंतिम प्लेसमेंट पूरा होने के बाद एक नई प्लेसमेंट की जाती है। स्वचालित रूप से आदेश वापस ले लो और पुनः प्लेसमेंट जब नवीनतम लेनदेन की कीमत प्लेसमेंट गहराई से अधिक है *2.

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

function CancelPendingOrders() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            return;
        }

        for (var j = 0; j < orders.length; j++) {
            exchange.CancelOrder(orders[j].Id);
            if (j < (orders.length-1)) {
                Sleep(Interval);
            }
        }
    }
}

var LastBuyPrice = 0;
var InitAccount = null;

function dispatch() {
    var account = null;
    var ticker = _C(exchange.GetTicker);
    if (LastBuyPrice > 0) {
        if (_C(exchange.GetOrders).length > 0) {
            if (ticker.Last > LastBuyPrice && ((ticker.Last - LastBuyPrice) / LastBuyPrice) > (2*(EntrustDepth/100))) {
                Log('deviate to much, newest last price:', ticker.Last, 'order buy price', LastBuyPrice);
                CancelPendingOrders();
            } else {
                return true;
            }
        } else {
            account = _C(exchange.GetAccount);
            Log("order finised, total cost:", _N(InitAccount.Balance - account.Balance), "avg buy price:", _N((InitAccount.Balance - account.Balance) / (account.Stocks - InitAccount.Stocks)));
        }
        LastBuyPrice = 0;
    }
    
    var BuyPrice = _N(ticker.Buy * (1 - EntrustDepth/100),PricePerision);
    if (BuyPrice > MaxBuyPrice) {
        return true;
    }
    
    if (!account) {
        account = _C(exchange.GetAccount);
    }


    if ((InitAccount.Balance - account.Balance) >= TotalBuyNet) {
        return false;
    }
    
    var RandomAvgBuyOnce = (AvgBuyOnce * ((100 - FloatPoint) / 100)) + (((FloatPoint * 2) / 100) * AvgBuyOnce * Math.random());
    var UsedMoney = Math.min(account.Balance, RandomAvgBuyOnce, TotalBuyNet - (InitAccount.Balance - account.Balance));
    
    var BuyAmount = _N(UsedMoney / BuyPrice, 3);
    if (BuyAmount < MinStock) {
        return false;
    }
    LastBuyPrice = BuyPrice;
    exchange.Buy(BuyPrice, BuyAmount, 'Cost: ', _N(UsedMoney), 'last price', ticker.Last);
    return true;
}

function main() {
    CancelPendingOrders();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    if (InitAccount.Balance < TotalBuyNet) {
        throw "balance not enough";
    }
    LoopInterval = Math.max(LoopInterval, 1);
    while (dispatch()) {
        Sleep(LoopInterval * 1000);
    }
    Log("All Done", _C(exchange.GetAccount));
}