@quantform/core 0.3.217 → 0.3.222

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()
     );
   };

package/src/indicator/truerange.spec.ts

@@ -18,10 +18,10 @@ describe('truerange atr tests', () => {
     ])
       .pipe(
         truerange(it => it),
-        sma(4, it => it)
+        sma(4, ([, it]) => it)
       )
       .subscribe({
-        next: it => (value = it.value),
+        next: ([, it]) => (value = it),
         complete: () => {
           expect(parseFloat(value.toFixed(2))).toBe(42.41);
           done();

package/src/indicator/truerange.ts

@@ -3,22 +3,27 @@ import { map, share } from 'rxjs/operators';
 import { Candle } from '../domain';
 
 export function truerange<T>(fn: (it: T) => Candle) {
-  return function(source: Observable<T>): Observable<number> {
+  return function (source: Observable<T>): Observable<[T, number]> {
     let previous;
 
     return source.pipe(
       map(it => {
         const current = fn(it);
 
-        return previous == null
-          ? current.high - current.low
-          : Math.max(
-              Math.max(
-                current.high - current.low,
-                Math.abs(current.high - previous.close)
-              ),
-              Math.abs(current.low - previous.close)
-            );
+        const value =
+          previous == null
+            ? current.high - current.low
+            : Math.max(
+                Math.max(
+                  current.high - current.low,
+                  Math.abs(current.high - previous.close)
+                ),
+                Math.abs(current.low - previous.close)
+              );
+
+        const tuple: [T, number] = [it, value];
+
+        return tuple;
       }),
       share()
     );

package/src/indicator/window.ts

@@ -0,0 +1,27 @@
+import { Observable, share, map } 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]> {
+    const buffer = new RingBuffer<Y>(length);
+
+    return source.pipe(
+      map(it => {
+        let removed = null;
+
+        if (buffer.isFull) {
+          removed = buffer.peek();
+        }
+
+        const value = fn(it);
+
+        buffer.enqueue(value);
+
+        const tuple: [T, RingBuffer<Y>, Y, Y] = [it, buffer, value, removed];
+
+        return tuple;
+      }),
+      share()
+    );
+  };
+}

package/src/indicator/wma.spec.ts

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

package/src/indicator/wma.ts

@@ -1,55 +1,27 @@
 import { Observable } from 'rxjs';
 import { filter, map, share } from 'rxjs/operators';
-import { RingBuffer } from './ring-buffer';
-import { SMA } from './sma';
-import { WindowIndicator } from './window-indicator';
+import { window } from './window';
 
-export class WMA extends WindowIndicator<number> {
-  private _k = 0;
-  private _sma: SMA;
-  private _value: number;
-
-  get value(): number {
-    return this._value;
-  }
-
-  constructor(capacity: number) {
-    super(capacity);
-
-    this._k = 1.0 / capacity;
-    this._sma = new SMA(capacity);
-  }
-
-  calculate(added: number, removed: number, buffer: RingBuffer<number>) {
-    if (!this.isCompleted) {
-      return;
-    }
-
-    let norm = 0.0;
-    let sum = 0.0;
-
-    for (let i = 0; i < this.capacity; i++) {
-      const weight = (this.capacity - i) * this.capacity;
-      norm = norm + weight;
-
-      sum = sum + buffer.at(this.capacity - (i + 1)) * weight;
-    }
+export function wma<T>(length: number, fn: (it: T) => number) {
+  return function (source: Observable<T>): Observable<[T, number]> {
+    return source.pipe(
+      window(length, fn),
+      filter(([, buffer]) => buffer.isFull),
+      map(([it, buffer]) => {
+        let norm = 0.0;
+        let sum = 0.0;
 
-    this._value = sum / norm;
-  }
-}
+        for (let i = 0; i < buffer.capacity; i++) {
+          const weight = (buffer.capacity - i) * buffer.capacity;
 
-export function wma<T>(length: number, fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<WMA> {
-    const indicator = new WMA(length);
+          norm = norm + weight;
+          sum = sum + buffer.at(buffer.capacity - (i + 1)) * weight;
+        }
 
-    return source.pipe(
-      filter(it => {
-        indicator.append(fn(it));
+        const tuple: [T, number] = [it, sum / norm];
 
-        return indicator.isCompleted;
+        return tuple;
       }),
-      map(_ => indicator),
       share()
     );
   };

package/src/session/session-descriptor.ts

@@ -24,7 +24,5 @@ export interface SessionDescriptor {
    */
   measurement?: Measurement;
 
-  template?: string;
-
   behaviour?: Behaviour | Behaviour[] | ((session: Session) => Observable<any>);
 }

package/src/session/session-optimizer.ts

@@ -1,5 +1,5 @@
 export function fit(key: string, generator?: any[]) {
-  return function(target: any, propertyKey: string) {
+  return function (target: any, propertyKey: string) {
     let defaultSetterValue;
 
     if (generator) {