ہائی فریکوئنسی ٹریڈنگ حکمت عملی تجزیہ - پینی جمپ

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

پینی جمپ حکمت عملی کو سمجھنا

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

مثال کے طور پر ، فرض کریں کہ اسٹاک مارکیٹ کی اصل گہرائی اس طرح کی تھی: 200 ∙ $1.01 x $1.03 ∙ 200. پھر ایک ہاتھی داخل ہوتا ہے اور ہر ایک $1.01 پر 3000 حصص خریدنے کا آرڈر دیتا ہے۔ اس وقت ، مارکیٹ کی گہرائی 3200 ∙ $1.01 x $1.03 ∙ 200 میں بدل جائے گی۔ یہ عمل ایک ہاتھی متعارف کرانے کی طرح ہے ، جو مارکیٹ میں دوسرے شرکاء کی توجہ کا مرکز بن جاتا ہے۔

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

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

• مارکیٹ میں دھوکہ دہی حقیقت میں ، بڑے ادارہ جاتی سرمایہ کار عام طور پر مارکیٹ میں بڑی تعداد میں خرید و فروخت کے احکامات کو کھل کر نہیں دیتے ہیں ، کیونکہ اس طرح کے رویے سے مارکیٹ کے دوسرے شرکاء کو جوابی اقدامات کرنے یا یہاں تک کہ مارکیٹ میں ہیرا پھیری کرنے کا باعث بن سکتا ہے۔ لہذا ، وہ فریب پیدا کرنے ، اعلی تعدد کے تاجروں کو میدان میں راغب کرنے ، اور پھر قیمتوں میں اتار چڑھاؤ سے فائدہ اٹھانے کے لئے تیزی سے فروخت یا خریدنے کی حکمت عملی اپناتے ہیں۔

پینی جمپ حکمت عملی کا بنیادی خیال

پینی جمپ حکمت عملی کا بنیادی خیال یہ ہے کہ ایک بار جب بڑا کھلاڑی مارکیٹ میں ظاہر ہوتا ہے اور ایک مخصوص قیمت (جیسے $ 1.01) کی حمایت کرتا ہے تو ، اعلی تعدد کے تاجر تیزی سے اپنی بولی کو ایک سینٹ ، مثال کے طور پر ، $ 1.02 تک بڑھا دیں گے۔ اس کی وجہ یہ ہے کہ اعلی تعدد کے تاجر سمجھتے ہیں کہ اس قیمت کی سطح پر ایک بڑے کھلاڑی کی ظاہری شکل کا مطلب ہے کہ اس کی مضبوط خریداری کی حمایت ہے ، لہذا وہ قیمت میں اضافے کی امید میں قریب سے پیروی کرنے کی کوشش کرتے ہیں۔ جب قیمت واقعی میں $ 1.03 x $ 1.05 تک بڑھتی ہے تو ، اعلی تعدد کے تاجر تیزی سے فروخت کرسکتے ہیں اور $ 0.01 کا منافع حاصل کرسکتے ہیں۔

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

پیسہ چھلانگ حکمت عملی کوڈ کا تجزیہ

حکمت عملی کا ماخذ کوڈ:https://www.fmz.com/strategy/358

مندرجہ بالا فراہم کردہ حکمت عملی کا کوڈ ایک مثال ہے ، جو پینی جمپ حکمت عملی کو نافذ کرنے کے لئے استعمال ہوتا ہے۔ ذیل میں کوڈ کی تفصیلی وضاحت ہے ، جس سے ابتدائی افراد کو یہ سمجھنے میں مدد ملتی ہے کہ یہ کیسے کام کرتا ہے:

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

// Variables
var InitAccount = null;

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

function updateStatus(msg) {
    LogStatus("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", Counter.f, "\n"+msg+"#0000ff\n"+new Date());
}

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("Successful payment: " + opAmount +", Start taking action...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("Didn't get it, start to stop loss, currently buying one: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

میں آپ کی فراہم کردہ حکمت عملی کوڈ لائن کی طرف سے لائن تجزیہ کریں گے آپ کو اس کے آپریشن میں تفصیل سے سمجھنے میں مدد کرنے کے لئے.

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

یہ کوڈ کاؤنٹر نامی ایک شے کو شروع کرتا ہے ، جس کا استعمال کسی حکمت عملی کی تجارتی شماریاتی معلومات کو ٹریک کرنے کے لئے کیا جاتا ہے۔ خاص طور پر اس میں تین خصوصیات شامل ہیں:

• i: ٹرانزیکشنز کی کل تعداد کی نمائندگی کرتا ہے۔
• w: کامیاب لین دین کی تعداد کی نمائندگی کرتا ہے۔
• f: ناکام ٹرانزیکشنز کی تعداد کی نمائندگی کرتا ہے۔

یہ صفات حکمت عملی کے نفاذ کے عمل کے دوران ریکارڈ اور اپ ڈیٹ کی جائیں گی۔

var InitAccount = null;

کوڈ کی یہ لائن InitAccount نامی متغیر کو شروع کرتی ہے ، جو حکمت عملی کے عمل کو شروع کرنے پر اکاؤنٹ کی معلومات کو اسٹور کرے گی۔

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

یہ ایک فنکشن ہے جس کا نامCancelAll()، اس کا مقصد مارکیٹ میں تمام ناقابل عمل احکامات کو منسوخ کرنا ہے۔ آئیے اس کے افعال کو قدم بہ قدم بیان کرتے ہیں:

• while (true): یہ ایک لامحدود لوپ ہے، یہ چلتا رہے گا جب تک کوئی نامکمل احکامات نہیں ہیں.
• var orders = _C(exchange.GetOrders): یہ کوڈ لائن تبادلہ.GetOrders فنکشن کا استعمال کرتا ہے موجودہ اکاؤنٹ میں تمام زیر التواء احکامات کو حاصل کرنے اور احکامات متغیر میں ان کو ذخیرہ کرنے کے لئے.
• if (orders.length == 0): یہ کوڈ لائن کسی بھی نامکمل احکامات کی جانچ پڑتال کرتی ہے۔ اگر آرڈر صف کی لمبائی 0 ہے تو اس کا مطلب ہے کہ کوئی نامکمل احکامات نہیں ہیں اور لوپ میں خلل پڑے گا۔
• for (var i = 0; i < orders.length; i++): یہ ایک for لوپ ہے جو تمام نامکمل احکامات کے ذریعے تکرار کرتا ہے۔
• exchange.CancelOrder(orders[i].Id): یہ کوڈ لائن ہر آرڈر کو اس کے آئی ڈی کے ذریعہ منسوخ کرنے کے لئے exchange.CancelOrder() فنکشن کا استعمال کرتی ہے۔
• Sleep(Interval): یہ کوڈ لائن ایک انتظار کی مدت متعارف کراتا ہے، ایک مخصوص وقت کے لئے روکتا ہے (ملسی سیکنڈ میں) ، اس بات کو یقینی بنانے کے لئے کہ منسوخی کے احکامات کا آپریشن بہت کثرت سے نہیں ہے.

یہ کوڈ لائن ایک انتظار کی مدت متعارف کراتا ہے، ایک مخصوص وقت کے لئے روکنے کے لئے (ملسی سیکنڈ میں) ، اس بات کو یقینی بنانے کے لئے کہ منسوخی کے احکامات کا آپریشن بہت کثرت سے نہیں ہے.

function updateStatus(msg) {
    LogStatus("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", Counter.f, "\n" + msg + "#0000ff\n" + new Date());
}

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

کا استعمال کرتے ہوئےLogStatus()حکمت عملی کے عمل کے دوران اسٹیٹس بار میں دکھائی جانے والی معلومات کو ریکارڈ کرنے کی تقریب۔ یہ تجارت کی گنتی ، کامیاب گنتی اور ناکامی کی گنتی کے بارے میں متن دکھاتا ہے۔ کےmsgپیرامیٹر شامل ہے، جس میں مارکیٹ کی موجودہ حالت کے بارے میں معلومات شامل ہیں. موجودہ ٹائم اسٹیمپ (new Date()) وقت کی معلومات ظاہر کرنے کے لئے منسلک کیا جاتا ہے. اس فنکشن کا مقصد حکمت عملی کے نفاذ کے دوران نگرانی اور تجزیہ کے لئے ٹرانزیکشن کی حیثیت کی معلومات کو ریکارڈ کرنا اور اپ ڈیٹ کرنا ہے۔

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("Successful payment: " + opAmount +", Start taking action...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("Didn't get it, start to stop loss, currently buying one: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

یہ بنیادی عملدرآمد کی تقریب ہےmain()اسٹریٹیجی کے بنیادی منطق پر مشتمل ہے۔ آئیے اس کے آپریشن لائن فی لائن کی وضاحت کرتے ہیں:

• if (DisableLog): کوڈ کی یہ لائن چیک کرتی ہے کہ آیا DisableLog متغیر درست ہے ، اور اگر ایسا ہے تو ، یہ لاگ ریکارڈنگ کو غیر فعال کردے گا۔ اس بات کو یقینی بنانا ہے کہ غیر ضروری لاگ اسٹریٹجی کے ذریعہ ریکارڈ نہیں کیے جاتے ہیں۔

• CancelAll(): اس بات کو یقینی بنانے کے لئے کہ کوئی نامکمل آرڈر نہیں ہیں اس سے پہلے وضاحت کی گئی منسوخ کریںAll() فنکشن کو کال کریں.

• InitAccount = _C(exchange.GetAccount): یہ کوڈ لائن کرنٹ اکاؤنٹ کی معلومات حاصل کرتی ہے اور اسے InitAccount متغیر میں اسٹور کرتی ہے۔ اس کا استعمال حکمت عملی کے عمل کو شروع کرنے پر اکاؤنٹ کی حیثیت کو ریکارڈ کرنے کے لئے کیا جائے گا۔

• var i = 0;اورvar locks = 0;: دو متغیرات، i اور تالے، جو بعد کی حکمت عملی منطق میں استعمال کیا جائے گا شروع.

• while (true): یہ ایک لامحدود لوپ ہے، بنیادی طور پر حکمت عملی کے مسلسل عملدرآمد کے لئے استعمال کیا جاتا ہے.

اگلا، ہم میں اہم حکمت عملی منطق کی وضاحت کریں گےwhile (true)لائن کی طرف سے لائن لوپ.

while (true) {
    Sleep(Interval);
    var depth = _C(exchange.GetDepth);
    if (depth.Asks.length === 0 || depth.Bids.length === 0) {
        continue;
    }
    updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);

• Sleep(Interval): یہ کوڈ لائن حکمت عملی کو وقت کی ایک مدت کے لئے سوتے رہنے کی اجازت دیتی ہے ، تاکہ حکمت عملی کی کارکردگی کی تعدد کو کنٹرول کیا جاسکے۔ وقفہ پیرامیٹر سوتے وقفے (ملسی سیکنڈ میں) کی وضاحت کرتا ہے۔

• var depth = _C(exchange.GetDepth): موجودہ مارکیٹ کی گہرائی کی معلومات حاصل کریں ، بشمول فروخت کے احکامات اور خریداری کے احکامات کی قیمتیں اور مقدار۔ یہ معلومات گہرائی متغیر میں محفوظ کی جائیں گی۔

• if (depth.Asks.length === 0 || depth.Bids.length === 0): یہ کوڈ لائن مارکیٹ کی گہرائی کی معلومات کی جانچ پڑتال کرتی ہے ، اس بات کو یقینی بناتی ہے کہ فروخت کے احکامات اور خریدنے کے احکامات دونوں موجود ہیں۔ اگر ان میں سے ایک موجود نہیں ہے تو ، اس سے یہ ظاہر ہوتا ہے کہ مارکیٹ میں کافی تجارتی معلومات نہیں ہوسکتی ہیں ، لہذا حکمت عملی انتظار کرتی رہے گی۔

• updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ", Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks): یہ کوڈ لائن اپ ڈیٹ اسٹیٹس فنکشن کو کال کرتی ہے تاکہ حکمت عملی کی حیثیت کی معلومات کو اپ ڈیٹ کیا جاسکے۔ یہ موجودہ مارکیٹ کی حیثیت کو ریکارڈ کرتی ہے ، جس میں سب سے زیادہ بولی کی قیمت ، سب سے کم قیمت کی قیمت اور پہلے سے مقفل اوقات (لاک) شامل ہیں۔

    var askPrice = 0;
    for (i = 0; i < depth.Asks.length; i++) {
        if (depth.Asks[i].Amount >= Lot) {
            askPrice = depth.Asks[i].Price;
            break;
        }
    }
    if (askPrice === 0) {
        continue;
    }
    var elephant = null;

• var askPrice = 0;: askPrice متغیر کو شروع کریں، یہ شرائط کو پورا فروخت کے احکامات کی قیمت کو ذخیرہ کرنے کے لئے استعمال کیا جائے گا.

• for (i = 0; i < depth.Asks.length; i++): یہ ایک فار لوپ ہے جو مارکیٹ میں فروخت کے احکامات کی قیمت اور مقدار کی معلومات کو عبور کرنے کے لئے استعمال ہوتا ہے۔

• if (depth.Asks[i].Amount >= Lot): لوپ میں ، چیک کریں کہ آیا ہر فروخت آرڈر کی مقدار مخصوص لاٹ (ہینڈ گنتی) سے زیادہ یا مساوی ہے۔ اگر ایسا ہے تو ، اس فروخت آرڈر کی قیمت کو askPrice میں اسٹور کریں اور لوپ کو ختم کریں۔

• if (askPrice === 0): اگر کوئی فروخت کے احکامات نہیں ملتے ہیں جو شرائط کو پورا کرتے ہیں (askPrice اب بھی 0 ہے) ، حکمت عملی انتظار کرنا جاری رکھے گی اور بعد میں کارروائیوں کو چھوڑ دے گی.

• var elephant = null;: ہاتھی متغیر کو شروع کریں، یہ ہاتھی کے طور پر شناخت خرید آرڈر کی معلومات کو ذخیرہ کرنے کے لئے استعمال کیا جائے گا.

    for (i = 1; i < depth.Bids.length; i++) {
        if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
            break;
        }
        if (depth.Bids[i].Amount >= ElephantAmount) {
            elephant = depth.Bids[i];
            break;
        }
    }

    if (!elephant) {
        locks = 0;
        continue;
    }
    locks++;
    if (locks < LockCount) {
        continue;
    }
    locks = 0;

مارکیٹ میں خریدنے کے احکامات کی قیمت اور مقدار کی معلومات کو عبور کرنا جاری رکھیں ، پہلا خریدنے کا آرڈر (بڈز[0]) کو چھوڑ دیں۔

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): چیک کریں کہ موجودہ بولی کی قیمت اور askPrice کے درمیان فرق ElephantSpace سے بڑا ہے۔ اگر ایسا ہے تو ، اس سے یہ ظاہر ہوتا ہے کہ یہ elephant سے کافی دور ہے ، اور حکمت عملی اب تلاش جاری نہیں رکھے گی۔

• if (depth.Bids[i].Amount >= ElephantAmount): چیک کریں کہ آیا موجودہ خرید آرڈر کی مقدار ElephantAmount سے زیادہ یا مساوی ہے۔ اگر ایسا ہے تو ، خرید آرڈر کی معلومات کو ہاتھی متغیر میں اسٹور کریں۔

• if (!elephant): اگر elephant نہیں ملتا ہے تو، مقفل گنتی کو 0 پر ری سیٹ کریں اور انتظار جاری رکھیں.

• locks++: اگر ہاتھی مل جائے تو ، تالے کی تعداد میں اضافہ کریں۔ اس بات کو یقینی بنانا ہے کہ حکمت عملی کو صرف ایک عرصے میں ہاتھی کے وجود کی متعدد بار تصدیق کے بعد ہی انجام دیا جائے۔

• if (locks < LockCount): چیک کریں کہ کیا لاک اوقات کی تعداد ضرورت کو پورا کرتی ہے (لاک کاؤنٹ) ۔ اگر ایسا نہیں ہے تو ، انتظار جاری رکھیں۔

    updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant));
    exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
    var ts = new Date().getTime();
    while (true) {
        Sleep(CheckInterval);
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        if ((new Date().getTime() - ts) > WaitInterval) {
            for (var i = 0; i < orders.length; i++) {
                exchange.CancelOrder(orders[i].Id);
            }
        }
    }

• updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant)): اپ ڈیٹ اسٹیٹس فنکشن کو کال کریں تاکہ اسٹریٹیجی کی موجودہ حالت کو ریکارڈ کیا جاسکے ، جس میں ہاتھی کی گیئر پوزیشن اور متعلقہ معلومات شامل ہیں۔ یہ حکمت عملی کی حیثیت بار میں دکھایا جائے گا۔

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): پایا گیا ہاتھی خریدنے کے لئے تبادلہ.خریداری فنکشن کا استعمال کریں۔ خریداری کی قیمت ہاتھی ہے۔ قیمت + پینی ٹِک ، خریداری کی مقدار لاٹ ہے ، اور خریداری کے عمل کو بولی[ + i + ] کے طور پر بیان کریں۔

• var ts = new Date().getTime(): وقت کے وقفے کے بعد حساب کے لئے موجودہ وقت کا ٹائم اسٹیمپ حاصل کریں.

• while (true): ایک نئی لامحدود لوپ درج کریں، ہاتھی خریدنے کے احکامات کے عملدرآمد کا انتظار کرنے کے لئے استعمال کیا.

• Sleep(CheckInterval): حکمت عملی حکم کی حیثیت کی جانچ پڑتال کی تعدد کو کنٹرول کرنے کے لئے ایک وقت کے لئے سوتا ہے.

• var orders = _C(exchange.GetOrders): جاری اکاؤنٹ کی تمام آرڈر کی معلومات حاصل کریں.

• if (orders.length == 0): چیک کریں کہ کوئی بھی نامکمل احکامات ہیں، اگر نہیں، لوپ توڑ.

• (new Date().getTime() - ts) > WaitInterval: موجودہ وقت اور جب elephant خریدا گیا تھا کے درمیان وقت کے وقفے کا حساب لگائیں۔ اگر یہ WaitInterval سے تجاوز کرتا ہے تو اس کا مطلب یہ ہے کہ انتظار کا وقت ختم ہوگیا ہے۔

• for (var i = 0; i < orders.length; i++): تمام غیر مکمل احکامات کے ذریعے سفر.

• exchange.CancelOrder(orders[i].Id): ہر نامکمل آرڈر کو منسوخ کرنے کے لئے تبادلہ.منسوخ آرڈر فنکشن کا استعمال کریں.

    var account = _C(exchange.GetAccount);
    var opAmount = _N(account.Stocks - InitAccount.Stocks);
    if (opAmount < 0.001) {
        Counter.f++;
        Counter.i++;
        continue;
    }
    updateStatus("Successful payment: " + opAmount + ", Start taking action...");
    exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
    var success = true;
    while (true) {
        var depth = _C(exchange.GetDepth);
        if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))) {
            success = false;
            updateStatus("Didn't get it, start to stop loss, currently buying one: " + depth.Bids[0].Price);
            CancelAll();
            account = _C(exchange.GetAccount);
            var opAmount = _N(account.Stocks - InitAccount.Stocks);
            if (opAmount < 0.001) {
                break;
            }
            exchange.Sell(depth.Bids[0].Price, opAmount);
        }
        var orders = _C(exchange.GetOrders);
        if (orders.length === 0) {
            break;
        }
        Sleep(CheckInterval);
    }
    if (success) {
        Counter.w++;
    } else {
        Counter.f++;
    }
    Counter.i++;
    var account = _C(exchange.GetAccount);
    LogProfit(account.Balance - InitAccount.Balance, account);
}

• var account = _C(exchange.GetAccount): کرنٹ اکاؤنٹ کی معلومات حاصل کریں۔

• var opAmount = _N(account.Stocks - InitAccount.Stocks) ہاتھی خریدنے کے بعد اکاؤنٹ کے اثاثوں میں تبدیلی کا حساب لگائیں۔ اگر تبدیلی 0.001 سے کم ہے تو ، اس سے یہ ظاہر ہوتا ہے کہ خریداری ناکام ہوگئی ہے ، ناکامیوں کی تعداد میں اضافہ کریں اور اگلے لوپ پر جاری رکھیں۔

• updateStatus("Successful payment: " + opAmount + ", Start taking action..."): فلی کی کامیاب خریداری کی معلومات، بشمول خریدی گئی مقدار کو ریکارڈ کریں۔

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): کامیابی کے ساتھ خریدا گیا ہاتھی منافع کے لئے فروخت کرنے کے لئے تبادلہ.فروخت کی تقریب کا استعمال کریں۔ فروخت کی قیمت ہاتھی ہے۔ قیمت + (پینی ٹِک * منافع ٹِک) ہے۔

ایک نئی لامحدود لوپ درج کریں، فروخت کے احکامات کے عملدرآمد کا انتظار کرنے کے لئے استعمال کیا.

• var depth = _C(exchange.GetDepth): مارکیٹ کی گہرائی کی معلومات حاصل کریں۔

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): مارکیٹ کی گہرائی کی معلومات چیک کریں، اگر مارکیٹ کی قیمت پہلے ہی سٹاپ نقصان کی سطح پر گر گئی ہے، تو سٹاپ نقصان کی کارروائی کو انجام دیں.

• CancelAll(): پوزیشن کے خطرے سے بچنے کے لئے تمام نامکمل احکامات کو منسوخ کرنے کے لئے منسوخ کریں.

• if (opAmount < 0.001): خریداری کی مقدار کو دوبارہ چیک کریں، اگر یہ 0.001 سے کم ہے، تو یہ اشارہ کرتا ہے کہ خریداری ناکام ہوگئی ہے، لوپ سے باہر نکلیں.

• exchange.Sell(depth.Bids[0].Price, opAmount): سٹاپ نقصان کا آپریشن انجام دیں، موجودہ مارکیٹ کی کم قیمت پر باقی اثاثے فروخت کریں۔

آخر میں، کامیاب اور ناکام لین دین کی تعداد کو اپ ڈیٹ کریں کہ آیا لین دین کامیاب تھا یا نہیں، اور تجارتی منافع کو ریکارڈ کریں.

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

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

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

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

1. سب سے پہلے، حکمت عملی مارکیٹ کی گہرائی کی معلومات کی جانچ پڑتال کرے گی تاکہ فروخت کے احکامات اور خریدنے کے احکامات کی موجودہ صورتحال کو سمجھا جا سکے.

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

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

4. اگر ہاتھی کی کافی تعداد لگاتار پائی جاتی ہے (لاک کاؤنٹ پیرامیٹر کے ذریعہ کنٹرول کیا جاتا ہے) ، تو حکمت عملی مزید مندرجہ ذیل کارروائیوں کو انجام دے گی:

• اپ ڈیٹ اسٹیٹس فنکشن کو کال کریں تاکہ فلی کے گیئر اور متعلقہ معلومات کو ریکارڈ کیا جاسکے۔
• elephant خریدنے کے لئے exchange.Buy فنکشن کا استعمال کریں، elephant.Price + PennyTick کی خریداری کی قیمت کے ساتھ، اور لاٹ کی مقدار.
• خریدنے کے حکم کے عمل کے انتظار میں ایک نئی لامحدود لوپ شروع کریں.
• حکم کی حیثیت چیک کریں. اگر یہ مکمل ہو گیا ہے، لوپ سے باہر توڑ.
• اگر انتظار کا وقت مقرر کردہ وقفہ (WaitInterval) سے زیادہ ہو تو تمام غیر مکمل احکامات منسوخ کریں۔
• کامیاب خریداری کے بعد اکاؤنٹ کے اثاثوں میں ہونے والی تبدیلیوں کا حساب لگائیں۔ اگر تبدیلی 0.001 سے کم ہے تو ، اس سے یہ ظاہر ہوتا ہے کہ خریداری ناکام ہوگئی ہے۔ ناکامی کی تعداد میں اضافہ کریں اور اگلے لوپ کو جاری رکھیں۔
• ہاتھیوں کی کامیاب خریداری کے بارے میں معلومات ریکارڈ کریں، بشمول خریدی گئی مقدار۔

5. اس کے بعد ، حکمت عملی ایک نئی لامحدود لوپ میں داخل ہوگی ، جس میں فروخت کے عمل کے عمل کا انتظار ہوگا۔ اس لوپ میں ، یہ مندرجہ ذیل اقدامات انجام دے گا:

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

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

خلاصہ

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