آربٹریج پر مبنی موافقت پذیر کریپٹوکرنسی گرڈ ٹریڈنگ حکمت عملی

مصنف:چاؤ ژانگ، تاریخ: 2024-01-19 14:17:50
ٹیگز:

img

جائزہ

یہ ایک انکولی کریپٹوکرنسی گرڈ ٹریڈنگ حکمت عملی ہے جو اعتدال پسندی کے لئے گرڈ ٹریڈنگ کے طریقہ کار پر مبنی ہے۔ یہ مارکیٹ میں اتار چڑھاؤ کی بنیاد پر گرڈ ٹریڈنگ کی قیمت کی حد کو خود بخود ایڈجسٹ کرسکتا ہے اور اس قیمت کی حد کے اندر موثر اعتدال پسندی کی تجارت کرسکتا ہے۔

حکمت عملی کا اصول

اس حکمت عملی کا بنیادی خیال یہ ہے:

  1. تاریخی اعلی اور کم قیمتوں کی بنیاد پر متحرک طور پر ٹریڈنگ گرڈ کی قیمت کی حد کا حساب لگائیں۔

  2. اس قیمت کی حد کے اندر اندر برابر وقفوں پر N گرڈ لائنز مقرر کریں.

  3. جب قیمت ہر گرڈ لائن کو توڑتی ہے تو، ایک مقررہ مقدار کے ساتھ طویل یا مختصر پوزیشن کھولیں.

  4. ملحقہ گرڈ لائنوں اور منافع کے لئے بند پوزیشنوں کے درمیان ثالثی.

  5. جب قیمت دوبارہ گرڈ رینج میں داخل ہو جائے تو، گرڈ لائنز کی مارجن لاگت پر پوزیشن کھولنا جاری رکھیں۔

  6. گرڈ قیمت کی حد کے اندر ہائی فریکوئینسی آربراج ٹریڈنگ کے لئے اس سائیکل کو دہرائیں۔

خاص طور پر، حکمت عملی سب سے پہلے ریئل ٹائم میں گرڈ کی اوپری اور نچلی حدود کا حساب لگاتی ہے جس میں ترتیب شدہ لوک بیک ونڈو (i_boundLookback) اور اتار چڑھاؤ کی حد (i_boundDev) پیرامیٹرز کے مطابق.

پھر N گرڈ لائنز (i_gridQty) کو بالائی اور نچلی حدود کے درمیان یکساں طور پر تقسیم کیا جاتا ہے۔ ان گرڈ لائنز کی قیمتیں گرڈ لائن آر آر صف میں محفوظ کی جاتی ہیں۔

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

جب قیمت ایک بار پھر ملحقہ گرڈ لائن کو توڑتی ہے، تو اسے سابقہ آربیٹریج کے احکامات اور منافع کے لئے بند پوزیشنوں کے ساتھ مماثل کیا جا سکتا ہے.

قیمتوں میں اتار چڑھاؤ کی حد کے اندر اعلی تعدد کے لئے اس سائیکل کو دہرائیں۔

فوائد کا تجزیہ

روایتی نیٹ ورک کی حکمت عملیوں کے مقابلے میں اس حکمت عملی کا سب سے بڑا فائدہ یہ ہے کہ نیٹ ورک کی حد خود بخود مارکیٹ کے اتار چڑھاو کے مطابق ایڈجسٹ ہوتی ہے ، جس کی خصوصیات مندرجہ ذیل ہیں:

  1. مکمل طور پر خودکار، دستی مداخلت کی ضرورت نہیں.

  2. قیمتوں کے رجحانات کو پکڑنے اور رجحان کی سمت میں تجارت کرنے کے قابل.

  3. قابو پانے والے خطرات، یکطرفہ پیچھا کرنے والے خطرات سے بچنے کے.

  4. اعلی تجارتی تعدد اور منافع کا مارجن.

  5. سمجھنے میں آسان، سادہ ترتیب.

  6. اعلی سرمایہ استعمال، آسانی سے پھنس نہیں.

  7. ریئل ٹائم میں مارکیٹ کی تبدیلیوں کی عکاسی کرتا ہے، جو الگورتھم ٹریڈنگ کے لئے موزوں ہے۔

خطرے کا تجزیہ

اگرچہ اس حکمت عملی کے بہت سے فوائد ہیں ، لیکن کچھ خطرات بھی ہیں ، جو بنیادی طور پر مندرجہ ذیل میں مرکوز ہیں:

  1. انتہائی قیمتوں میں اتار چڑھاؤ میں بڑے نقصانات کا امکان۔

  2. منافع حاصل کرنے کے لئے مناسب ہولڈنگ مدت اور ٹریڈنگ جوڑی کی ضرورت ہوتی ہے۔

  3. دارالحکومت کا پیمانہ اتار چڑھاؤ کی حد سے ملنا چاہئے.

  4. پیرامیٹرز کی کثرت سے نگرانی اور اصلاح کی ضرورت ہوسکتی ہے۔

انسداد اقدامات میں شامل ہیں:

  1. گرڈ رینج کو بڑھانے کے لیے گرڈ اسپیسنگ میں اضافہ کریں۔

  2. زیادہ مستحکم ٹریڈنگ کے جوڑے کا انتخاب کریں.

  3. کافی لیکویڈیٹی کے لئے سرمایہ پیمانے کو ایڈجسٹ کریں.

  4. خودکار مانیٹرنگ اور الرٹ میکانزم قائم کریں۔

اصلاح کی ہدایات

حکمت عملی کو مندرجہ ذیل پہلوؤں میں بہتر بنایا جاسکتا ہے:

  1. متحرک گرڈ: خود کار طریقے سے اتار چڑھاؤ کی بنیاد پر گرڈ پیرامیٹرز کو ایڈجسٹ کریں.

  2. سٹاپ نقصان کا طریقہ کار: انتہائی خطرات کو محدود کرنے کے لئے معقول سٹاپ نقصان کے مقامات مقرر کریں.

  3. مرکب گرڈ: وقت کے استعمال کو زیادہ سے زیادہ کرنے کے لئے مختلف ادوار کے لئے مختلف پیرامیٹرز کا استعمال کرتے ہوئے گرڈ کو یکجا کریں.

  4. مشین لرننگ: قوانین کے بجائے پیرامیٹرز کو خود بخود بہتر بنانے کے لئے اعصابی نیٹ ورک استعمال کریں.

  5. کراس مارکیٹ آربیٹریج: تبادلے یا کرنسی کے جوڑوں کے درمیان ثالثی.

خلاصہ

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


/*backtest
start: 2024-01-11 00:00:00
end: 2024-01-18 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("(IK) Grid Script", overlay=true, pyramiding=14, close_entries_rule="ANY", default_qty_type=strategy.cash, initial_capital=100.0, currency="USD", commission_type=strategy.commission.percent, commission_value=0.1)
i_autoBounds    = input(group="Grid Bounds", title="Use Auto Bounds?", defval=true, type=input.bool)                             // calculate upper and lower bound of the grid automatically? This will theorhetically be less profitable, but will certainly require less attention
i_boundSrc      = input(group="Grid Bounds", title="(Auto) Bound Source", defval="Hi & Low", options=["Hi & Low", "Average"])     // should bounds of the auto grid be calculated from recent High & Low, or from a Simple Moving Average
i_boundLookback = input(group="Grid Bounds", title="(Auto) Bound Lookback", defval=250, type=input.integer, maxval=500, minval=0) // when calculating auto grid bounds, how far back should we look for a High & Low, or what should the length be of our sma
i_boundDev      = input(group="Grid Bounds", title="(Auto) Bound Deviation", defval=0.10, type=input.float, maxval=1, minval=-1)  // if sourcing auto bounds from High & Low, this percentage will (positive) widen or (negative) narrow the bound limits. If sourcing from Average, this is the deviation (up and down) from the sma, and CANNOT be negative.
i_upperBound    = input(group="Grid Bounds", title="(Manual) Upper Boundry", defval=0.285, type=input.float)                      // for manual grid bounds only. The upperbound price of your grid
i_lowerBound    = input(group="Grid Bounds", title="(Manual) Lower Boundry", defval=0.225, type=input.float)                      // for manual grid bounds only. The lowerbound price of your grid.
i_gridQty       = input(group="Grid Lines",  title="Grid Line Quantity", defval=8, maxval=15, minval=3, type=input.integer)       // how many grid lines are in your grid

f_getGridBounds(_bs, _bl, _bd, _up) =>
    if _bs == "Hi & Low"
        _up ? highest(close, _bl) * (1 + _bd) : lowest(close, _bl)  * (1 - _bd)
    else
        avg = sma(close, _bl)
        _up ? avg * (1 + _bd) : avg * (1 - _bd)

f_buildGrid(_lb, _gw, _gq) =>
    gridArr = array.new_float(0)
    for i=0 to _gq-1
        array.push(gridArr, _lb+(_gw*i))
    gridArr

f_getNearGridLines(_gridArr, _price) =>
    arr = array.new_int(3)
    for i = 0 to array.size(_gridArr)-1
        if array.get(_gridArr, i) > _price
            array.set(arr, 0, i == array.size(_gridArr)-1 ? i : i+1)
            array.set(arr, 1, i == 0 ? i : i-1)
            break
    arr

var upperBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true) : i_upperBound  // upperbound of our grid
var lowerBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false) : i_lowerBound // lowerbound of our grid
var gridWidth       = (upperBound - lowerBound)/(i_gridQty-1)                                                       // space between lines in our grid
var gridLineArr     = f_buildGrid(lowerBound, gridWidth, i_gridQty)                                                 // an array of prices that correspond to our grid lines
var orderArr        = array.new_bool(i_gridQty, false)                                                              // a boolean array that indicates if there is an open order corresponding to each grid line

var closeLineArr    = f_getNearGridLines(gridLineArr, close)                                                        // for plotting purposes - an array of 2 indices that correspond to grid lines near price
var nearTopGridLine = array.get(closeLineArr, 0)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line above current price
var nearBotGridLine = array.get(closeLineArr, 1)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line below current price
strategy.initial_capital = 50000
for i = 0 to (array.size(gridLineArr) - 1)
    if close < array.get(gridLineArr, i) and not array.get(orderArr, i) and i < (array.size(gridLineArr) - 1)
        buyId = i
        array.set(orderArr, buyId, true)
        strategy.entry(id=tostring(buyId), long=true, qty=(strategy.initial_capital/(i_gridQty-1))/close, comment="#"+tostring(buyId))
    if close > array.get(gridLineArr, i) and i != 0
        if array.get(orderArr, i-1)
            sellId = i-1
            array.set(orderArr, sellId, false)
            strategy.close(id=tostring(sellId), comment="#"+tostring(sellId))

if i_autoBounds
    upperBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true)
    lowerBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false)
    gridWidth   := (upperBound - lowerBound)/(i_gridQty-1)
    gridLineArr := f_buildGrid(lowerBound, gridWidth, i_gridQty)

closeLineArr    := f_getNearGridLines(gridLineArr, close)
nearTopGridLine := array.get(closeLineArr, 0)
nearBotGridLine := array.get(closeLineArr, 1)





مزید