@quantform/core 0.5.13 → 0.5.23

package/src/domain/trade.operator.ts

@@ -0,0 +1,15 @@
+import { filter, map, Observable, startWith } from 'rxjs';
+
+import { State } from '../store';
+import { Component } from './component';
+import { InstrumentSelector } from './instrument';
+import { Trade } from './trade';
+
+export function trade(selector: InstrumentSelector, state: State) {
+  return (source$: Observable<Component>) =>
+    source$.pipe(
+      startWith(state.trade.get(selector.id)),
+      filter(it => it instanceof Trade && it.instrument.id == selector.id),
+      map(it => it as Trade)
+    );
+}

package/src/domain/trade.spec.ts

@@ -0,0 +1,17 @@
+import { Asset } from './asset';
+import { Instrument } from './instrument';
+import { Trade } from './trade';
+
+describe('Trade', () => {
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
+
+  test('should construct an empty trade', () => {
+    const sut = new Trade(instrument);
+
+    expect(sut.id).toEqual(instrument.id);
+  });
+});

package/src/domain/trade.ts

@@ -1,4 +1,4 @@
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 import { Instrument } from '.';
 import { Component } from './component';
 
@@ -7,12 +7,15 @@ import { Component } from './component';
  * and seller of the same asset.
  */
 export class Trade implements Component {
+  id: string;
   kind = 'trade';
   timestamp: timestamp;
-  rate: number;
-  quantity: number;
+  rate: decimal;
+  quantity: decimal;
 
-  constructor(public readonly instrument: Instrument) {}
+  constructor(public readonly instrument: Instrument) {
+    this.id = instrument.id;
+  }
 
   toString() {
     return this.instrument.toString();

package/src/indicator/atr.ts

@@ -1,16 +1,17 @@
 import { map, Observable, share } from 'rxjs';
 
 import { Candle } from '../domain';
+import { decimal } from '../shared';
 import { rma } from './rma';
-import { truerange } from './truerange';
+import { trueRange } from './true-range';
 
 export function atr<T>(length: number, fn: (it: T) => Candle) {
-  return function (source: Observable<T>): Observable<[T, number]> {
+  return function (source: Observable<T>): Observable<[T, decimal]> {
     return source.pipe(
-      truerange(fn),
+      trueRange(fn),
       rma(length, ([, tr]) => tr),
-      map(([[it], truerange]) => {
-        const tuple: [T, number] = [it, truerange];
+      map(([[it], tr]) => {
+        const tuple: [T, decimal] = [it, tr];
 
         return tuple;
       }),

package/src/indicator/cross.spec.ts

@@ -1,39 +1,36 @@
-import { from } from 'rxjs';
+import { from, map } from 'rxjs';
 
-import { crossover, crossunder } from './cross';
+import { d } from '../shared';
+import { crossOver, crossUnder } from './cross';
 
-describe('crossunder tests', () => {
-  test('should crossunder uptrend once', done => {
+describe('crossUnder', () => {
+  test('should crossUnder uptrend once', done => {
     from([1, 2, 3, 4, 5])
       .pipe(
-        crossunder(
-          () => 3,
-          it => it
-        )
+        map(it => d(it)),
+        crossUnder(d(3), it => it)
       )
       .subscribe({
-        next: it => expect(it).toBe(4),
+        next: it => expect(it).toEqual(d(4)),
         complete: done()
       });
   });
 
-  test('should crossunder uptrend twice', done => {
+  test('should crossUnder uptrend twice', done => {
     let crosses = 0;
 
     from([1, 2, 3, 4, 5, 4, 2, 3, 3, 3, 4, 5])
       .pipe(
-        crossunder(
-          () => 3,
-          it => it
-        )
+        map(it => d(it)),
+        crossUnder(d(3), it => it)
       )
       .subscribe({
         next: it => {
-          expect(it).toBe(4);
+          expect(it).toEqual(d(4));
           crosses++;
         },
         complete: () => {
-          expect(crosses).toBe(2);
+          expect(crosses).toEqual(2);
           done();
         }
       });
@@ -44,18 +41,16 @@ describe('crossunder tests', () => {
 
     from([1, 2, 3, 4, 5, 4, 3, 3, 4, 5])
       .pipe(
-        crossunder(
-          () => 3,
-          it => it
-        )
+        map(it => d(it)),
+        crossUnder(d(3), it => it)
       )
       .subscribe({
         next: it => {
-          expect(it).toBe(4);
+          expect(it).toEqual(d(4));
           crosses++;
         },
         complete: () => {
-          expect(crosses).toBe(1);
+          expect(crosses).toEqual(1);
           done();
         }
       });
@@ -64,10 +59,8 @@ describe('crossunder tests', () => {
   test('should not cross downtrend', done => {
     from([5, 4, 3, 2, 1])
       .pipe(
-        crossunder(
-          () => 3,
-          it => it
-        )
+        map(it => d(it)),
+        crossUnder(d(3), it => it)
       )
       .subscribe({
         next: () => fail(),
@@ -76,17 +69,15 @@ describe('crossunder tests', () => {
   });
 });
 
-describe('crossover tests', () => {
+describe('crossover', () => {
   test('should crossover downtrend once', done => {
     from([5, 4, 3, 2, 1])
       .pipe(
-        crossover(
-          () => 3,
-          it => it
-        )
+        map(it => d(it)),
+        crossOver(d(3), it => it)
       )
       .subscribe({
-        next: it => expect(it).toBe(2),
+        next: it => expect(it).toEqual(d(2)),
         complete: done()
       });
   });
@@ -96,18 +87,16 @@ describe('crossover tests', () => {
 
     from([5, 4, 3, 2, 1, 2, 2, 3, 4, 4, 2, 3])
       .pipe(
-        crossover(
-          () => 3,
-          it => it
-        )
+        map(it => d(it)),
+        crossOver(d(3), it => it)
       )
       .subscribe({
         next: it => {
-          expect(it).toBe(2);
+          expect(it).toEqual(d(2));
           crosses++;
         },
         complete: () => {
-          expect(crosses).toBe(2);
+          expect(crosses).toEqual(2);
           done();
         }
       });
@@ -118,18 +107,16 @@ describe('crossover tests', () => {
 
     from([5, 4, 3, 2, 1, 2, 3, 3, 4, 5])
       .pipe(
-        crossover(
-          () => 3,
-          it => it
-        )
+        map(it => d(it)),
+        crossOver(d(3), it => it)
       )
       .subscribe({
         next: it => {
-          expect(it).toBe(2);
+          expect(it).toEqual(d(2));
           crosses++;
         },
         complete: () => {
-          expect(crosses).toBe(1);
+          expect(crosses).toEqual(1);
           done();
         }
       });
@@ -138,10 +125,8 @@ describe('crossover tests', () => {
   test('should not cross uptrend', done => {
     from([1, 2, 3, 4, 5])
       .pipe(
-        crossover(
-          () => 3,
-          it => it
-        )
+        map(it => d(it)),
+        crossOver(d(3), it => it)
       )
       .subscribe({
         next: () => fail(),

package/src/indicator/cross.ts

@@ -1,19 +1,24 @@
 import { filter, Observable } from 'rxjs';
 
-export function crossunder<T>(limitFn: (it: T) => number, currentFn: (it: T) => number) {
+import { decimal } from '../shared';
+
+export function crossUnder<T>(
+  trigger: decimal | ((it: T) => decimal),
+  value: (it: T) => decimal
+) {
   return function (source: Observable<T>): Observable<T> {
     let triggered = false;
 
     return source.pipe(
       filter(it => {
-        const limit = limitFn(it);
-        const current = currentFn(it);
+        const limit = typeof trigger == 'function' ? trigger(it) : trigger;
+        const current = value(it);
 
-        if (current < limit) {
+        if (current.lessThan(limit)) {
           triggered = true;
         }
 
-        if (triggered && current > limit) {
+        if (triggered && current.greaterThan(limit)) {
           triggered = false;
 
           return true;
@@ -25,20 +30,23 @@ export function crossunder<T>(limitFn: (it: T) => number, currentFn: (it: T) =>
   };
 }
 
-export function crossover<T>(limitFn: (it: T) => number, currentFn: (it: T) => number) {
+export function crossOver<T>(
+  trigger: decimal | ((it: T) => decimal),
+  value: (it: T) => decimal
+) {
   return function (source: Observable<T>): Observable<T> {
     let triggered = false;
 
     return source.pipe(
       filter(it => {
-        const limit = limitFn(it);
-        const current = currentFn(it);
+        const limit = typeof trigger == 'function' ? trigger(it) : trigger;
+        const current = value(it);
 
-        if (current > limit) {
+        if (current.greaterThan(limit)) {
           triggered = true;
         }
 
-        if (triggered && current < limit) {
+        if (triggered && current.lessThan(limit)) {
           triggered = false;
 
           return true;

package/src/indicator/donchian.ts

@@ -1,6 +1,7 @@
 import { map, Observable, share, withLatestFrom } from 'rxjs';
 
 import { Candle } from '../domain';
+import { decimal } from '../shared';
 import { minMax } from './min-max';
 
 export function donchian<T>(length: number, fn: (it: T) => Candle) {
@@ -8,8 +9,8 @@ export function donchian<T>(length: number, fn: (it: T) => Candle) {
     [
       T,
       {
-        upper: number;
-        lower: number;
+        upper: decimal;
+        lower: decimal;
       }
     ]
   > {
@@ -24,8 +25,8 @@ export function donchian<T>(length: number, fn: (it: T) => Candle) {
         const tuple: [
           T,
           {
-            upper: number;
-            lower: number;
+            upper: decimal;
+            lower: decimal;
           }
         ] = [it, { lower: low[1].min, upper: high[1].max }];
 

package/src/indicator/drawdown.ts

@@ -1,9 +1,11 @@
 import { map, Observable, share } from 'rxjs';
 
-export function drawdown<T>(fn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<number> {
-    let rate;
-    let max = 0;
+import { d, decimal } from '../shared';
+
+export function drawdown<T>(fn: (it: T) => decimal) {
+  return function (source: Observable<T>): Observable<decimal> {
+    let rate: decimal;
+    let max = d.Zero;
 
     return source.pipe(
       map(it => {
@@ -15,7 +17,7 @@ export function drawdown<T>(fn: (it: T) => number) {
           if (value > rate) {
             rate = value;
           } else if (value < rate) {
-            max = Math.min(max, value / rate - 1);
+            max = decimal.min(max, value.div(rate).minus(1));
           }
         }
 

package/src/indicator/ema.spec.ts

@@ -1,21 +1,22 @@
 import { from } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { ema } from './ema';
 
-describe('ema tests', () => {
+describe('ema', () => {
   test('should return expected value', done => {
-    let value;
+    let value: decimal;
 
     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
     ])
-      .pipe(ema(20, it => it))
+      .pipe(ema(20, it => d(it)))
       .subscribe({
         next: ([, it]) => (value = it),
         complete: () => {
-          expect(parseFloat(value.toFixed(4))).toBe(214.6336);
+          expect(value.toDecimalPlaces(4)).toEqual(d(214.6336));
           done();
         }
       });

package/src/indicator/ema.ts

@@ -1,11 +1,12 @@
 import { map, Observable, share } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { sma } from './sma';
 
-export function ema<T>(length: number, fn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<[T, number]> {
-    const alpha = 2.0 / (length + 1);
-    let value: number = null;
+export function ema<T>(length: number, fn: (it: T) => decimal) {
+  return function (source: Observable<T>): Observable<[T, decimal]> {
+    const alpha = d(2.0).div(d(length + 1));
+    let value: decimal = null;
 
     return source.pipe(
       sma(length, fn),
@@ -13,10 +14,10 @@ export function ema<T>(length: number, fn: (it: T) => number) {
         if (!value) {
           value = sma;
         } else {
-          value = alpha * fn(it) + (1.0 - alpha) * value;
+          value = alpha.mul(fn(it)).plus(d(1.0).minus(alpha).mul(value));
         }
 
-        const tuple: [T, number] = [it, value];
+        const tuple: [T, decimal] = [it, value];
 
         return tuple;
       }),

package/src/indicator/envelope.ts

@@ -1,17 +1,22 @@
 import { map, Observable, share } from 'rxjs';
 
+import { decimal } from '../shared';
 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 }> {
+export function envelope<T>(
+  length: number,
+  percent: number,
+  valueFn: (it: T) => decimal
+) {
+  return function (source: Observable<T>): Observable<{ min: decimal; max: decimal }> {
     return source.pipe(
       sma(length, valueFn),
-      map(([it, sma]) => {
-        const offset = (sma * percent) / 100;
+      map(([, sma]) => {
+        const offset = sma.mul(percent).div(100);
 
         return {
-          min: sma - offset,
-          max: sma + offset
+          min: sma.minus(offset),
+          max: sma.add(offset)
         };
       }),
       share()

package/src/indicator/index.ts

@@ -12,6 +12,6 @@ export * from './sma';
 export * from './swma';
 export * from './tma';
 export * from './trailing';
-export * from './truerange';
+export * from './true-range';
 export * from './window';
 export * from './wma';

package/src/indicator/macd.ts

@@ -1,20 +1,21 @@
 import { map, Observable, share, withLatestFrom } from 'rxjs';
 
+import { decimal } from '../shared';
 import { ema } from './ema';
 
 export function macd<T>(
   fast: number,
   slow: number,
   length: number,
-  fn: (it: T) => number
+  fn: (it: T) => decimal
 ) {
-  return function (source: Observable<T>): Observable<number> {
+  return function (source: Observable<T>): Observable<decimal> {
     source = source.pipe(share());
 
     return source.pipe(
       withLatestFrom(source.pipe(ema(fast, fn)), source.pipe(ema(slow, fn))),
-      ema(length, it => it[1][1] - it[2][1]),
-      map(([it, macd]) => macd),
+      ema(length, it => it[1][1].minus(it[2][1])),
+      map(([, macd]) => macd),
       share()
     );
   };

package/src/indicator/min-max.ts

@@ -1,21 +1,24 @@
 import { filter, map, Observable, share } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { window } from './window';
 
-export function minMax<T>(length: number, fn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<[T, { min: number; max: number }]> {
+export function minMax<T>(length: number, fn: (it: T) => decimal) {
+  return function (
+    source: Observable<T>
+  ): Observable<[T, { min: decimal; max: decimal }]> {
     return source.pipe(
       window(length, fn),
       filter(([, buffer]) => buffer.isFull),
       map(([it, buffer]) => {
-        let min = 0;
-        let max = 0;
+        let min = d.Zero;
+        let max = d.Zero;
 
         buffer.forEach(it => {
-          min = Math.min(it, min);
-          max = Math.max(it, max);
+          min = decimal.min(it, min);
+          max = decimal.max(it, max);
         });
-        const tuple: [T, { min: number; max: number }] = [it, { min, max }];
+        const tuple: [T, { min: decimal; max: decimal }] = [it, { min, max }];
 
         return tuple;
       }),

package/src/indicator/rma.ts

@@ -1,11 +1,12 @@
 import { map, Observable, share } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { sma } from '.';
 
-export function rma<T>(length: number, fn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<[T, number]> {
-    const alpha = 1.0 / length;
-    let value: number = null;
+export function rma<T>(length: number, fn: (it: T) => decimal) {
+  return function (source: Observable<T>): Observable<[T, decimal]> {
+    const alpha = d(1.0).div(length);
+    let value: decimal = null;
 
     return source.pipe(
       sma(length, fn),
@@ -13,10 +14,10 @@ export function rma<T>(length: number, fn: (it: T) => number) {
         if (!value) {
           value = sma;
         } else {
-          value = alpha * fn(it) + (1.0 - alpha) * value;
+          value = alpha.mul(fn(it)).plus(d(1.0).minus(alpha).mul(value));
         }
 
-        const tuple: [T, number] = [it, value];
+        const tuple: [T, decimal] = [it, value];
         return tuple;
       }),
       share()

package/src/indicator/sma.spec.ts

@@ -1,18 +1,19 @@
 import { from } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { sma } from './sma';
 
-describe('sma tests', () => {
+describe('sma', () => {
   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])
-      .pipe(sma(5, it => it))
+      .pipe(sma(5, it => d(it)))
       .subscribe({
         next: ([, it]) => (value = it),
         complete: () => {
-          expect(parseFloat(value.toFixed(2))).toBe(18084.52);
+          expect(value.toDecimalPlaces(2)).toEqual(d(18084.52));
           done();
         }
       });

package/src/indicator/sma.ts

@@ -1,20 +1,21 @@
 import { filter, map, Observable, share, tap } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { window } from './window';
 
-export function sma<T>(length: number, fn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<[T, number]> {
-    let accumulated = 0;
+export function sma<T>(length: number, fn: (it: T) => decimal) {
+  return function (source: Observable<T>): Observable<[T, decimal]> {
+    let accumulated = d.Zero;
 
     return source.pipe(
       window(length, fn),
-      tap(([, , added, removed]) => {
-        accumulated += added;
-        accumulated -= removed;
-      }),
+      tap(
+        ([, , added, removed]) =>
+          (accumulated = accumulated.add(added).minus(removed ?? 0))
+      ),
       filter(([, buffer]) => buffer.isFull),
       map(([it, buffer]) => {
-        const tuple: [T, number] = [it, accumulated / buffer.size];
+        const tuple: [T, decimal] = [it, accumulated.div(buffer.size)];
 
         return tuple;
       }),

package/src/indicator/swma.ts

@@ -1,9 +1,10 @@
 import { filter, map, Observable, share } from 'rxjs';
 
+import { d, decimal } from '../shared';
 import { window } from './window';
 
-export function swma<T>(fn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<[T, number]> {
+export function swma<T>(fn: (it: T) => decimal) {
+  return function (source: Observable<T>): Observable<[T, decimal]> {
     return source.pipe(
       window(4, fn),
       filter(([, buffer]) => buffer.isFull),
@@ -13,9 +14,12 @@ export function swma<T>(fn: (it: T) => number) {
         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 value = d.Zero.plus(x3.mul(1).div(6))
+          .plus(x2.mul(2).div(6))
+          .plus(x1.mul(2).div(6))
+          .plus(x0.mul(1).div(6));
 
-        const tuple: [T, number] = [it, value];
+        const tuple: [T, decimal] = [it, value];
         return tuple;
       }),
       share()

package/src/indicator/tma.spec.ts

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