@bitfinex/lib-js-util-math 0.7.0 → 1.0.0

package/test/twap.test.js

@@ -1,224 +1,218 @@
 'use strict'
 
-const chai = require('chai')
-  .use(require('dirty-chai'))
-const { expect } = chai
+const test = require('brittle')
 const { nBN } = require('../src/bn')
 const { groupBySize, kline, typicalPrice, TWAP } = require('../src/twap')
 
-module.exports = () => {
-  describe('# twap-tests', () => {
-    it('groupBySize - it should fail with empty array', () => {
-      return expect(
-        groupBySize.bind(null, [], 100)
-      ).to.throw()
+test('groupBySize - it should fail with empty array', (t) => {
+  t.exception.all(
+    groupBySize.bind(null, [], 100)
+  )
+})
+
+test('groupBySize - it should fail with interval <= 0', (t) => {
+  t.exception.all(
+    groupBySize.bind(null, [123], 0)
+  )
+})
+
+test('groupBySize - it should fail with mixed positive/negative values', (t) => {
+  t.exception.all(
+    groupBySize.bind(null, [-123, 123], 100)
+  )
+})
+
+test('groupBySize - it should fail with invalid values', (t) => {
+  t.exception.all(
+    groupBySize.bind(null, ['-a123', 123], 100)
+  )
+})
+
+test('groupBySize - it should work with just one item', (t) => {
+  const res = groupBySize(['123'], 300)
+  t.ok(Array.isArray(res))
+  t.is(res.length, 1)
+  t.ok(Array.isArray(res[0]))
+  t.is(res[0].length, 1)
+  t.is(res[0][0], '123')
+})
+
+test('groupBySize - it should work with primitive types', (t) => {
+  const res = groupBySize([100, 200, 300, 400, 500, 600, 1000, 1100, 1200], 300)
+  t.ok(Array.isArray(res))
+  t.is(res.length, 4)
+  const expected = [[100, 200, 300], [400, 500, 600], [], [1000, 1100, 1200]]
+  res.forEach((g, i) => {
+    const e = expected[i]
+    t.is(g.length, e.length)
+    g.forEach((item, j) => {
+      t.is(item, e[j])
     })
-
-    it('groupBySize - it should fail with interval <= 0', () => {
-      return expect(
-        groupBySize.bind(null, [123], 0)
-      ).to.throw()
-    })
-
-    it('groupBySize - it should fail with mixed positive/negative values', () => {
-      return expect(
-        groupBySize.bind(null, [-123, 123], 100)
-      ).to.throw()
-    })
-
-    it('groupBySize - it should fail with invalid values', () => {
-      return expect(
-        groupBySize.bind(null, ['-a123', 123], 100)
-      ).to.throw()
-    })
-
-    it('groupBySize - it should work with just one item', () => {
-      const res = groupBySize(['123'], 300)
-      expect(res).to.be.an('array')
-      expect(res.length).to.be.equal(1)
-      expect(res[0]).to.be.an('array')
-      expect(res[0].length).to.be.equal(1)
-      return expect(res[0][0]).to.be.equal('123')
-    })
-
-    it('groupBySize - it should work with primitive types', () => {
-      const res = groupBySize([100, 200, 300, 400, 500, 600, 1000, 1100, 1200], 300)
-      expect(res).to.be.an('array')
-      expect(res.length).to.be.equal(4)
-      const expected = [[100, 200, 300], [400, 500, 600], [], [1000, 1100, 1200]]
-      res.forEach((g, i) => {
-        const e = expected[i]
-        expect(g.length).to.be.equal(e.length)
-        g.forEach((item, j) => {
-          expect(item).to.be.equal(e[j])
-        })
-      })
-    })
-
-    it('groupBySize - it should work with negative prices', () => {
-      const res = groupBySize([-100, -200, -300, -400, -500, -600, -1000, -1100, -1200], 300)
-      expect(res).to.be.an('array')
-      expect(res.length).to.be.equal(4)
-      const expected = [[-1200, -1100, -1000], [], [-600, -500, -400], [-300, -200, -100]]
-      res.forEach((g, i) => {
-        const e = expected[i]
-        expect(g.length).to.be.equal(e.length)
-        g.forEach((item, j) => {
-          expect(item).to.be.equal(e[j])
-        })
-      })
-    })
-
-    it('groupBySize - it should work with complex types', () => {
-      const now = Date.now()
-      const prices = [
-        { price: '10003', ts: now - 9000 },
-        { price: '10000', ts: now - 4000 },
-        { price: '10003', ts: now - 6000 },
-        { price: '10001', ts: now - 5000 },
-        { price: '10003', ts: now - 8000 }
-      ]
-      const expected = [
-        [{ price: '10003', ts: now - 9000 }, { price: '10003', ts: now - 8000 }],
-        [{ price: '10003', ts: now - 6000 }, { price: '10001', ts: now - 5000 }, { price: '10000', ts: now - 4000 }]
-      ]
-
-      const res = groupBySize(prices, 3000, (a) => a.ts)
-      expect(res.length).to.be.equal(2)
-      res.forEach((g, i) => {
-        const e = expected[i]
-        expect(g.length).to.be.equal(e.length)
-        g.forEach((item, j) => {
-          expect(item.ts).to.be.equal(e[j].ts)
-        })
-      })
-    })
-
-    it('kline - it should fail with empty array', () => {
-      return expect(kline.bind(null, [])).to.throw()
-    })
-
-    it('kline - it should fail with invalid numbers', () => {
-      expect(kline.bind(null, ['abc123', 123, 333, 44])).to.throw()
-      return expect(kline.bind(null, [123, 123, 'aaa333', 44])).to.throw()
-    })
-
-    it('kline - it should return expected value', () => {
-      const prices = ['10001', 10002, nBN(10003)]
-      const res = kline(prices)
-
-      expect(res.open).to.be.equal('10001')
-      expect(res.high).to.be.equal('10003')
-      expect(res.low).to.be.equal('10001')
-      expect(res.close).to.be.equal('10003')
-    })
-
-    it('kline - it should work with complex types', () => {
-      const now = Date.now()
-      const prices = [
-        { price: 10001, ts: now - 2000 },
-        { price: 10002, ts: now - 1000 },
-        { price: 10003, ts: now }
-      ]
-      const res = kline(prices, (a) => a.price)
-
-      expect(res.open).to.be.equal('10001')
-      expect(res.high).to.be.equal('10003')
-      expect(res.low).to.be.equal('10001')
-      expect(res.close).to.be.equal('10003')
-    })
-
-    it('typicalPrice - it should fail with empty array', () => {
-      return expect(typicalPrice.bind(null, [])).to.throw()
-    })
-
-    it('typicalPrice - it should fail with invalid numbers', () => {
-      expect(typicalPrice.bind(null, ['abc123', 123, 333, 44])).to.throw()
-      return expect(typicalPrice.bind(null, [123, 123, 'aaa333', 44])).to.throw()
-    })
-
-    it('typicalPrice - it should return expected value', () => {
-      const prices = ['10001', 10002, nBN(10003)]
-      const res = typicalPrice(prices)
-      return expect(res).to.be.equal('10002')
-    })
-
-    it('typicalPrice - it should work with complex types', () => {
-      const now = Date.now()
-      const prices = [
-        { price: 10001, ts: now },
-        { price: 10002, ts: now - 1000 },
-        { price: 10003, ts: now - 2000 }
-      ]
-      const res = typicalPrice(prices, (a) => a.price)
-      return expect(res).to.be.equal('10002')
-    })
-
-    it('twap - it should fail with empty array', () => {
-      return expect(TWAP.bind(null, [], 3000, (a) => a.ts, (a) => a.price)).to.throw()
-    })
-
-    it('twap - it should fail with interval <= 0', () => {
-      const now = Date.now()
-      const prices = [
-        { price: '10001', ts: now },
-        { price: '10000', ts: now - 1000 },
-        { price: '10001', ts: now - 2000 },
-        { price: 10002, ts: now - 3000 },
-        { price: '10003', ts: now - 9000 },
-        { price: nBN('10000'), ts: now - 4000 },
-        { price: '10003', ts: now - 6000 },
-        { price: '10001', ts: now - 5000 },
-        { price: '10003', ts: now - 8000 }
-      ]
-      return expect(TWAP.bind(null, prices, -3000, (a) => a.ts, (a) => a.price)).to.throw()
-    })
-
-    it('twap - it should fail with invalid numbers', () => {
-      const now = Date.now()
-      const prices = [
-        { price: '10001', ts: now },
-        { price: '10000', ts: now - 1000 },
-        { price: '10001', ts: now - 2000 },
-        { price: 10002, ts: now - 3000 },
-        { price: '10003', ts: now - 9000 },
-        { price: nBN('10000'), ts: now - 4000 },
-        { price: 'ab10003', ts: now - 6000 },
-        { price: '10001', ts: now - 5000 },
-        { price: '10003', ts: now - 8000 }
-      ]
-      return expect(TWAP.bind(null, prices, 3000, (a) => a.ts, (a) => a.price)).to.throw()
-    })
-
-    it('twap - it should return expected value', () => {
-      const now = Date.now()
-      const prices = [
-        { price: '10001', ts: now },
-        { price: '10000', ts: now - 1000 },
-        { price: '10001', ts: now - 2000 },
-        { price: 10002, ts: now - 3000 },
-        { price: '10003', ts: now - 9000 },
-        { price: nBN('10000'), ts: now - 4000 },
-        { price: '10003', ts: now - 6000 },
-        { price: '10001', ts: now - 5000 },
-        { price: '10003', ts: now - 8000 }
-      ]
-      const res = TWAP(prices, 3000, (a) => a.ts, (a) => a.price)
-      return expect(res).to.be.equal('10001.625')
+  })
+})
+
+test('groupBySize - it should work with negative prices', (t) => {
+  const res = groupBySize([-100, -200, -300, -400, -500, -600, -1000, -1100, -1200], 300)
+  t.ok(Array.isArray(res))
+  t.is(res.length, 4)
+  const expected = [[-1200, -1100, -1000], [], [-600, -500, -400], [-300, -200, -100]]
+  res.forEach((g, i) => {
+    const e = expected[i]
+    t.is(g.length, e.length)
+    g.forEach((item, j) => {
+      t.is(item, e[j])
     })
-
-    it('twap - it should filter empty slots', () => {
-      const now = Date.now()
-      const prices = [
-        { price: '10001', ts: now },
-        { price: '10000', ts: now - 1000 },
-        { price: '10001', ts: now - 2000 },
-        { price: 10002, ts: now - 3000 },
-        { price: '10003', ts: now - 12000 },
-        { price: nBN('10000'), ts: now - 4000 }
-      ]
-      const res = TWAP(prices, 3000, (a) => a.ts, (a) => a.price)
-      return expect(res).to.be.equal('10001.25')
+  })
+})
+
+test('groupBySize - it should work with complex types', (t) => {
+  const now = Date.now()
+  const prices = [
+    { price: '10003', ts: now - 9000 },
+    { price: '10000', ts: now - 4000 },
+    { price: '10003', ts: now - 6000 },
+    { price: '10001', ts: now - 5000 },
+    { price: '10003', ts: now - 8000 }
+  ]
+  const expected = [
+    [{ price: '10003', ts: now - 9000 }, { price: '10003', ts: now - 8000 }],
+    [{ price: '10003', ts: now - 6000 }, { price: '10001', ts: now - 5000 }, { price: '10000', ts: now - 4000 }]
+  ]
+
+  const res = groupBySize(prices, 3000, (a) => a.ts)
+  t.is(res.length, 2)
+  res.forEach((g, i) => {
+    const e = expected[i]
+    t.is(g.length, e.length)
+    g.forEach((item, j) => {
+      t.is(item.ts, e[j].ts)
     })
   })
-}
+})
+
+test('kline - it should fail with empty array', (t) => {
+  t.exception.all(kline.bind(null, []))
+})
+
+test('kline - it should fail with invalid numbers', (t) => {
+  t.exception.all(kline.bind(null, ['abc123', 123, 333, 44]))
+  t.exception.all(kline.bind(null, [123, 123, 'aaa333', 44]))
+})
+
+test('kline - it should return expected value', (t) => {
+  const prices = ['10001', 10002, nBN(10003)]
+  const res = kline(prices)
+
+  t.is(res.open, '10001')
+  t.is(res.high, '10003')
+  t.is(res.low, '10001')
+  t.is(res.close, '10003')
+})
+
+test('kline - it should work with complex types', (t) => {
+  const now = Date.now()
+  const prices = [
+    { price: 10001, ts: now - 2000 },
+    { price: 10002, ts: now - 1000 },
+    { price: 10003, ts: now }
+  ]
+  const res = kline(prices, (a) => a.price)
+
+  t.is(res.open, '10001')
+  t.is(res.high, '10003')
+  t.is(res.low, '10001')
+  t.is(res.close, '10003')
+})
+
+test('typicalPrice - it should fail with empty array', (t) => {
+  t.exception.all(typicalPrice.bind(null, []))
+})
+
+test('typicalPrice - it should fail with invalid numbers', (t) => {
+  t.exception.all(typicalPrice.bind(null, ['abc123', 123, 333, 44]))
+  t.exception.all(typicalPrice.bind(null, [123, 123, 'aaa333', 44]))
+})
+
+test('typicalPrice - it should return expected value', (t) => {
+  const prices = ['10001', 10002, nBN(10003)]
+  const res = typicalPrice(prices)
+  t.is(res, '10002')
+})
+
+test('typicalPrice - it should work with complex types', (t) => {
+  const now = Date.now()
+  const prices = [
+    { price: 10001, ts: now },
+    { price: 10002, ts: now - 1000 },
+    { price: 10003, ts: now - 2000 }
+  ]
+  const res = typicalPrice(prices, (a) => a.price)
+  t.is(res, '10002')
+})
+
+test('twap - it should fail with empty array', (t) => {
+  t.exception.all(TWAP.bind(null, [], 3000, (a) => a.ts, (a) => a.price))
+})
+
+test('twap - it should fail with interval <= 0', (t) => {
+  const now = Date.now()
+  const prices = [
+    { price: '10001', ts: now },
+    { price: '10000', ts: now - 1000 },
+    { price: '10001', ts: now - 2000 },
+    { price: 10002, ts: now - 3000 },
+    { price: '10003', ts: now - 9000 },
+    { price: nBN('10000'), ts: now - 4000 },
+    { price: '10003', ts: now - 6000 },
+    { price: '10001', ts: now - 5000 },
+    { price: '10003', ts: now - 8000 }
+  ]
+  t.exception.all(TWAP.bind(null, prices, -3000, (a) => a.ts, (a) => a.price))
+})
+
+test('twap - it should fail with invalid numbers', (t) => {
+  const now = Date.now()
+  const prices = [
+    { price: '10001', ts: now },
+    { price: '10000', ts: now - 1000 },
+    { price: '10001', ts: now - 2000 },
+    { price: 10002, ts: now - 3000 },
+    { price: '10003', ts: now - 9000 },
+    { price: nBN('10000'), ts: now - 4000 },
+    { price: 'ab10003', ts: now - 6000 },
+    { price: '10001', ts: now - 5000 },
+    { price: '10003', ts: now - 8000 }
+  ]
+  t.exception.all(TWAP.bind(null, prices, 3000, (a) => a.ts, (a) => a.price))
+})
+
+test('twap - it should return expected value', (t) => {
+  const now = Date.now()
+  const prices = [
+    { price: '10001', ts: now },
+    { price: '10000', ts: now - 1000 },
+    { price: '10001', ts: now - 2000 },
+    { price: 10002, ts: now - 3000 },
+    { price: '10003', ts: now - 9000 },
+    { price: nBN('10000'), ts: now - 4000 },
+    { price: '10003', ts: now - 6000 },
+    { price: '10001', ts: now - 5000 },
+    { price: '10003', ts: now - 8000 }
+  ]
+  const res = TWAP(prices, 3000, (a) => a.ts, (a) => a.price)
+  t.is(res, '10001.625')
+})
+
+test('twap - it should filter empty slots', (t) => {
+  const now = Date.now()
+  const prices = [
+    { price: '10001', ts: now },
+    { price: '10000', ts: now - 1000 },
+    { price: '10001', ts: now - 2000 },
+    { price: 10002, ts: now - 3000 },
+    { price: '10003', ts: now - 12000 },
+    { price: nBN('10000'), ts: now - 4000 }
+  ]
+  const res = TWAP(prices, 3000, (a) => a.ts, (a) => a.price)
+  t.is(res, '10001.25')
+})

package/test/vwap.test.js

@@ -1,121 +1,119 @@
 'use strict'
 
-const chai = require('chai')
-  .use(require('dirty-chai'))
-const { expect } = chai
+const test = require('brittle')
 const { VWAP, EWVWAP } = require('../src/vwap')
 
-module.exports = () => {
-  describe('# vwap-tests', () => {
-    it('VWAP - it should fail with non numeric values', () => {
-      const values = [
-        { price: '10161', volume: '1' },
-        { price: 'a10261.235', volume: '1' }
-      ]
-
-      return expect(
-        VWAP.bind(null, values)
-      ).to.throw()
-    })
-
-    it('VWAP - it return 0 with no values', () => {
-      return expect(VWAP([])).to.be.equal('0')
-    })
-
-    it('VWAP - it should match the expected value', () => {
-      const values = [
-        { price: '10161', volume: '1' },
-        { price: '10261.235', volume: '1' },
-        { price: '10324.2567', volume: '1' },
-        { price: '10724', volume: '1' },
-        { price: '10232', volume: '1' },
-        { price: '10510.25847', volume: '1' },
-        { price: '10261.826', volume: '1' }
-      ]
-
-      const res = VWAP(values)
-      return expect(res).to.be.equal('10353.51088142857142857143')
-    })
-
-    it('EWVWAP - it should fail with non numeric values', () => {
-      const values = [
-        { price: '10161', weightType: 'bfx' },
-        { price: 'a10261.235', weightType: 'bitstamp' },
-        { price: '10261.826', weightType: 'kraken' }
-      ]
-
-      return expect(
-        EWVWAP.bind(null, values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
-      ).to.throw()
-    })
-
-    it('EWVWAP - it should fail with NaN values', () => {
-      const values = [
-        { price: '10161', weightType: 'bfx' },
-        { price: NaN, weightType: 'bitstamp' },
-        { price: '10261.826', weightType: 'kraken' }
-      ]
-
-      return expect(
-        EWVWAP.bind(null, values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
-      ).to.throw()
-    })
-
-    it('EWVWAP - it should fail with invalid config', () => {
-      const values = [
-        { price: '10161', weightType: 'bfx' },
-        { price: '10261.235', weightType: 'bitstamp' },
-        { price: '10261.826', weightType: 'kraken' }
-      ]
-
-      return expect(
-        EWVWAP.bind(null, values, { bfx: 0.33, bitstamp: 0.33, kraken: 0.33 })
-      ).to.throw('ERR_INVALID_WEIGHT_CONF')
-    })
-
-    it('EWVWAP - it should throw with wrong weightType in values', async () => {
-      const values = [
-        { price: '10161', weightType: 'bfx' },
-        { price: '10232', weightType: 'bitstamp' },
-        { price: '10510.25847', weightType: 'binance' },
-        { price: '10261.826', weightType: 'kraken' }
-      ]
-
-      return expect(
-        EWVWAP.bind(null, values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
-      ).to.throw('ERR_INVALID_WEIGHT_TYPE')
-    })
-
-    it('EWVWAP - it should throw with multiple weights of same type', async () => {
-      const values = [
-        { price: '10161', weightType: 'bfx' },
-        { price: '10261.235', weightType: 'bfx' },
-        { price: '10324.2567', weightType: 'bfx' },
-        { price: '10724', weightType: 'bfx' },
-        { price: '10510.25847', weightType: 'bitstamp' },
-        { price: '10261.826', weightType: 'kraken' }
-      ]
-
-      return expect(
-        EWVWAP.bind(null, values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
-      ).to.throw('ERR_DUP_WEIGHT_PRICES')
-    })
-
-    it('EWVWAP - it return 0 with no values', async () => {
-      return expect(
-        VWAP([], { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
-      ).to.be.equal('0')
-    })
-
-    it('EWVWAP - it should match the expected value', async () => {
-      const values = [
-        { price: '10161', weightType: 'bfx' },
-        { price: '10510.25847', weightType: 'bitstamp' },
-        { price: '10261.826', weightType: 'kraken' }
-      ]
-
-      const res = EWVWAP(values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
-      return expect(res).to.be.equal('10251.016894')
-    })
-  })
-}
+test('VWAP - it should fail with non numeric values', (t) => {
+  const values = [
+    { price: '10161', volume: '1' },
+    { price: 'a10261.235', volume: '1' }
+  ]
+
+  t.exception.all(
+    VWAP.bind(null, values)
+  )
+})
+
+test('VWAP - it return 0 with no values', (t) => {
+  t.is(VWAP([]), '0')
+})
+
+test('VWAP - it should match the expected value', (t) => {
+  const values = [
+    { price: '10161', volume: '1' },
+    { price: '10261.235', volume: '1' },
+    { price: '10324.2567', volume: '1' },
+    { price: '10724', volume: '1' },
+    { price: '10232', volume: '1' },
+    { price: '10510.25847', volume: '1' },
+    { price: '10261.826', volume: '1' }
+  ]
+
+  const res = VWAP(values)
+  t.is(res, '10353.51088142857142857143')
+})
+
+test('EWVWAP - it should fail with non numeric values', (t) => {
+  const values = [
+    { price: '10161', weightType: 'bfx' },
+    { price: 'a10261.235', weightType: 'bitstamp' },
+    { price: '10261.826', weightType: 'kraken' }
+  ]
+
+  t.exception.all(
+    EWVWAP.bind(null, values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
+  )
+})
+
+test('EWVWAP - it should fail with NaN values', (t) => {
+  const values = [
+    { price: '10161', weightType: 'bfx' },
+    { price: NaN, weightType: 'bitstamp' },
+    { price: '10261.826', weightType: 'kraken' }
+  ]
+
+  t.exception.all(
+    EWVWAP.bind(null, values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
+  )
+})
+
+test('EWVWAP - it should fail with invalid config', (t) => {
+  const values = [
+    { price: '10161', weightType: 'bfx' },
+    { price: '10261.235', weightType: 'bitstamp' },
+    { price: '10261.826', weightType: 'kraken' }
+  ]
+
+  t.exception(
+    EWVWAP.bind(null, values, { bfx: 0.33, bitstamp: 0.33, kraken: 0.33 }),
+    /ERR_INVALID_WEIGHT_CONF/
+  )
+})
+
+test('EWVWAP - it should throw with wrong weightType in values', async (t) => {
+  const values = [
+    { price: '10161', weightType: 'bfx' },
+    { price: '10232', weightType: 'bitstamp' },
+    { price: '10510.25847', weightType: 'binance' },
+    { price: '10261.826', weightType: 'kraken' }
+  ]
+
+  t.exception(
+    EWVWAP.bind(null, values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 }),
+    /ERR_INVALID_WEIGHT_TYPE/
+  )
+})
+
+test('EWVWAP - it should throw with multiple weights of same type', async (t) => {
+  const values = [
+    { price: '10161', weightType: 'bfx' },
+    { price: '10261.235', weightType: 'bfx' },
+    { price: '10324.2567', weightType: 'bfx' },
+    { price: '10724', weightType: 'bfx' },
+    { price: '10510.25847', weightType: 'bitstamp' },
+    { price: '10261.826', weightType: 'kraken' }
+  ]
+
+  t.exception(
+    EWVWAP.bind(null, values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 }),
+    /ERR_DUP_WEIGHT_PRICES/
+  )
+})
+
+test('EWVWAP - it return 0 with no values', async (t) => {
+  t.is(
+    VWAP([], { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 }),
+    '0'
+  )
+})
+
+test('EWVWAP - it should match the expected value', async (t) => {
+  const values = [
+    { price: '10161', weightType: 'bfx' },
+    { price: '10510.25847', weightType: 'bitstamp' },
+    { price: '10261.826', weightType: 'kraken' }
+  ]
+
+  const res = EWVWAP(values, { bfx: 0.6, bitstamp: 0.2, kraken: 0.2 })
+  t.is(res, '10251.016894')
+})