ہری مرچوں کی کٹائی کرنے والی مشینوں کی حکمت عملی کا تجزیہ (1)

گوبھی کاٹنے والی مشینوں کی حکمت عملی کا تجزیہ

حالیہ انوینٹرز کو ویکیپیڈیا گروپ میں تبادلہ خیالprint moneyایک بار پھر ، ایک بہت ہی پرانی حکمت عملی ، جس کے بارے میں بات چیت بہت گرم ہے ، وسیع پیمانے پر لوگوں کی نظر میں واپس آگئی:آم کاٹنے والی مشین。 print moneyروبوٹ ٹریڈنگ کے اصول نے گوبھی کاٹنے والی مشین کی حکمت عملی کا حوالہ دیا ، اس نے الزام لگایا کہ اس وقت گوبھی کاٹنے والی مشین کی حکمت عملی کے بارے میں اس کی سمجھ میں نہیں آیا تھا۔ لہذا ، اصل حکمت عملی کو دوبارہ سنجیدگی سے دیکھا گیا اور ایک بار پھر موجد کی مقدار پر منتقل شدہ ورژن کو دیکھا گیا۔OKCoin کی نقل و حمل◄ اس کے بارے میں سوچنا یہ ہے کہ اس پلیٹ فارم کے صارفین کو اس حکمت عملی کو سیکھنے کے ل the پلیٹ فارم کے انوینٹرز کی طرف سے کوانٹیفائی کی جانے والی پلیٹ فارم کی نقل و حمل کی حکمت عملی کا تجزیہ کیا جائے۔ اس مضمون میں ہم نے اسٹریٹجک خیالات، ارادوں اور دیگر سطحوں سے زیادہ تجزیہ کیا ہے تاکہ پروگرامنگ سے متعلق سست مواد کو کم سے کم کیا جا سکے۔

[OKCoin کی نقل و حمل کی گوبھی کاٹنے والی مشینیں] حکمت عملی کا ماخذ:

function LeeksReaper() {
    var self = {}
    self.numTick = 0
    self.lastTradeId = 0
    self.vol = 0
    self.askPrice = 0
    self.bidPrice = 0
    self.orderBook = {Asks:[], Bids:[]}
    self.prices = []
    self.tradeOrderId = 0
    self.p = 0.5
    self.account = null
    self.preCalc = 0
    self.preNet = 0

    self.updateTrades = function() {
        var trades = _C(exchange.GetTrades)
        if (self.prices.length == 0) {
            while (trades.length == 0) {
                trades = trades.concat(_C(exchange.GetTrades))
            }
            for (var i = 0; i < 15; i++) {
                self.prices[i] = trades[trades.length - 1].Price
            }
        }
        self.vol = 0.7 * self.vol + 0.3 * _.reduce(trades, function(mem, trade) {
            // Huobi not support trade.Id
            if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
                self.lastTradeId = Math.max(trade.Id == 0 ? trade.Time : trade.Id, self.lastTradeId)
                mem += trade.Amount
            }
            return mem
        }, 0)

    }
    self.updateOrderBook = function() {
        var orderBook = _C(exchange.GetDepth)
        self.orderBook = orderBook
        if (orderBook.Bids.length < 3 || orderBook.Asks.length < 3) {
            return
        }
        self.bidPrice = orderBook.Bids[0].Price * 0.618 + orderBook.Asks[0].Price * 0.382 + 0.01
        self.askPrice = orderBook.Bids[0].Price * 0.382 + orderBook.Asks[0].Price * 0.618 - 0.01
        self.prices.shift()
        self.prices.push(_N((orderBook.Bids[0].Price + orderBook.Asks[0].Price) * 0.35 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.05))
    }
    self.balanceAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        var now = new Date().getTime()
        if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {
            self.preCalc = now
            var net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))
            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }
        }
        self.btc = account.Stocks
        self.cny = account.Balance
        self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)
        var balanced = false
        
        if (self.p < 0.48) {
            Log("开始平衡", self.p)
            self.cny -= 300
            if (self.orderBook.Bids.length >0) {
                exchange.Buy(self.orderBook.Bids[0].Price + 0.00, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.01, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.02, 0.01)
            }
        } else if (self.p > 0.52) {
            Log("开始平衡", self.p)
            self.btc -= 0.03
            if (self.orderBook.Asks.length >0) {
                exchange.Sell(self.orderBook.Asks[0].Price - 0.00, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.01, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.02, 0.01)
            }
        }
        Sleep(BalanceTimeout)
        var orders = exchange.GetOrders()
        if (orders) {
            for (var i = 0; i < orders.length; i++) {
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)
                }
            }
        }
    }

    self.poll = function() {
        self.numTick++
        self.updateTrades()
        self.updateOrderBook()
        self.balanceAccount()
        
        var burstPrice = self.prices[self.prices.length-1] * BurstThresholdPct
        var bull = false
        var bear = false
        var tradeAmount = 0
        if (self.account) {
            LogStatus(self.account, 'Tick:', self.numTick, ', lastPrice:', self.prices[self.prices.length-1], ', burstPrice: ', burstPrice)
        }
        
        if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -1)) > burstPrice ||
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -2)) > burstPrice && self.prices[self.prices.length-1] > self.prices[self.prices.length-2]
            )) {
            bull = true
            tradeAmount = self.cny / self.bidPrice * 0.99
        } else if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -1)) < -burstPrice ||
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -2)) < -burstPrice && self.prices[self.prices.length-1] < self.prices[self.prices.length-2]
            )) {
            bear = true
            tradeAmount = self.btc
        }
        if (self.vol < BurstThresholdVol) {
            tradeAmount *= self.vol / BurstThresholdVol
        }
        
        if (self.numTick < 5) {
            tradeAmount *= 0.8
        }
        
        if (self.numTick < 10) {
            tradeAmount *= 0.8
        }
        
        if ((!bull && !bear) || tradeAmount < MinStock) {
            return
        }
        var tradePrice = bull ? self.bidPrice : self.askPrice
        while (tradeAmount >= MinStock) {
            var orderId = bull ? exchange.Buy(self.bidPrice, tradeAmount) : exchange.Sell(self.askPrice, tradeAmount)
            Sleep(200)
            if (orderId) {
                self.tradeOrderId = orderId
                var order = null
                while (true) {
                    order = exchange.GetOrder(orderId)
                    if (order) {
                        if (order.Status == ORDER_STATE_PENDING) {
                            exchange.CancelOrder(orderId)
                            Sleep(200)
                        } else {
                            break
                        }
                    }
                }
                self.tradeOrderId = 0
                tradeAmount -= order.DealAmount
                tradeAmount *= 0.9
                if (order.Status == ORDER_STATE_CANCELED) {
                    self.updateOrderBook()
                    while (bull && self.bidPrice - tradePrice > 0.1) {
                        tradeAmount *= 0.99
                        tradePrice += 0.1
                    }
                    while (bear && self.askPrice - tradePrice < -0.1) {
                        tradeAmount *= 0.99
                        tradePrice -= 0.1
                    }
                }
            }
        }
        self.numTick = 0
    }
    return self
}

function main() {
    var reaper = LeeksReaper()
    while (true) {
        reaper.poll()
        Sleep(TickInterval)
    }
}

حکمت عملی کا جائزہ

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

کلیدی الفاظ:

• حکمت عملیmainفنکشن کی پہلی سطر:var reaper = LeeksReaper()یہ ایک مقامی متغیر کا اعلان کرتا ہے.reaper، پھر LeeksReaper () فنکشن کو کال کریں ایک حکمت عملی کے منطقی اعتراض کی تعمیر کریںreaper。

• حکمت عملیmainاس کے بعد یہ فنکشن آتا ہے:

  while (true) {
      reaper.poll()
      Sleep(TickInterval)
  }
  

  ایک میں داخلwhileموت کا دائرہ، مسلسل عملدرآمدreaperاشیاء کی پروسیسنگ کی تقریبpoll()，poll()یہ فنکشن ٹریڈنگ کی حکمت عملی کا بنیادی منطق ہے ، اور اس کے بعد ہی پوری حکمت عملی کا عمل شروع ہوتا ہے۔ کے بارے میںSleep(TickInterval)یہ اچھی طرح سے سمجھا جاتا ہے کہ ٹریڈنگ منطق کے گردش کی تعدد کو کنٹرول کرنے کے لئے ہر مجموعی طور پر ٹریڈنگ منطق کے عملدرآمد کے بعد وقفے کا وقت کنٹرول کرنا ہے۔

تجزیہLeeksReaper()تعمیراتی افعال

دیکھو!LeeksReaper()اس کے علاوہ، آپ کو اس بات کا یقین کرنے کی ضرورت نہیں ہے کہ آپ کو اس کے بارے میں کیا خیال ہے.

LeeksReaper()اگر آپ کو یہ معلوم نہیں ہے کہ آپ کو کیا کرنا ہے تو ، آپ کو یہ معلوم ہونا چاہئے کہ آپ کو کیا کرنا ہے۔var self = {}، میںLeeksReaper()فنکشن کے عمل کے دوران ، اس خالی شے میں آہستہ آہستہ کچھ طریقوں ، خصوصیات کو شامل کیا جاتا ہے ، آخر کار اس شے کی تعمیر مکمل ہوجاتی ہے ، اور آخر میں اس شے کو واپس کردیتا ہے ((یعنیmain()فنکشن کے اندرvar reaper = LeeksReaper()اس مرحلے میں، واپس آنے والے اعتراض کی قدر دی جاتی ہےreaper）。

دے دوselfاشیاء کی خصوصیات کو شامل کریں

اگلاselfبہت ساری خصوصیات شامل کی گئیں ، جن میں سے ہر ایک کی وضاحت میں ذیل میں کروں گا ، تاکہ ان خصوصیات ، متغیرات کے استعمال ، ارادے ، اور حکمت عملی کو آسانی سے سمجھنے کے ل quickly جلدی سے سمجھا جاسکے ، اور اس کوڈ کے اس ڈھیر کو دیکھنے سے گریز کیا جاسکے۔

    self.numTick = 0         # 用来记录poll函数调用时未触发交易的次数，当触发下单并且下单逻辑执行完时，self.numTick重置为0
    self.lastTradeId = 0     # 交易市场已经成交的订单交易记录ID，这个变量记录市场当前最新的成交记录ID
    self.vol = 0             # 通过加权平均计算之后的市场每次考察时成交量参考（每次循环获取一次市场行情数据，可以理解为考察了行情一次）
    self.askPrice = 0        # 卖单提单价格，可以理解为策略通过计算后将要挂卖单的价格
    self.bidPrice = 0        # 买单提单价格
    self.orderBook = {Asks:[], Bids:[]}    # 记录当前获取的订单薄数据，即深度数据（卖一...卖n,买一...买n）
    self.prices = []                       # 一个数组，记录订单薄中前三档加权平均计算之后的时间序列上的价格，简单说就是每次储存计算得到的订单薄前三档加权平均价格，放在一个数组中，用于后续策略交易信号参考，所以该变量名是prices，复数形式，表示一组价格
    self.tradeOrderId = 0    # 记录当前提单下单后的订单ID
    self.p = 0.5             # 仓位比重，币的价值正好占总资产价值的一半时，该值为0.5，即平衡状态
    self.account = null      # 记录账户资产数据，由GetAccount()函数返回数据
    self.preCalc = 0         # 记录最近一次计算收益时的时间戳，单位毫秒，用于控制收益计算部分代码触发执行的频率
    self.preNet = 0          # 记录当前收益数值

دے دوselfاشیاء کو شامل کرنے کا طریقہ

اور پھر ہم نے خود کو ان خصوصیات کو شامل کیا، اور پھر ہم نے خود کو ان خصوصیات کو شامل کیا.selfاعتراض کو طریقہ شامل کرنے کے لئے، اس کو کچھ کام کرنے اور کچھ افعال رکھنے کی اجازت دیتا ہے۔

اور پھر آپ نے یہ بھی کہا:

    self.updateTrades = function() {
        var trades = _C(exchange.GetTrades)  # 调用FMZ封装的接口GetTrades，获取当前最新的市场成交数据
        if (self.prices.length == 0) {       # 当self.prices.length == 0时，需要给self.prices数组填充数值，只有策略启动运行时才会触发
            while (trades.length == 0) {     # 如果近期市场上没有更新的成交记录，这个while循环会一直执行，直到有最新成交数据，更新trades变量
                trades = trades.concat(_C(exchange.GetTrades))   # concat 是JS数组类型的一个方法，用来拼接两个数组，这里就是把“trades”数组和“_C(exchange.GetTrades)”返回的数组数据拼接成一个数组
            }
            for (var i = 0; i < 15; i++) {   # 给self.prices填充数据，填充15个最新成交价格
                self.prices[i] = trades[trades.length - 1].Price
            }
        }
        self.vol = 0.7 * self.vol + 0.3 * _.reduce(trades, function(mem, trade) {  # _.reduce 函数迭代计算，累计最新成交记录的成交量
            // Huobi not support trade.Id
            if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
                self.lastTradeId = Math.max(trade.Id == 0 ? trade.Time : trade.Id, self.lastTradeId)
                mem += trade.Amount
            }
            return mem
        }, 0)

    }

updateTradesاس فنکشن کا کام ایک بار تازہ ترین مارکیٹ ٹرانزیکشن ڈیٹا حاصل کرنا ہے ، اور اس کے مطابق کچھ حساب کتاب کرنا اور ریکارڈ کرنا ہے ، جو حکمت عملی کے بعد کی منطق میں استعمال ہوتا ہے۔ میں نے اوپر کے کوڈ میں براہ راست لکھے گئے لائن کی طرف اشارہ کیا ہے۔ کے لئے_.reduceیہاں ایک چھوٹی سی بات ہے جو شاید آپ کے ساتھیوں کو الجھن میں ڈال دے گی جو پروگرامنگ کے بارے میں کچھ نہیں جانتے ہیں۔_.reduceہاںUnderscore.jsاس لائبریری کے افعال، FMZJS کی پالیسی اس لائبریری کی حمایت کرتا ہے، لہذا یہ آئرنائزیشن کے لئے آسان ہے، اور یہ آپ کے لئے بہت اچھا ہے.Underscore.js资料链接

اس کا مطلب بہت آسان ہے، مثال کے طور پر:

function main () {
   var arr = [1, 2, 3, 4]
   var sum = _.reduce(arr, function(ret, ele){
       ret += ele
       
       return ret
   }, 0)

   Log("sum:", sum)    # sum 等于 10
}

اور اس کا مطلب یہ ہے کہ[1, 2, 3, 4]اس میں سے ہر ایک کو جمع کیا جائے گا.tradesاعداد و شمار کے مجموعے میں ہر ٹرانزیکشن ریکارڈ کے اعداد و شمار کو جمع کیا جاتا ہے۔ تازہ ترین ٹرانزیکشن ریکارڈ ٹرانزیکشنز کا مجموعہ پیدا ہوتا ہے۔self.vol = 0.7 * self.vol + 0.3 * _.reduce(...)براہ کرم اجازت دیں...اس کے بجائے اس کوڈ کا ایک ٹکڑا.self.volیہ حساب کتاب بھی ایک ویویٹڈ اوسط ہے۔ یعنی تازہ ترین ٹرانزیکشن کی مجموعی ٹرانزیکشن کا وزن 30 فیصد ہے جبکہ آخری ویویٹڈ حساب سے حاصل ہونے والی ٹرانزیکشن کا وزن 70 فیصد ہے۔ یہ تناسب حکمت عملی کے مصنفین کے ذریعہ طے کیا گیا ہے اور یہ مارکیٹ کے قوانین کے مشاہدے سے متعلق ہوسکتا ہے۔ اور آپ مجھ سے پوچھتے ہیں کہ اگر حالیہ ٹرانزیکشن کے اعداد و شمار حاصل کرنے والے انٹرفیس مجھے پرانے اعداد و شمار کی نقل واپس کرتے ہیں تو کیا ہوتا ہے؟ کیا میں نے غلط اعداد و شمار حاصل کیے ہیں اور کیا اس کا کوئی فائدہ ہے؟

if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
    ...
}

اس فیصلے کا فیصلہ ٹرانزیکشن ریکارڈ میں ٹرانزیکشن آئی ڈی پر مبنی کیا جاسکتا ہے ، اور صرف اس صورت میں مجموعی طور پر متحرک ہوتا ہے جب آئی ڈی پچھلے ریکارڈ سے بڑی ہو ، یا اگر ایکسچینج انٹرفیس آئی ڈی فراہم نہیں کرتا ہے ، یعنی ،trade.Id == 0اس کے علاوہ ، آپ کو اس وقت کے بارے میں جاننے کی ضرورت ہے۔self.lastTradeIdیہ ٹائم ٹیب ہے جو ٹرانزیکشن ریکارڈ کو محفوظ کرتا ہے، ID نہیں.

اور دوسرا فنکشن جو ہم نے شامل کیا:

    self.updateOrderBook = function() {
        var orderBook = _C(exchange.GetDepth)
        self.orderBook = orderBook
        if (orderBook.Bids.length < 3 || orderBook.Asks.length < 3) {
            return
        }
        self.bidPrice = orderBook.Bids[0].Price * 0.618 + orderBook.Asks[0].Price * 0.382 + 0.01
        self.askPrice = orderBook.Bids[0].Price * 0.382 + orderBook.Asks[0].Price * 0.618 - 0.01
        self.prices.shift()
        self.prices.push(_N((orderBook.Bids[0].Price + orderBook.Asks[0].Price) * 0.35 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.05))
    }

اگلا دیکھیںupdateOrderBookاس فنکشن کے نام سے ظاہر ہوتا ہے کہ اس فنکشن کا کام آرڈر ٹین کو اپ ڈیٹ کرنا ہے۔ ہاں ، لیکن صرف آرڈر ٹین کو اپ ڈیٹ کرنا ہی نہیں ہے۔ فنکشن ایف ایم زیڈ کے API فنکشن کو کال کرنا شروع کرتا ہے۔GetDepth()موجودہ مارکیٹ آرڈر پتلی اعداد و شمار حاصل کریں ((ایک فروخت... فروخت n، ایک خرید... خرید n) اور پتلی اعداد و شمار کو ریکارڈ کریںself.orderBookدرمیانہ۔ اس کے بعد فیصلہ کیا جاتا ہے کہ اگر آرڈر پتلی اعداد و شمار خریدیں ، فروخت کریں یا 3 سے کم آرڈر کریں تو ، غیر فعال فنکشن کو براہ راست واپس کرنے کا فیصلہ کیا جاتا ہے۔

اس کے بعد ، دو اعداد و شمار کا حساب لگایا گیا:

• قیمتوں کا حساب لگائیں حساب کتاب کی قیمت بھی وزن میں اضافہ اوسط کا استعمال کرتے ہوئے حساب کیا جاتا ہے، ادائیگی کے حساب کے لئے، خریدنے کے لئے ایک اختیار کو 61.8٪ ((0.618) ، فروخت کرنے کے لئے ایک باقی وزن 38.2٪ ((0.382) یہ بھی اسی طرح ہے جب خرید و فروخت کی قیمتوں کا حساب لگایا جاتا ہے تو ، فروخت اور فروخت کی ایک قیمت کا حق زیادہ اہم ہوتا ہے۔ 0.618 کیوں ہے ، شاید مصنف کو سونے کی تقسیم کا تناسب زیادہ پسند ہے۔ آخر میں ایک نقطۂٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔٔ

• اپ ڈیٹ ٹائم سیریز میں آرڈر ٹھنڈے پہلے تین درجے کے ساتھ ساتھ اوسط قیمت پہلے تین گرے خریدنے کے لئے ، بیچنے کی قیمت کا وزن اوسط حساب لگائیں ، پہلی گرے کا وزن 0.7 ، دوسری گرے کا وزن 0.2 ، تیسری گرے کا وزن 0.1 ہے۔ کچھ ساتھیوں کا کہنا ہے کہ: اوہ ، نہیں ، کوڈ میں لکڑی 0.7 ، 0.2 ، 0.1 ہے ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، اوہ ، او ہم اس حساب کو آگے بڑھاتے ہیں:

  (买一 + 卖一) * 0.35 + (买二 + 卖二) * 0.1 + (买三 + 卖三) * 0.05
  ->
  (买一 + 卖一) / 2 * 2 * 0.35 + (买二 + 卖二) / 2 * 2 * 0.1 + (买三 + 卖三) / 2 * 2 * 0.05
  ->
  (买一 + 卖一) / 2 * 0.7 + (买二 + 卖二) / 2 * 0.2 + (买三 + 卖三) / 2 * 0.1
  ->
  第一档平均的价格 * 0.7 + 第二档平均的价格 * 0.2 + 第三档平均的价格 * 0.1
  

  یہاں سے یہ دیکھا جاسکتا ہے کہ حتمی قیمت کا حساب کتاب اصل میں اس وقت کی مارکیٹ میں تین درمیانے درجے کی قیمتوں کی قیمتوں کا تعین ہے۔ اس کے بعد اس قیمت کے حساب سے اپ ڈیٹ کریں.self.pricesاعداد و شمار، سب سے پرانی اعداد و شمار میں سے ایک کو نکالنے کے لئےshift()فنکشن) ، ایک تازہ ترین ڈیٹا میں اپ ڈیٹ کریں ((کے ذریعےpush()فنکشن، شفٹ، اور پش فنکشن جے ایس زبان کے آرٹیکل آبجیکٹ کے طریقوں میں سے ایک ہیں، جس میں جے ایس کے اعداد و شمار کو تلاش کرنے کے لئے استعمال کیا جا سکتا ہے.self.pricesاعداد و شمار کا سلسلہ وقت کے ساتھ ترتیب دیا گیا ڈیٹا اسٹریم ہے۔

میں نے ایک بار پھر آپ کو بتایا ہے کہ میں نے ایک بار پھر آپ کو بتایا ہے کہ میں نے ایک بار پھر آپ کو بتایا ہے کہ میں نے آپ کو بتایا ہے کہ میں نے آپ کو بتایا ہے کہ میں نے آپ کو بتایا ہے کہ میں نے آپ کو بتایا ہے کہ میں نے آپ کو بتایا ہے کہ میں آپ کو بتایا ہے کہ میں آپ کو نہیں جانتا کہ آپ کیا کہہ رہے ہیں۔