@quantform/core 0.3.214 → 0.3.220

package/src/adapter/paper/model/paper-model.ts

@@ -1,5 +1,5 @@
 import { tap } from 'rxjs/operators';
-import { Component, InstrumentSelector, Order, Orderbook } from '../../../domain';
+import { Component, InstrumentSelector, Order, Orderbook, Trade } from '../../../domain';
 import { PaperAdapter } from '..';
 import { Set } from 'typescript-collections';
 
@@ -15,35 +15,31 @@ export abstract class PaperModel {
   protected abstract onOrderCompleted(
     order: Order,
     averageExecutionRate: number,
-    orderbook: Orderbook
+    timestamp: number
   );
 
   protected abstract onOrderCanceled(order: Order);
 
   private intercept(component: Component) {
     if (component instanceof Orderbook) {
-      this.orderbook(component);
+      this.pendingOf(component.instrument).forEach(it =>
+        this.simulateOrderOnOrderbook(it, component)
+      );
+    } else if (component instanceof Trade) {
+      this.pendingOf(component.instrument).forEach(it =>
+        this.simulateOrderOnTrade(it, component)
+      );
     }
   }
 
-  protected orderbook(component: Orderbook) {
-    const pending = this.pendingOf(component.instrument);
-
-    if (pending.size() == 0) {
-      return;
-    }
-
-    pending.forEach(it => this.simulateOrder(it, component));
-  }
-
-  private simulateOrder(order: Order, orderbook: Orderbook) {
+  private simulateOrderOnOrderbook(order: Order, orderbook: Orderbook) {
     if (order.type == 'MARKET') {
       if (order.side == 'BUY' && orderbook.bestAskRate) {
         this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, orderbook.bestAskRate, orderbook);
+        this.onOrderCompleted(order, orderbook.bestAskRate, orderbook.timestamp);
       } else if (order.side == 'SELL' && orderbook.bestBidRate) {
         this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, orderbook.bestBidRate, orderbook);
+        this.onOrderCompleted(order, orderbook.bestBidRate, orderbook.timestamp);
       }
 
       return;
@@ -52,10 +48,31 @@ export abstract class PaperModel {
     if (order.type == 'LIMIT') {
       if (order.side == 'BUY' && order.rate >= orderbook.bestAskRate) {
         this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, orderbook.bestAskRate, orderbook);
+        this.onOrderCompleted(order, orderbook.bestAskRate, orderbook.timestamp);
       } else if (order.side == 'SELL' && order.rate <= orderbook.bestBidRate) {
         this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, orderbook.bestBidRate, orderbook);
+        this.onOrderCompleted(order, orderbook.bestBidRate, orderbook.timestamp);
+      }
+
+      return;
+    }
+  }
+
+  private simulateOrderOnTrade(order: Order, trade: Trade) {
+    if (order.type == 'MARKET') {
+      this.pendingOf(order.instrument).remove(order);
+      this.onOrderCompleted(order, trade.rate, trade.timestamp);
+
+      return;
+    }
+
+    if (order.type == 'LIMIT') {
+      if (order.side == 'BUY' && order.rate > trade.rate) {
+        this.pendingOf(order.instrument).remove(order);
+        this.onOrderCompleted(order, trade.rate, trade.timestamp);
+      } else if (order.side == 'SELL' && order.rate < trade.rate) {
+        this.pendingOf(order.instrument).remove(order);
+        this.onOrderCompleted(order, trade.rate, trade.timestamp);
       }
 
       return;

package/src/adapter/paper/model/paper-spot-model.ts

@@ -28,7 +28,7 @@ export class PaperSpotModel extends PaperModel {
     this.adapter.store.dispatch(new OrderPendingEvent(order.id, timestamp));
   }
 
-  onOrderCompleted(order: Order, averageExecutionRate: number, orderbook: Orderbook) {
+  onOrderCompleted(order: Order, averageExecutionRate: number, timestamp: timestamp) {
     const instrument =
       this.adapter.store.snapshot.universe.instrument[order.instrument.toString()];
     const transacted = {
@@ -53,10 +53,10 @@ export class PaperSpotModel extends PaperModel {
     }
 
     this.adapter.store.dispatch(
-      ...this.caluclateUnfreezAllocation(order, orderbook.timestamp),
-      new OrderFilledEvent(order.id, averageExecutionRate, orderbook.timestamp),
-      new BalanceTransactEvent(instrument.base, transacted.base, orderbook.timestamp),
-      new BalanceTransactEvent(instrument.quote, transacted.quote, orderbook.timestamp)
+      ...this.caluclateUnfreezAllocation(order, timestamp),
+      new OrderFilledEvent(order.id, averageExecutionRate, timestamp),
+      new BalanceTransactEvent(instrument.base, transacted.base, timestamp),
+      new BalanceTransactEvent(instrument.quote, transacted.quote, timestamp)
     );
   }
 

package/src/indicator/atr.ts

@@ -1,14 +1,19 @@
 import { Observable } from 'rxjs';
-import { share } from 'rxjs/operators';
+import { share, map } from 'rxjs/operators';
 import { Candle } from '../domain';
-import { rma, RMA } from './rma';
+import { rma } from './rma';
 import { truerange } from './truerange';
 
 export function atr<T>(length: number, fn: (it: T) => Candle) {
-  return function(source: Observable<T>): Observable<RMA> {
+  return function (source: Observable<T>): Observable<[T, number]> {
     return source.pipe(
       truerange(fn),
-      rma(length, it => it),
+      rma(length, ([, tr]) => tr),
+      map(([[it], truerange]) => {
+        const tuple: [T, number] = [it, truerange];
+
+        return tuple;
+      }),
       share()
     );
   };

package/src/indicator/donchian.ts

@@ -1,36 +1,36 @@
-import { Observable } from 'rxjs';
-import { filter, map, share } from 'rxjs/operators';
+import { Observable, withLatestFrom } from 'rxjs';
+import { map, share } from 'rxjs/operators';
+import { minMax } from './min-max';
 import { Candle } from '../domain';
-import { MinMax } from './min-max';
 
 export function donchian<T>(length: number, fn: (it: T) => Candle) {
-  return function (source: Observable<T>): Observable<{
-    timestamp: number;
-    upper: number;
-    middle: number;
-    lower: number;
-  }> {
-    const min = new MinMax(length);
-    const max = new MinMax(length);
-    let timestamp = 0;
+  return function (source: Observable<T>): Observable<
+    [
+      T,
+      {
+        upper: number;
+        lower: number;
+      }
+    ]
+  > {
+    source = source.pipe(share());
 
     return source.pipe(
-      filter(it => {
-        const candle = fn(it);
+      withLatestFrom(
+        source.pipe(minMax(length, it => fn(it).low)),
+        source.pipe(minMax(length, it => fn(it).high))
+      ),
+      map(([it, low, high]) => {
+        const tuple: [
+          T,
+          {
+            upper: number;
+            lower: number;
+          }
+        ] = [it, { lower: low[1].min, upper: high[1].max }];
 
-        timestamp = candle.timestamp;
-
-        min.append(candle.low);
-        max.append(candle.high);
-
-        return min.isCompleted && max.isCompleted;
+        return tuple;
       }),
-      map(() => ({
-        timestamp,
-        upper: max.max,
-        middle: (min.min + max.max) / 2,
-        lower: min.min
-      })),
       share()
     );
   };

package/src/indicator/ema.spec.ts

@@ -6,32 +6,13 @@ describe('ema tests', () => {
     let value;
 
     from([
-      212.8,
-      214.06,
-      213.89,
-      214.66,
-      213.95,
-      213.95,
-      214.55,
-      214.02,
-      214.51,
-      213.75,
-      214.22,
-      213.43,
-      214.21,
-      213.66,
-      215.03,
-      216.89,
-      216.66,
-      216.32,
-      214.98,
-      214.96,
-      215.05,
-      215.19
+      212.8, 214.06, 213.89, 214.66, 213.95, 213.95, 214.55, 214.02, 214.51, 213.75,
+      214.22, 213.43, 214.21, 213.66, 215.03, 216.89, 216.66, 216.32, 214.98, 214.96,
+      215.05, 215.19
     ])
       .pipe(ema(20, it => it))
       .subscribe({
-        next: it => (value = it.value),
+        next: ([, it]) => (value = it),
         complete: () => {
           expect(parseFloat(value.toFixed(4))).toBe(214.6336);
           done();

package/src/indicator/ema.ts

@@ -1,52 +1,25 @@
 import { Observable } from 'rxjs';
-import { filter, map, share } from 'rxjs/operators';
-import { SMA } from './sma';
-import { WindowIndicator } from './window-indicator';
-
-export class EMA extends WindowIndicator<number> {
-  private _alpha = 0;
-  private _sma: SMA;
-  private _value = null;
-
-  get value(): number {
-    return this._value;
-  }
-
-  constructor(capacity: number) {
-    super(capacity);
-
-    this._alpha = 2.0 / (capacity + 1);
-    this._sma = new SMA(capacity);
-  }
-
-  calculate(added: number) {
-    this._sma.append(added);
-
-    if (!this._sma.isCompleted) {
-      return;
-    }
-
-    if (!this.value) {
-      this._value = this._sma.value;
-    } else {
-      //this._value = (added - this._value) * this._alpha + this._value;
-
-      this._value = this._alpha * added + (1.0 - this._alpha) * this._value;
-    }
-  }
-}
+import { map, share } from 'rxjs/operators';
+import { sma } from './sma';
 
 export function ema<T>(length: number, fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<EMA> {
-    const indicator = new EMA(length);
+  return function (source: Observable<T>): Observable<[T, number]> {
+    const alpha = 2.0 / (length + 1);
+    let value: number = null;
 
     return source.pipe(
-      filter(it => {
-        indicator.append(fn(it));
+      sma(length, fn),
+      map(([it, sma]) => {
+        if (!value) {
+          value = sma;
+        } else {
+          value = alpha * fn(it) + (1.0 - alpha) * value;
+        }
+
+        const tuple: [T, number] = [it, value];
 
-        return indicator.isCompleted;
+        return tuple;
       }),
-      map(() => indicator),
       share()
     );
   };

package/src/indicator/envelope.ts

@@ -1,23 +1,17 @@
 import { Observable } from 'rxjs';
-import { filter, map, share } from 'rxjs/operators';
-import { SMA } from './sma';
+import { map, share } from 'rxjs/operators';
+import { sma } from './sma';
 
 export function envelope<T>(length: number, percent: number, valueFn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<{ min: number; max: number }> {
-    const indicator = new SMA(length);
-
+  return function (source: Observable<T>): Observable<{ min: number; max: number }> {
     return source.pipe(
-      filter(it => {
-        indicator.append(valueFn(it));
-
-        return indicator.isCompleted;
-      }),
-      map(it => {
-        const offset = (indicator.value * percent) / 100;
+      sma(length, valueFn),
+      map(([it, sma]) => {
+        const offset = (sma * percent) / 100;
 
         return {
-          min: indicator.value - offset,
-          max: indicator.value + offset
+          min: sma - offset,
+          max: sma + offset
         };
       }),
       share()

package/src/indicator/index.ts

@@ -10,7 +10,7 @@ export * from './swma';
 export * from './tma';
 export * from './trailing';
 export * from './truerange';
-export * from './window-indicator';
+export * from './window';
 export * from './wma';
 export * from './donchian';
 export * from './atr';

package/src/indicator/macd.ts

@@ -1,6 +1,6 @@
-import { Observable } from 'rxjs';
-import { filter, map, share } from 'rxjs/operators';
-import { EMA } from './ema';
+import { Observable, withLatestFrom } from 'rxjs';
+import { map, share } from 'rxjs/operators';
+import { ema } from './ema';
 
 export function macd<T>(
   fast: number,
@@ -8,24 +8,13 @@ export function macd<T>(
   length: number,
   fn: (it: T) => number
 ) {
-  return function(source: Observable<T>): Observable<number> {
-    const ema = {
-      fast: new EMA(fast),
-      slow: new EMA(slow),
-      macd: new EMA(length)
-    };
+  return function (source: Observable<T>): Observable<number> {
+    source = source.pipe(share());
 
     return source.pipe(
-      filter(it => {
-        const value = fn(it);
-
-        ema.fast.append(value);
-        ema.slow.append(value);
-        ema.macd.append(ema.fast.value - ema.slow.value);
-
-        return ema.macd.isCompleted;
-      }),
-      map(_ => ema.macd.value),
+      withLatestFrom(source.pipe(ema(fast, fn)), source.pipe(ema(slow, fn))),
+      ema(length, it => it[1][1] - it[2][1]),
+      map(([it, macd]) => macd),
       share()
     );
   };

package/src/indicator/min-max.ts

@@ -1,46 +1,24 @@
 import { Observable } from 'rxjs';
 import { filter, map, share } from 'rxjs/operators';
-import { RingBuffer } from './ring-buffer';
-import { WindowIndicator } from './window-indicator';
-
-export class MinMax extends WindowIndicator<number> {
-  private _min = 0;
-  private _max = 0;
-
-  get min(): number {
-    return this._min;
-  }
-
-  get max(): number {
-    return this._max;
-  }
-
-  constructor(capacity: number) {
-    super(capacity);
-  }
-
-  calculate(added: number, removed: number, buffer: RingBuffer<number>) {
-    this._min = added;
-    this._max = added;
-
-    buffer.forEach(it => {
-      this._min = Math.min(it, this._min);
-      this._max = Math.max(it, this._max);
-    });
-  }
-}
+import { window } from './window';
 
 export function minMax<T>(length: number, fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<MinMax> {
-    const indicator = new MinMax(length);
-
+  return function (source: Observable<T>): Observable<[T, { min: number; max: number }]> {
     return source.pipe(
-      filter(it => {
-        indicator.append(fn(it));
-
-        return indicator.isCompleted;
+      window(length, fn),
+      filter(([, buffer]) => buffer.isFull),
+      map(([it, buffer]) => {
+        let min = 0;
+        let max = 0;
+
+        buffer.forEach(it => {
+          min = Math.min(it, min);
+          max = Math.max(it, max);
+        });
+        const tuple: [T, { min: number; max: number }] = [it, { min, max }];
+
+        return tuple;
       }),
-      map(() => indicator),
       share()
     );
   };

package/src/indicator/rma.ts

@@ -1,52 +1,24 @@
 import { Observable } from 'rxjs';
-import { filter, map, share } from 'rxjs/operators';
-import { SMA } from '.';
-import { WindowIndicator } from './window-indicator';
-
-export class RMA extends WindowIndicator<number> {
-  private _alpha = 0;
-  private _sma: SMA;
-  private _value = null;
-
-  get value(): number {
-    return this._value;
-  }
-
-  constructor(capacity: number) {
-    super(capacity);
-
-    this._alpha = 1.0 / capacity;
-    this._sma = new SMA(capacity);
-  }
-
-  calculate(added: number) {
-    this._sma.append(added);
-
-    if (!this._sma.isCompleted) {
-      return;
-    }
-
-    if (!this.value) {
-      this._value = this._sma.value;
-    } else {
-      //this._value = (added - this._value) * this._alpha + this._value;
-
-      this._value = this._alpha * added + (1.0 - this._alpha) * this._value;
-    }
-  }
-}
+import { map, share } from 'rxjs/operators';
+import { sma } from '.';
 
 export function rma<T>(length: number, fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<RMA> {
-    const indicator = new RMA(length);
+  return function (source: Observable<T>): Observable<[T, number]> {
+    const alpha = 1.0 / length;
+    let value: number = null;
 
     return source.pipe(
-      filter(it => {
-        indicator.append(fn(it));
-
-        return indicator.isCompleted;
+      sma(length, fn),
+      map(([it, sma]) => {
+        if (!value) {
+          value = sma;
+        } else {
+          value = alpha * fn(it) + (1.0 - alpha) * value;
+        }
+
+        const tuple: [T, number] = [it, value];
+        return tuple;
       }),
-      map(() => indicator),
       share()
     );
   };

package/src/indicator/sma.spec.ts

@@ -9,7 +9,7 @@ describe('sma tests', () => {
     from([18136.17, 18092.15, 18082.39, 18065.4, 18046.47])
       .pipe(sma(5, it => it))
       .subscribe({
-        next: it => (value = it.value),
+        next: ([, it]) => (value = it),
         complete: () => {
           expect(parseFloat(value.toFixed(2))).toBe(18084.52);
           done();

package/src/indicator/sma.ts

@@ -1,39 +1,23 @@
-import { Observable } from 'rxjs';
+import { Observable, tap } from 'rxjs';
 import { filter, map, share } from 'rxjs/operators';
-import { RingBuffer } from './ring-buffer';
-import { WindowIndicator } from './window-indicator';
-
-export class SMA extends WindowIndicator<number> {
-  private _accmulated = 0;
-  private _value: number;
-
-  get value(): number {
-    return this._value;
-  }
-
-  constructor(capacity: number) {
-    super(capacity);
-  }
-
-  calculate(added: number, removed: number, buffer: RingBuffer<number>) {
-    this._accmulated += added;
-    this._accmulated -= removed;
-
-    this._value = this._accmulated / buffer.size;
-  }
-}
+import { window } from './window';
 
 export function sma<T>(length: number, fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<SMA> {
-    const indicator = new SMA(length);
+  return function (source: Observable<T>): Observable<[T, number]> {
+    let accumulated = 0;
 
     return source.pipe(
-      filter(it => {
-        indicator.append(fn(it));
+      window(length, fn),
+      tap(([, , added, removed]) => {
+        accumulated += added;
+        accumulated -= removed;
+      }),
+      filter(([, buffer]) => buffer.isFull),
+      map(([it, buffer]) => {
+        const tuple: [T, number] = [it, accumulated / buffer.size];
 
-        return indicator.isCompleted;
+        return tuple;
       }),
-      map(_ => indicator),
       share()
     );
   };

package/src/indicator/swma.ts

@@ -1,44 +1,23 @@
 import { Observable } from 'rxjs';
 import { filter, map, share } from 'rxjs/operators';
-import { RingBuffer } from './ring-buffer';
-import { WindowIndicator } from './window-indicator';
-
-export class SWMA extends WindowIndicator<number> {
-  private _value;
-
-  get value(): number {
-    return this._value;
-  }
-
-  constructor() {
-    super(4);
-  }
-
-  calculate(added: number, removed: number, buffer: RingBuffer<number>) {
-    if (!this.isCompleted) {
-      return;
-    }
-
-    const x3 = buffer.at(this.capacity - (3 + 1));
-    const x2 = buffer.at(this.capacity - (2 + 1));
-    const x1 = buffer.at(this.capacity - (1 + 1));
-    const x0 = buffer.at(this.capacity - (0 + 1));
-
-    this._value = (x3 * 1) / 6 + (x2 * 2) / 6 + (x1 * 2) / 6 + (x0 * 1) / 6;
-  }
-}
+import { window } from './window';
 
 export function swma<T>(fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<SWMA> {
-    const indicator = new SWMA();
-
+  return function (source: Observable<T>): Observable<[T, number]> {
     return source.pipe(
-      filter(it => {
-        indicator.append(fn(it));
-
-        return indicator.isCompleted;
+      window(4, fn),
+      filter(([, buffer]) => buffer.isFull),
+      map(([it, buffer]) => {
+        const x3 = buffer.at(buffer.capacity - (3 + 1));
+        const x2 = buffer.at(buffer.capacity - (2 + 1));
+        const x1 = buffer.at(buffer.capacity - (1 + 1));
+        const x0 = buffer.at(buffer.capacity - (0 + 1));
+
+        const value = (x3 * 1) / 6 + (x2 * 2) / 6 + (x1 * 2) / 6 + (x0 * 1) / 6;
+
+        const tuple: [T, number] = [it, value];
+        return tuple;
       }),
-      map(_ => indicator),
       share()
     );
   };

package/src/indicator/tma.spec.ts

@@ -9,7 +9,7 @@ describe('tma tests', () => {
     from([18086.36, 18116.15, 18127.81, 18136.17, 18092.15, 18082.39, 18065.4, 18046.47])
       .pipe(tma(4, it => it))
       .subscribe({
-        next: it => (value = it.value),
+        next: ([, it]) => (value = it),
         complete: () => {
           expect(parseFloat(value.toFixed(2))).toBe(18090.98);
           done();

package/src/indicator/tma.ts

@@ -1,13 +1,18 @@
 import { Observable } from 'rxjs';
-import { share } from 'rxjs/operators';
-import { SWMA, swma } from './swma';
+import { share, map } from 'rxjs/operators';
+import { swma } from './swma';
 import { wma } from './wma';
 
 export function tma<T>(length: number, fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<SWMA> {
+  return function (source: Observable<T>): Observable<[T, number]> {
     return source.pipe(
       wma(length, fn),
-      swma(it => it.value),
+      swma(([, it]) => it),
+      map(([[it], swma]) => {
+        const tuple: [T, number] = [it, swma];
+
+        return tuple;
+      }),
       share()
     );
   };