dYdX حکمت عملی ڈیزائن کا مثال

بہت سے صارفین کی مانگ کے جواب میں ، ایف ایم زیڈ پلیٹ فارم نے حال ہی میں ڈی وائی ڈی ایکس تک رسائی حاصل کی ہے ، جو ایک غیر مرکزی تبادلہ ہے۔ کوئی بھی شخص جس کے پاس حکمت عملی ہے وہ ڈیجیٹل کرنسی ڈی وائی ڈی ایکس حاصل کرنے کے عمل سے لطف اندوز ہوسکتا ہے۔ میں صرف ایک طویل عرصے سے اسٹوکاسٹک تجارتی حکمت عملی لکھنا چاہتا تھا ، اس سے کوئی فرق نہیں پڑتا ہے کہ آیا اس سے منافع ہوتا ہے۔ لہذا اگلا ہم اسٹوکاسٹک ایکسچینج حکمت عملی ڈیزائن کرنے کے لئے مل کر آتے ہیں ، اس سے کوئی فرق نہیں پڑتا ہے کہ حکمت عملی اچھی کارکردگی کا مظاہرہ کرتی ہے یا نہیں ، ہم صرف حکمت عملی ڈیزائن سیکھتے ہیں۔

اسٹوکاسٹک ٹریڈنگ حکمت عملی کا ڈیزائن

آئیے ایک دماغ کی بارش کریں! یہ بے ترتیب اشارے اور قیمتوں کے ساتھ بے ترتیب طور پر آرڈر دینے کی حکمت عملی تیار کرنے کا ارادہ رکھتا ہے۔ آرڈر دینے کا مطلب صرف طویل یا مختصر جانا ہے ، صرف امکان پر شرط لگانا ہے۔ پھر ہم 1 ~ 100 کی بے ترتیب تعداد کا استعمال کریں گے تاکہ یہ طے کیا جاسکے کہ طویل یا مختصر جانا ہے۔

طویل عرصے تک جانے کے لئے شرط: 1 ~ 50 کی بے ترتیب تعداد. شارٹ جانے کی شرط: 51~100 کی بے ترتیب تعداد۔

اس طرح طویل اور مختصر دونوں 50 نمبر ہیں۔ اگلا ، آئیے اس بارے میں سوچیں کہ پوزیشن کو کیسے بند کیا جائے ، چونکہ یہ ایک شرط ہے ، اس کے بعد جیت یا نقصان کے لئے ایک معیار ہونا ضروری ہے۔ ہم ٹرانزیکشن میں فکسڈ اسٹاپ منافع اور نقصان کے لئے ایک معیار طے کرتے ہیں۔ جیت کے لئے منافع کو روکیں ، کھونے کے لئے نقصان کو روکیں۔ اسٹاپ منافع اور نقصان کی رقم کے بارے میں ، یہ اصل میں منافع اور نقصان کے تناسب کا اثر ہے ، اوہ ہاں! یہ جیت کی شرح کو بھی متاثر کرتا ہے! (کیا یہ حکمت عملی ڈیزائن موثر ہے؟ کیا اسے مثبت ریاضی کی توقعات کے طور پر ضمانت دی جاسکتی ہے؟ پہلے کریں! (اس کے بعد ، یہ صرف سیکھنے ، تحقیق کے لئے ہے!)

ٹریڈنگ لاگت سے پاک نہیں ہے، ہمارے اسٹوکاسٹک ٹریڈنگ جیت کی شرح کو 50 فیصد سے کم کی طرف کھینچنے کے لئے کافی سلائپج، فیس وغیرہ موجود ہیں۔ تو اسے مستقل طور پر کیسے ڈیزائن کیا جائے؟ پوزیشن کو بڑھانے کے لئے ایک ضارب ڈیزائن کرنے کے بارے میں کیا خیال ہے؟ چونکہ یہ ایک شرط ہے ، لہذا بے ترتیب تجارتوں کی ایک قطار میں 8 ~ 10 بار ہارنے کا امکان کم ہونا چاہئے۔ لہذا پہلا لین دین کم سے کم مقدار میں آرڈر دینے کے لئے ڈیزائن کیا گیا تھا ، جتنا ممکن ہو سکے کم سے کم۔ پھر اگر میں ہار جاتا ہوں تو ، میں آرڈر کی مقدار میں اضافہ کروں گا اور بے ترتیب طور پر آرڈر دینا جاری رکھوں گا۔

ٹھیک ہے، حکمت عملی سادہ ڈیزائن کیا گیا ہے.

ماخذ کوڈ ڈیزائن کیا گیا:

var openPrice = 0 
var ratio = 1
var totalEq = null 
var nowEq = null 

function cancelAll() {
    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, orders[i])
            Sleep(500)
        }
        Sleep(500)
    }
}

function main() {
    if (isReset) {
        _G(null)
        LogReset(1)
        LogProfitReset()
        LogVacuum()
        Log("reset all data", "#FF0000")
    }

    exchange.SetContractType(ct)

    var initPos = _C(exchange.GetPosition)
    if (initPos.length != 0) {
        throw "Strategy starts with a position!"
    }
    
    exchange.SetPrecision(pricePrecision, amountPrecision)
    Log("set the pricePrecision", pricePrecision, amountPrecision)
    
    if (!IsVirtual()) {
        var recoverTotalEq = _G("totalEq")
        if (!recoverTotalEq) {
            var currTotalEq = _C(exchange.GetAccount).Balance   // equity
            if (currTotalEq) {
                totalEq = currTotalEq
                _G("totalEq", currTotalEq)
            } else {
                throw "failed to obtain initial interest"
            }
        } else {
            totalEq = recoverTotalEq
        }
    } else {
        totalEq = _C(exchange.GetAccount).Balance
    }
    
    while (1) {
        if (openPrice == 0) {
            // Update account information and calculate profits
            var nowAcc = _C(exchange.GetAccount)
            nowEq = IsVirtual() ? nowAcc.Balance : nowAcc.Balance  // equity
            LogProfit(nowEq - totalEq, nowAcc)
            
            var direction = Math.floor((Math.random()*100)+1)   // 1~50 , 51~100
            var depth = _C(exchange.GetDepth)
            if (depth.Asks.length <= 2 || depth.Bids.length <= 2) {
                Sleep(1000)
                continue 
            }
            if (direction > 50) {
                // long
                openPrice = depth.Bids[1].Price
                exchange.SetDirection("buy")
                exchange.Buy(Math.abs(openPrice) + slidePrice, amount * ratio)
            } else {
                // short
                openPrice = -depth.Asks[1].Price
                exchange.SetDirection("sell")
                exchange.Sell(Math.abs(openPrice) - slidePrice, amount * ratio)
            }       
            Log("place", direction > 50 ? "buying order" : "selling order", ", price:", Math.abs(openPrice))
            continue
        }

        var orders = _C(exchange.GetOrders)
        if (orders.length == 0) {
            var pos = _C(exchange.GetPosition)
            if (pos.length == 0) {
                openPrice = 0
                continue
            }
            
            // Test for closing the position
            while (1) {
                var depth = _C(exchange.GetDepth)
                if (depth.Asks.length <= 2 || depth.Bids.length <= 2) {
                    Sleep(1000)
                    continue 
                }
                var stopLossPrice = openPrice > 0 ? Math.abs(openPrice) - stopLoss : Math.abs(openPrice) + stopLoss 
                var stopProfitPrice = openPrice > 0 ? Math.abs(openPrice) + stopProfit : Math.abs(openPrice) - stopProfit
                var winOrLoss = 0 // 1 win , -1 loss 
                
                // drawing the line
                $.PlotLine("bid", depth.Bids[0].Price)
                $.PlotLine("ask", depth.Asks[0].Price)
                
                // stop loss
                if (openPrice > 0 && depth.Bids[0].Price < stopLossPrice) {
                    exchange.SetDirection("closebuy")
                    exchange.Sell(depth.Bids[0].Price - slidePrice, pos[0].Amount)
                    winOrLoss = -1
                } else if (openPrice < 0 && depth.Asks[0].Price > stopLossPrice) {
                    exchange.SetDirection("closesell")
                    exchange.Buy(depth.Asks[0].Price + slidePrice, pos[0].Amount)
                    winOrLoss = -1
                }
                
                // stop profit
                if (openPrice > 0 && depth.Bids[0].Price > stopProfitPrice) {
                    exchange.SetDirection("closebuy")
                    exchange.Sell(depth.Bids[0].Price - slidePrice, pos[0].Amount)  
                    winOrLoss = 1
                } else if (openPrice < 0 && depth.Asks[0].Price < stopProfitPrice) {
                    exchange.SetDirection("closesell")
                    exchange.Buy(depth.Asks[0].Price + slidePrice, pos[0].Amount)
                    winOrLoss = 1
                }
                
                // Test the pending orders
                Sleep(2000)
                var orders = _C(exchange.GetOrders)                
                if (orders.length == 0) {
                    pos = _C(exchange.GetPosition)
                    if (pos.length == 0) {
                        if (winOrLoss == -1) {
                            ratio++
                        } else if (winOrLoss == 1) {
                            ratio = 1
                        }
                        break
                    }                    
                } else {
                    // cancel pending orders
                    cancelAll()
                    Sleep(2000)
                    pos = _C(exchange.GetPosition)
                    // update the position after cancellation, and check it again
                    if (pos.length == 0) {
                        if (winOrLoss == -1) {
                            ratio++
                        } else if (winOrLoss == 1) {
                            ratio = 1
                        }
                        break
                    }    
                }
                
                var tbl = {
                    "type" : "table", 
                    "title" : "info", 
                    "cols" : ["totalEq", "nowEq", "openPrice", "bid1Price", "ask1Price", "ratio", "pos.length"], 
                    "rows" : [], 
                }
                tbl.rows.push([totalEq, nowEq, Math.abs(openPrice), depth.Bids[0].Price, depth.Asks[0].Price, ratio, pos.length])
                tbl.rows.push(["pos", "type", "amount", "price", "--", "--", "--"])
                for (var j = 0 ; j < pos.length ; j++) {
                    tbl.rows.push([j, pos[j].Type, pos[j].Amount, pos[j].Price, "--", "--", "--"])
                }
                LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
            }
        } else {
            // cancel the pending orders
            // reset openPrice
            cancelAll()
            openPrice = 0
        }
        Sleep(1000)
    }
}

حکمت عملی کے پیرامیٹرز:

اوہ ہاں! اس حکمت عملی کو ایک نام کی ضرورت ہے، چلو اسے کہتے ہیں اندازہ لگائیں سائز (dYdX ورژن) .

بیک ٹیسٹ

بیک ٹیسٹنگ صرف حوالہ کے لئے ہے، >_

بیک ٹیسٹ ختم ہو گیا ہے، کوئی بگ نہیں ہے.

یہ حکمت عملی صرف سیکھنے اور حوالہ کے لئے استعمال کیا جاتا ہے، حقیقی بوٹ میں اس کا استعمال نہیں کرتے!