@quantform/core 0.3.214 → 0.3.220

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) {

package/src/session/session.ts

@@ -83,33 +83,38 @@ export class Session {
     await this.worker.wait();
   }
 
-  save(...measure: Measure[]) {
-    if (!this.descriptor?.measurement) {
+  statement(output: Record<string, any>) {
+    if (!this.behaviour?.statement) {
       return;
     }
 
-    this.worker.enqueue(() =>
-      this.descriptor.measurement.save(this.descriptor.id, measure)
-    );
+    this.behaviour.statement(output);
   }
 
-  query(params: { type: string; timestamp?: number }): Observable<Measure> {
-    return from(
+  useMeasure<T extends Measure>(
+    params: { type: string; timestamp?: number },
+    defaultValue: T = undefined
+  ) {
+    const query$ = from(
       this.descriptor.measurement.query(this.descriptor.id, {
         type: params.type,
         timestamp: params.timestamp ?? this.store.snapshot.timestamp,
         limit: 1,
         direction: 'BACKWARD'
       })
-    ).pipe(map(it => it[0]));
-  }
+    ).pipe(map(it => (it.length ? (it[0] as T) : defaultValue)));
 
-  statement(output: Record<string, any>) {
-    if (!this.behaviour?.statement) {
-      return;
-    }
+    const setter = (value: T) => {
+      this.worker.enqueue(() =>
+        this.descriptor.measurement.save(this.descriptor.id, [value])
+      );
+    };
 
-    this.behaviour.statement(output);
+    return [query$, setter];
+  }
+
+  useOptimizer(path: string): any {
+    return 0;
   }
 
   async subscribe(instrument: Array<InstrumentSelector>): Promise<void> {

package/src/store/event/store-candle.event.ts

@@ -1,5 +1,7 @@
+import { TradePatchEventHandler } from './store-trade.event';
 import { timestamp } from '../../common/datetime';
 import { InstrumentSelector } from '../../domain';
+import { State } from '../store.state';
 import { StoreEvent } from './store.event';
 
 export class CandleEvent implements StoreEvent {
@@ -16,3 +18,16 @@ export class CandleEvent implements StoreEvent {
     readonly timestamp: timestamp
   ) {}
 }
+
+export function CandleEventHandler(event: CandleEvent, state: State) {
+  return TradePatchEventHandler(
+    {
+      type: 'trade-patch',
+      instrument: event.instrument,
+      quantity: event.volume,
+      rate: event.close,
+      timestamp: event.timestamp
+    },
+    state
+  );
+}

package/src/store/store.ts

@@ -14,6 +14,8 @@ import {
   BalanceTransactEventHandler,
   BalanceUnfreezEvent,
   BalanceUnfreezEventHandler,
+  CandleEvent,
+  CandleEventHandler,
   InstrumentPatchEvent,
   InstrumentPatchEventHandler,
   InstrumentSubscriptionEvent,
@@ -222,4 +224,12 @@ export class Store extends Topic<StoreEvent, any> {
   onTradePatch(event: TradePatchEvent) {
     return TradePatchEventHandler(event, this.snapshot);
   }
+
+  /**
+   * @see CandleEventHandler
+   */
+  @handler(CandleEvent)
+  onCandle(event: CandleEvent) {
+    return CandleEventHandler(event, this.snapshot);
+  }
 }

package/dist/indicator/window-indicator.d.ts

@@ -1,10 +0,0 @@
-import { RingBuffer } from './ring-buffer';
-export declare abstract class WindowIndicator<T> {
-    private _buffer;
-    get capacity(): number;
-    get size(): number;
-    get isCompleted(): boolean;
-    constructor(capacity: number);
-    abstract calculate(added: T, removed: T, buffer: RingBuffer<T>): any;
-    append(value: T): void;
-}

package/dist/indicator/window-indicator.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WindowIndicator = void 0;
-const ring_buffer_1 = require("./ring-buffer");
-class WindowIndicator {
-    constructor(capacity) {
-        this._buffer = new ring_buffer_1.RingBuffer(capacity);
-    }
-    get capacity() {
-        return this._buffer.capacity;
-    }
-    get size() {
-        return this._buffer.size;
-    }
-    get isCompleted() {
-        return this._buffer.isFull;
-    }
-    append(value) {
-        let removed = null;
-        if (this.isCompleted) {
-            removed = this._buffer.peek();
-        }
-        this._buffer.enqueue(value);
-        this.calculate(value, removed, this._buffer);
-    }
-}
-exports.WindowIndicator = WindowIndicator;
-//# sourceMappingURL=window-indicator.js.map

package/dist/indicator/window-indicator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-indicator.js","sourceRoot":"","sources":["../../src/indicator/window-indicator.ts"],"names":[],"mappings":";;;AAAA,+CAA2C;AAE3C,MAAsB,eAAe;IAenC,YAAY,QAAgB;QAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,wBAAU,CAAI,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAdD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;IAC/B,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3B,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAC7B,CAAC;IAQM,MAAM,CAAC,KAAQ;QACpB,IAAI,OAAO,GAAG,IAAI,CAAC;QAEnB,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAC/B;QAED,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAE5B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/C,CAAC;CACF;AAhCD,0CAgCC"}

package/src/indicator/window-indicator.ts

@@ -1,35 +0,0 @@
-import { RingBuffer } from './ring-buffer';
-
-export abstract class WindowIndicator<T> {
-  private _buffer: RingBuffer<T>;
-
-  get capacity(): number {
-    return this._buffer.capacity;
-  }
-
-  get size(): number {
-    return this._buffer.size;
-  }
-
-  get isCompleted(): boolean {
-    return this._buffer.isFull;
-  }
-
-  constructor(capacity: number) {
-    this._buffer = new RingBuffer<T>(capacity);
-  }
-
-  abstract calculate(added: T, removed: T, buffer: RingBuffer<T>);
-
-  public append(value: T) {
-    let removed = null;
-
-    if (this.isCompleted) {
-      removed = this._buffer.peek();
-    }
-
-    this._buffer.enqueue(value);
-
-    this.calculate(value, removed, this._buffer);
-  }
-}