@quantform/core 0.5.15 → 0.5.23

package/src/indicator/trailing.spec.ts

@@ -1,20 +1,24 @@
-import { from } from 'rxjs';
+import { from, map } from 'rxjs';
 
-import { trailingdown, trailingup } from './trailing';
+import { d } from '../shared';
+import { trailingDown, trailingUp } from './trailing';
 
-describe('trailingup', () => {
+describe('trailingUp', () => {
   test('should trigger uptrend once', done => {
     let triggered = false;
 
     from([1, 2, 3, 2, 3])
-      .pipe(trailingup(3, 1, it => it))
+      .pipe(
+        map(it => d(it)),
+        trailingUp(d(3), d(1), it => it)
+      )
       .subscribe({
         next: it => {
-          expect(it).toBe(2);
+          expect(it).toEqual(d(2));
           triggered = true;
         },
         complete: () => {
-          expect(triggered).toBe(true);
+          expect(triggered).toEqual(true);
           done();
         }
       });
@@ -24,33 +28,39 @@ describe('trailingup', () => {
     let triggered = 0;
 
     from([1, 2, 3, 2, 3, 2, 3])
-      .pipe(trailingup(3, 1, it => it))
+      .pipe(
+        map(it => d(it)),
+        trailingUp(d(3), d(1), it => it)
+      )
       .subscribe({
         next: it => {
-          expect(it).toBe(2);
+          expect(d(it)).toEqual(d(2));
           triggered++;
         },
         complete: () => {
-          expect(triggered).toBe(2);
+          expect(triggered).toEqual(2);
           done();
         }
       });
   });
 });
 
-describe('trailingdown', () => {
+describe('trailingDown', () => {
   test('should trigger downtrend once', done => {
     let triggered = false;
 
     from([3, 2, 1, 2, 1])
-      .pipe(trailingdown(3, 1, it => it))
+      .pipe(
+        map(it => d(it)),
+        trailingDown(d(3), d(1), it => it)
+      )
       .subscribe({
         next: it => {
-          expect(it).toBe(2);
+          expect(it).toEqual(d(2));
           triggered = true;
         },
         complete: () => {
-          expect(triggered).toBe(true);
+          expect(triggered).toEqual(true);
           done();
         }
       });
@@ -60,14 +70,17 @@ describe('trailingdown', () => {
     let triggered = 0;
 
     from([3, 2, 1, 2, 1, 2, 1])
-      .pipe(trailingdown(3, 1, it => it))
+      .pipe(
+        map(it => d(it)),
+        trailingDown(d(3), d(1), it => it)
+      )
       .subscribe({
         next: it => {
-          expect(it).toBe(2);
+          expect(it).toEqual(d(2));
           triggered++;
         },
         complete: () => {
-          expect(triggered).toBe(2);
+          expect(triggered).toEqual(2);
           done();
         }
       });

package/src/indicator/trailing.ts

@@ -1,14 +1,16 @@
 import { filter, Observable } from 'rxjs';
 
+import { d, decimal } from '../shared';
+
 export class Trailing {
   private triggered = false;
-  private max = null;
-  private min = null;
+  private max: decimal = null;
+  private min: decimal = null;
 
-  constructor(readonly trigger: number, readonly buffer: number) {}
+  constructor(readonly trigger: decimal, readonly buffer: decimal) {}
 
-  up(value: number): boolean {
-    if (value >= this.trigger) {
+  up(value: decimal): boolean {
+    if (value.greaterThanOrEqualTo(this.trigger)) {
       this.triggered = true;
     }
 
@@ -16,11 +18,11 @@ export class Trailing {
       if (!this.max) {
         this.max = value;
       } else {
-        this.max = Math.max(this.max, value);
+        this.max = decimal.max(this.max, value);
       }
     }
 
-    if (this.triggered && value <= this.max - this.buffer) {
+    if (this.triggered && value.lessThanOrEqualTo(this.max.minus(this.buffer))) {
       this.triggered = false;
       this.max = null;
 
@@ -30,8 +32,8 @@ export class Trailing {
     return false;
   }
 
-  down(value: number): boolean {
-    if (value <= this.trigger) {
+  down(value: decimal): boolean {
+    if (value.lessThanOrEqualTo(this.trigger)) {
       this.triggered = true;
     }
 
@@ -39,11 +41,11 @@ export class Trailing {
       if (!this.min) {
         this.min = value;
       } else {
-        this.min = Math.min(this.min, value);
+        this.min = decimal.min(this.min, value);
       }
     }
 
-    if (this.triggered && value >= this.min + this.buffer) {
+    if (this.triggered && value.greaterThanOrEqualTo(this.min.plus(this.buffer))) {
       this.triggered = false;
       this.min = null;
 
@@ -54,7 +56,11 @@ export class Trailing {
   }
 }
 
-export function trailingup<T>(trigger: number, buffer: number, value: (it: T) => number) {
+export function trailingUp<T>(
+  trigger: decimal,
+  buffer: decimal,
+  value: (it: T) => decimal
+) {
   return function (source: Observable<T>): Observable<T> {
     const trailing = new Trailing(trigger, buffer);
 
@@ -62,10 +68,10 @@ export function trailingup<T>(trigger: number, buffer: number, value: (it: T) =>
   };
 }
 
-export function trailingdown<T>(
-  trigger: number,
-  buffer: number,
-  value: (it: T) => number
+export function trailingDown<T>(
+  trigger: decimal,
+  buffer: decimal,
+  value: (it: T) => decimal
 ) {
   return function (source: Observable<T>): Observable<T> {
     const trailing = new Trailing(trigger, buffer);

package/src/indicator/true-range.spec.ts

@@ -0,0 +1,32 @@
+import { from } from 'rxjs';
+
+import { Candle } from '../domain';
+import { d, decimal, now } from '../shared';
+import { sma } from './sma';
+import { trueRange } from './true-range';
+
+describe('trueRange', () => {
+  test('should return expected value', done => {
+    let value: decimal;
+
+    //12 Dec 2020 00:00
+    from([
+      new Candle(now(), d(18127.81), d(18149.75), d(18100.0), d(18136.17)),
+      new Candle(now(), d(18136.17), d(18136.18), d(18089.75), d(18092.15)),
+      new Candle(now(), d(18092.15), d(18120.03), d(18081.0), d(18082.39)),
+      new Candle(now(), d(18082.39), d(18087.04), d(18041.0), d(18065.4)),
+      new Candle(now(), d(18066.11), d(18079.15), d(18041.0), d(18046.47))
+    ])
+      .pipe(
+        trueRange(it => it),
+        sma(4, ([, it]) => it)
+      )
+      .subscribe({
+        next: ([, it]) => (value = it),
+        complete: () => {
+          expect(value.toDecimalPlaces(2)).toEqual(d(42.41));
+          done();
+        }
+      });
+  });
+});

package/src/indicator/true-range.ts

@@ -0,0 +1,32 @@
+import { map, Observable, share } from 'rxjs';
+
+import { Candle } from '../domain';
+import { decimal } from '../shared';
+
+export function trueRange<T>(fn: (it: T) => Candle) {
+  return function (source: Observable<T>): Observable<[T, decimal]> {
+    let previous;
+
+    return source.pipe(
+      map(it => {
+        const current = fn(it);
+
+        const value =
+          previous == null
+            ? current.high.minus(current.low)
+            : decimal.max(
+                decimal.max(
+                  current.high.minus(current.low),
+                  decimal.abs(current.high.minus(previous.close))
+                ),
+                decimal.abs(current.low.minus(previous.close))
+              );
+
+        const tuple: [T, decimal] = [it, value];
+
+        return tuple;
+      }),
+      share()
+    );
+  };
+}

package/src/indicator/window.ts

@@ -3,12 +3,12 @@ import { map, Observable, share } from 'rxjs';
 import { RingBuffer } from './ring-buffer';
 
 export function window<T, Y>(length: number, fn: (value: T) => Y) {
-  return function (source: Observable<T>): Observable<[T, RingBuffer<Y>, Y, Y]> {
+  return function (source: Observable<T>): Observable<[T, RingBuffer<Y>, Y, Y?]> {
     const buffer = new RingBuffer<Y>(length);
 
     return source.pipe(
       map(it => {
-        let removed = null;
+        let removed = undefined;
 
         if (buffer.isFull) {
           removed = buffer.peek();
@@ -18,7 +18,7 @@ export function window<T, Y>(length: number, fn: (value: T) => Y) {
 
         buffer.enqueue(value);
 
-        const tuple: [T, RingBuffer<Y>, Y, Y] = [it, buffer, value, removed];
+        const tuple: [T, RingBuffer<Y>, Y, Y?] = [it, buffer, value, removed];
 
         return tuple;
       }),

package/src/indicator/wma.spec.ts

@@ -1,17 +1,18 @@
 import { from } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { wma } from './wma';
 
 describe('wma', () => {
   test('should return expected value', done => {
-    let value;
+    let value: decimal;
     //12 Dec 2020 00:00
-    from([18136.17, 18092.15, 18082.39, 18065.4, 18046.47])
+    from([d(18136.17), d(18092.15), d(18082.39), d(18065.4), d(18046.47)])
       .pipe(wma(5, it => it))
       .subscribe({
         next: ([, it]) => (value = it),
         complete: () => {
-          expect(parseFloat(value.toFixed(2))).toBe(18070.77);
+          expect(value.toDecimalPlaces(2)).toEqual(d(18070.77));
           done();
         }
       });

package/src/indicator/wma.ts

@@ -1,24 +1,25 @@
 import { filter, map, Observable, share } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { window } from './window';
 
-export function wma<T>(length: number, fn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<[T, number]> {
+export function wma<T>(length: number, fn: (it: T) => decimal) {
+  return function (source: Observable<T>): Observable<[T, decimal]> {
     return source.pipe(
       window(length, fn),
       filter(([, buffer]) => buffer.isFull),
       map(([it, buffer]) => {
-        let norm = 0.0;
-        let sum = 0.0;
+        let norm = d(0.0);
+        let sum = d(0.0);
 
         for (let i = 0; i < buffer.capacity; i++) {
           const weight = (buffer.capacity - i) * buffer.capacity;
 
-          norm = norm + weight;
-          sum = sum + buffer.at(buffer.capacity - (i + 1)) * weight;
+          norm = norm.add(weight);
+          sum = sum.add(buffer.at(buffer.capacity - (i + 1)).mul(weight));
         }
 
-        const tuple: [T, number] = [it, sum / norm];
+        const tuple: [T, decimal] = [it, sum.div(norm)];
 
         return tuple;
       }),

package/src/shared/collections.spec.ts

@@ -0,0 +1,30 @@
+import { Liquidity, LiquidityAskComparer } from '..';
+import { d, PriorityList } from '.';
+
+describe('PriorityList', () => {
+  test('should patch a best bid and ask', () => {
+    const input = [
+      { rate: d(2), quantity: d(2) },
+      { rate: d(2), quantity: d(3) },
+      { rate: d(5), quantity: d(1) },
+      { rate: d(5), quantity: d(2) },
+      { rate: d(3), quantity: d(1) },
+      { rate: d(1), quantity: d(8) },
+      { rate: d(1), quantity: d(0) },
+      { rate: d(3), quantity: d(0) },
+      { rate: d(5), quantity: d(0) }
+    ];
+
+    const sut = new PriorityList<Liquidity>(LiquidityAskComparer, 'rate');
+
+    input.forEach(it => (it.quantity.greaterThan(0) ? sut.enqueue(it) : sut.dequeue(it)));
+
+    const volume = sut.reduce((it, agg) => agg.add(it.quantity.mul(it.rate)), d.Zero);
+
+    expect(sut.head.rate).toEqual(d(2));
+    expect(sut.head.quantity).toEqual(d(3));
+    expect(volume).toEqual(d(6));
+    expect(sut.getByKey(2).quantity).toEqual(d(3));
+    expect(sut.getByKey(3)).toEqual(undefined);
+  });
+});

package/src/shared/collections.ts

@@ -33,3 +33,109 @@ export class Set<T extends { id: string }> {
     return this.array;
   }
 }
+
+export class PriorityList<T extends { next: T }> {
+  private valueByKey: Record<any, T> = {};
+
+  head: T;
+
+  constructor(
+    private readonly comparer: (lhs: Omit<T, 'next'>, rhs: Omit<T, 'next'>) => number,
+    private readonly key: keyof Omit<T, 'next'>
+  ) {}
+
+  getByKey(key: any): T {
+    return this.valueByKey[key];
+  }
+
+  private make(value: Omit<T, 'next'>, next: T = undefined): T {
+    const node = { ...value, next } as T;
+
+    this.valueByKey[node[this.key].toString()] = node;
+
+    return node;
+  }
+
+  enqueue(value: Omit<T, 'next'>) {
+    if (!this.head) {
+      this.head = this.make(value);
+    }
+
+    if (this.comparer(this.head, value) > 0) {
+      this.head = this.make(value, this.head);
+    } else if (this.comparer(this.head, value) == 0) {
+      this.head = this.make(value, this.head.next);
+    } else {
+      this.visit(it => {
+        if (it.next) {
+          if (this.comparer(it.next, value) == 0) {
+            it.next = this.make(value, it.next.next);
+
+            return false;
+          }
+
+          if (this.comparer(it.next, value) > 0) {
+            it.next = this.make(value, it.next);
+
+            return false;
+          }
+
+          return true;
+        } else {
+          it.next = this.make(value);
+
+          return false;
+        }
+      });
+    }
+  }
+
+  dequeue(value: Omit<T, 'next'>) {
+    if (!this.head) {
+      return;
+    }
+
+    if (this.comparer(this.head, value) == 0) {
+      this.head = this.head.next;
+
+      delete this.valueByKey[value[this.key].toString()];
+    }
+
+    this.visit(it => {
+      if (it.next && this.comparer(it.next, value) == 0) {
+        it.next = it.next.next;
+
+        delete this.valueByKey[value[this.key].toString()];
+
+        return false;
+      }
+    });
+  }
+
+  clear() {
+    this.head = undefined;
+    this.valueByKey = {};
+  }
+
+  visit(fn: (value: T) => boolean) {
+    let top = this.head;
+
+    while (top) {
+      if (!fn(top)) {
+        break;
+      }
+
+      top = top.next;
+    }
+  }
+
+  reduce<K>(fn: (value: T, aggregate: K) => K, initValue: K) {
+    this.visit(it => {
+      initValue = fn(it, initValue);
+
+      return true;
+    });
+
+    return initValue;
+  }
+}

package/src/shared/decimals.spec.ts

@@ -1,35 +1,29 @@
-import { ceil, fixed, floor, precision } from './decimals';
+import { d } from './decimals';
 
 describe('decimals', () => {
   test('get precision tests', () => {
-    expect(precision(0.01)).toEqual(2);
-    expect(precision(0.0054)).toEqual(4);
-    expect(precision(0.9)).toEqual(1);
-    expect(precision(0.0)).toEqual(0);
-    expect(precision(2)).toEqual(0);
-  });
-
-  test('fixed tests', () => {
-    expect(fixed(0.01, 2)).toEqual(0.01);
-    expect(fixed(0.011, 2)).toEqual(0.01);
-    expect(fixed(0.019, 2)).toEqual(0.01);
-    expect(fixed(0.019, 0)).toEqual(0);
-    expect(fixed(0.00000058, 8)).toEqual(0.00000058);
+    expect(d(0.01).decimalPlaces()).toEqual(2);
+    expect(d(0.0054).decimalPlaces()).toEqual(4);
+    expect(d(0.9).decimalPlaces()).toEqual(1);
+    expect(d(0.0).decimalPlaces()).toEqual(0);
+    expect(d(2).decimalPlaces()).toEqual(0);
   });
 
   test('floor tests', () => {
-    expect(floor(0.01, 2)).toEqual(0.01);
-    expect(floor(0.000000019, 8)).toEqual(0.00000001);
-    expect(floor(0.011, 2)).toEqual(0.01);
-    expect(floor(0.019, 2)).toEqual(0.01);
-    expect(floor(0.019, 0)).toEqual(0);
+    expect(d(0.01).toFloor(2)).toEqual(d(0.01));
+    expect(d(0.000000019).toFloor(8)).toEqual(d(0.00000001));
+    expect(d(0.011).toFloor(2)).toEqual(d(0.01));
+    expect(d(0.019).toFloor(2)).toEqual(d(0.01));
+    expect(d(0.019).toFloor(0)).toEqual(d.Zero);
+    expect(d(0.01).toFloor(2)).toEqual(d(0.01));
+    expect(d(0.00000058).toFloor(8)).toEqual(d(0.00000058));
   });
 
   test('ceil tests', () => {
-    expect(ceil(0.01, 2)).toEqual(0.01);
-    expect(ceil(0.000000019, 8)).toEqual(0.00000002);
-    expect(ceil(0.011, 2)).toEqual(0.02);
-    expect(ceil(0.019, 2)).toEqual(0.02);
-    expect(ceil(0.019, 0)).toEqual(1);
+    expect(d(0.01).toCeil(2)).toEqual(d(0.01));
+    expect(d(0.000000019).toCeil(8)).toEqual(d(0.00000002));
+    expect(d(0.011).toCeil(2)).toEqual(d(0.02));
+    expect(d(0.019).toCeil(2)).toEqual(d(0.02));
+    expect(d(0.019).toCeil(0)).toEqual(d(1));
   });
 });

package/src/shared/decimals.ts

@@ -1,79 +1,46 @@
-/**
- * calculate the number of decimal places of a number
- * @param value
- * @returns a precision number of the value
- */
-export function precision(value: number) {
-  if (!isFinite(value)) {
-    return 0;
-  }
-
-  let e = 1;
-  let p = 0;
+import { Decimal } from 'decimal.js';
 
-  while (Math.round(value * e) / e !== value) {
-    e *= 10;
-    p++;
+declare module 'decimal.js' {
+  interface Decimal {
+    toFloor(decimalPlaces: number): Decimal;
+    toCeil(decimalPlaces: number): Decimal;
   }
-
-  return p;
 }
 
-/**
- * round down the number to the given precision
- * @param number
- * @param precision
- * @returns rounded down number
- */
-export function floor(number: number, precision: number): number {
-  const fixed = Math.pow(10, precision);
+Decimal.prototype.toFloor = function (decimalPlaces: number) {
+  return this.toDecimalPlaces(decimalPlaces, Decimal.ROUND_FLOOR);
+};
 
-  return Math.floor(number * fixed) / fixed;
-}
+Decimal.prototype.toCeil = function (decimalPlaces: number) {
+  return this.toDecimalPlaces(decimalPlaces, Decimal.ROUND_CEIL);
+};
 
-/**
- * round up the number to the given precision
- * @param number
- * @param precision
- * @returns rounded up number
- */
-export function ceil(number: number, precision: number): number {
-  const fixed = Math.pow(10, precision);
+export class decimal extends Decimal {}
 
-  return Math.ceil(number * fixed) / fixed;
+export function d(value: Decimal.Value) {
+  return new decimal(value);
 }
 
-/**
- * round the number to the given precision
- * @param number
- * @param precision
- * @returns rounded number
- */
-export function fixed(number: number, precision: number): number {
-  return (
-    Math.floor((number + Number.EPSILON) * Math.pow(10, precision)) /
-    Math.pow(10, precision)
-  );
-}
+d.Zero = new decimal(0);
 
-export function weightedMean(values: number[], weights: number[]) {
+export function weightedMean(values: decimal[], weights: decimal[]): decimal {
   const result = values
     .map((value, i) => {
       const weight = weights[i];
-      const sum = value * weight;
+      const sum = value.mul(weight);
       return [sum, weight];
     })
-    .reduce((p, c) => [p[0] + c[0], p[1] + c[1]], [0, 0]);
+    .reduce((p, c) => [p[0].add(c[0]), p[1].add(c[1])], [d.Zero, d.Zero]);
 
   if (!result[1]) {
-    return 0;
+    return d.Zero;
   }
 
-  return result[0] / result[1];
+  return result[0].div(result[1]);
 }
 
-export function pnl(entryRate: number, exitRate: number, amount: number) {
-  return (exitRate / entryRate - 1) * amount;
+export function pnl(entryRate: decimal, exitRate: decimal, amount: decimal) {
+  return exitRate.div(entryRate).minus(1).mul(amount);
 }
 
 /**

package/src/shared/index.ts

@@ -4,3 +4,4 @@ export * from './io';
 export * from './logger';
 export * from './policy';
 export * from './collections';
+export * from './pipe';

package/src/shared/pipe.ts

@@ -0,0 +1,12 @@
+import { filter, map, Observable } from 'rxjs';
+
+// tslint:disable-next-line: no-any
+type Constructor<T> = new (...args: any[]) => T;
+
+export function ofType<T extends K, K>(type: Constructor<T>) {
+  return (input: Observable<K>) =>
+    input.pipe(
+      filter(it => it instanceof type),
+      map(it => it as T)
+    );
+}