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

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

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

سب سے پہلے کان کنی کا اشتراک کریں

مضمون میں حکمت عملی کی کان کنی اسکرین شاٹ.

خوش آمدید دوستوں جو اشتراک کرنے کے لئے اچھے کان کنی کی حکمت عملی کے خیالات ہیں!

بے ترتیب تجارتی حکمت عملی ڈیزائن

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

لمبا کرنے کی شرط: 1 سے 50 تک کی بے ترتیب تعداد۔ مختصر کرنے کی شرط: 51 سے 100 تک کی بے ترتیب تعداد

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

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

ٹھیک ہے، حکمت عملی ٹھیک ہے۔

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

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 "Position detected when starting the strategy!"
    }
    
    exchange.SetPrecision(pricePrecision, amountPrecision)
    Log("setPrecision", 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 "fail to obtain the initial equity"
            }
        } else {
            totalEq = recoverTotalEq
        }
    } else {
        totalEq = _C(exchange.GetAccount).Balance
    }
    
    while (1) {
        if (openPrice == 0) {
            // update account information, and calculate the profit
            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 ? "buy order" : "sell 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
            }
            
            // detect close positions 
            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 
                
                // plot 
                $.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
                }
                
                // detect 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)
                    // after canceling, update positions, which needs to be detected 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 pending orders 
            // reset openPrice
            cancelAll()
            openPrice = 0
        }
        Sleep(1000)
    }
}

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

ٹھیک ہے! حکمت عملی کا ایک نام کی ضرورت ہے، اور اس کا نام چلو "گھٹ جو بڑا ہے (dYdX ورژن).

بیک ٹیسٹ

backtest صرف ریفرنس کے لئے ہے! یہ بنیادی طور پر اس بات کی جانچ پڑتال کرنے کے لئے ہے کہ آیا حکمت عملی میں کوئی کیڑے ہیں؛ بائننس فیوچر کے ساتھ بیک ٹیسٹ.

بیک ٹیسٹ ختم ہو گیا ہے، کوئی کیڑے نہیں، لیکن مجھے لگتا ہے کہ بیک ٹیسٹ کا نظام مماثل تھا...

ایک بوٹ میں چلائیں

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