@quantform/core 0.5.15 → 0.6.4

package/src/domain/candle.operator.spec.ts

@@ -1,125 +0,0 @@
-import { from } from 'rxjs';
-
-import { Candle } from './candle';
-import { candle, candleCompleted, mergeCandle } from './candle.operator';
-
-describe('candle', () => {
-  test('should aggregate and pipe candle updates', done => {
-    const input$ = from([
-      { timestamp: 1, rate: 1 },
-      { timestamp: 2, rate: 2 },
-      { timestamp: 3, rate: 3 },
-      { timestamp: 4, rate: 0 },
-      { timestamp: 5, rate: 7 },
-      { timestamp: 6, rate: 8 }
-    ]);
-
-    const output = [
-      { timestamp: 0, open: 1, high: 1, low: 1, close: 1 },
-      { timestamp: 0, open: 1, high: 2, low: 1, close: 2 },
-      { timestamp: 0, open: 1, high: 3, low: 1, close: 3 },
-      { timestamp: 0, open: 1, high: 3, low: 0, close: 0 },
-      { timestamp: 5, open: 0, high: 7, low: 7, close: 7 },
-      { timestamp: 5, open: 0, high: 8, low: 7, close: 8 }
-    ].reverse();
-
-    input$.pipe(candle(5, it => it.rate)).subscribe({
-      next: it => {
-        expect(it).toEqual(output.pop());
-        if (output.length === 0) {
-          done();
-        }
-      }
-    });
-  });
-});
-
-describe('candleCompleted', () => {
-  test('should aggregate and pipe distinct completed candles', done => {
-    const input$ = from([
-      { timestamp: 1, rate: 1 },
-      { timestamp: 2, rate: 2 },
-      { timestamp: 3, rate: 3 },
-      { timestamp: 4, rate: 0 },
-      { timestamp: 5, rate: 7 },
-      { timestamp: 6, rate: 8 }
-    ]);
-
-    input$
-      .pipe(
-        candle(5, it => it.rate),
-        candleCompleted()
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toEqual({ timestamp: 0, open: 1, high: 3, low: 0, close: 0 });
-          done();
-        }
-      });
-  });
-});
-
-describe('mergeCandle', () => {
-  test('should pipe and merge candle from history', done => {
-    const history$ = from([
-      new Candle(1, 1, 1.5, 0.5, 2),
-      new Candle(2, 2, 2.5, 1.5, 3),
-      new Candle(3, 3, 3.5, 2.5, 4)
-    ]);
-
-    const input$ = from([
-      { timestamp: 3, rate: 5 },
-      { timestamp: 4, rate: 3 },
-      { timestamp: 5, rate: 4 }
-    ]);
-
-    const output = [
-      { timestamp: 1, open: 1, high: 1.5, low: 0.5, close: 2 },
-      { timestamp: 2, open: 2, high: 2.5, low: 1.5, close: 3 },
-      { timestamp: 3, open: 3, high: 5, low: 2.5, close: 5 },
-      { timestamp: 4, open: 5, high: 3, low: 3, close: 3 },
-      { timestamp: 5, open: 3, high: 4, low: 4, close: 4 }
-    ].reverse();
-
-    input$.pipe(mergeCandle(1, it => it.rate, history$)).subscribe({
-      next: it => {
-        expect(it).toEqual(output.pop());
-        if (output.length === 0) {
-          done();
-        }
-      }
-    });
-  });
-
-  test('should pipe and not merge candle from history', done => {
-    const history$ = from([
-      new Candle(1, 1, 1.5, 0.5, 2),
-      new Candle(2, 2, 2.5, 1.5, 3),
-      new Candle(3, 3, 3.5, 2.5, 4)
-    ]);
-
-    const input$ = from([
-      { timestamp: 4, rate: 5 },
-      { timestamp: 5, rate: 3 },
-      { timestamp: 6, rate: 4 }
-    ]);
-
-    const output = [
-      { timestamp: 1, open: 1, high: 1.5, low: 0.5, close: 2 },
-      { timestamp: 2, open: 2, high: 2.5, low: 1.5, close: 3 },
-      { timestamp: 3, open: 3, high: 3.5, low: 2.5, close: 4 },
-      { timestamp: 4, open: 4, high: 5, low: 5, close: 5 },
-      { timestamp: 5, open: 5, high: 3, low: 3, close: 3 },
-      { timestamp: 6, open: 3, high: 4, low: 4, close: 4 }
-    ].reverse();
-
-    input$.pipe(mergeCandle(1, it => it.rate, history$)).subscribe({
-      next: it => {
-        expect(it).toEqual(output.pop());
-        if (output.length === 0) {
-          done();
-        }
-      }
-    });
-  });
-});

package/src/indicator/atr.ts

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

package/src/indicator/cross.spec.ts

@@ -1,151 +0,0 @@
-import { from } from 'rxjs';
-
-import { crossover, crossunder } from './cross';
-
-describe('crossunder', () => {
-  test('should crossunder uptrend once', done => {
-    from([1, 2, 3, 4, 5])
-      .pipe(
-        crossunder(
-          () => 3,
-          it => it
-        )
-      )
-      .subscribe({
-        next: it => expect(it).toBe(4),
-        complete: 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
-        )
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toBe(4);
-          crosses++;
-        },
-        complete: () => {
-          expect(crosses).toBe(2);
-          done();
-        }
-      });
-  });
-
-  test('should not cross bounce', done => {
-    let crosses = 0;
-
-    from([1, 2, 3, 4, 5, 4, 3, 3, 4, 5])
-      .pipe(
-        crossunder(
-          () => 3,
-          it => it
-        )
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toBe(4);
-          crosses++;
-        },
-        complete: () => {
-          expect(crosses).toBe(1);
-          done();
-        }
-      });
-  });
-
-  test('should not cross downtrend', done => {
-    from([5, 4, 3, 2, 1])
-      .pipe(
-        crossunder(
-          () => 3,
-          it => it
-        )
-      )
-      .subscribe({
-        next: () => fail(),
-        complete: done()
-      });
-  });
-});
-
-describe('crossover', () => {
-  test('should crossover downtrend once', done => {
-    from([5, 4, 3, 2, 1])
-      .pipe(
-        crossover(
-          () => 3,
-          it => it
-        )
-      )
-      .subscribe({
-        next: it => expect(it).toBe(2),
-        complete: done()
-      });
-  });
-
-  test('should crossover downtrend twice', done => {
-    let crosses = 0;
-
-    from([5, 4, 3, 2, 1, 2, 2, 3, 4, 4, 2, 3])
-      .pipe(
-        crossover(
-          () => 3,
-          it => it
-        )
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toBe(2);
-          crosses++;
-        },
-        complete: () => {
-          expect(crosses).toBe(2);
-          done();
-        }
-      });
-  });
-
-  test('should not cross bounce', done => {
-    let crosses = 0;
-
-    from([5, 4, 3, 2, 1, 2, 3, 3, 4, 5])
-      .pipe(
-        crossover(
-          () => 3,
-          it => it
-        )
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toBe(2);
-          crosses++;
-        },
-        complete: () => {
-          expect(crosses).toBe(1);
-          done();
-        }
-      });
-  });
-
-  test('should not cross uptrend', done => {
-    from([1, 2, 3, 4, 5])
-      .pipe(
-        crossover(
-          () => 3,
-          it => it
-        )
-      )
-      .subscribe({
-        next: () => fail(),
-        complete: done()
-      });
-  });
-});

package/src/indicator/cross.ts

@@ -1,51 +0,0 @@
-import { filter, Observable } from 'rxjs';
-
-export function crossunder<T>(limitFn: (it: T) => number, currentFn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<T> {
-    let triggered = false;
-
-    return source.pipe(
-      filter(it => {
-        const limit = limitFn(it);
-        const current = currentFn(it);
-
-        if (current < limit) {
-          triggered = true;
-        }
-
-        if (triggered && current > limit) {
-          triggered = false;
-
-          return true;
-        }
-
-        return false;
-      })
-    );
-  };
-}
-
-export function crossover<T>(limitFn: (it: T) => number, currentFn: (it: T) => number) {
-  return function (source: Observable<T>): Observable<T> {
-    let triggered = false;
-
-    return source.pipe(
-      filter(it => {
-        const limit = limitFn(it);
-        const current = currentFn(it);
-
-        if (current > limit) {
-          triggered = true;
-        }
-
-        if (triggered && current < limit) {
-          triggered = false;
-
-          return true;
-        }
-
-        return false;
-      })
-    );
-  };
-}

package/src/indicator/donchian.ts

@@ -1,37 +0,0 @@
-import { map, Observable, share, withLatestFrom } from 'rxjs';
-
-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<
-    [
-      T,
-      {
-        upper: number;
-        lower: number;
-      }
-    ]
-  > {
-    source = source.pipe(share());
-
-    return source.pipe(
-      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 }];
-
-        return tuple;
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/drawdown.ts

@@ -1,27 +0,0 @@
-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;
-
-    return source.pipe(
-      map(it => {
-        const value = fn(it);
-
-        if (!rate) {
-          rate = value;
-        } else {
-          if (value > rate) {
-            rate = value;
-          } else if (value < rate) {
-            max = Math.min(max, value / rate - 1);
-          }
-        }
-
-        return max;
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/ema.spec.ts

@@ -1,38 +0,0 @@
-import { from } from 'rxjs';
-
-import { ema } from './ema';
-
-describe('ema', () => {
-  test('should return expected value', done => {
-    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
-    ])
-      .pipe(ema(20, it => it))
-      .subscribe({
-        next: ([, it]) => (value = it),
-        complete: () => {
-          expect(parseFloat(value.toFixed(4))).toBe(214.6336);
-          done();
-        }
-      });
-  });
-  /*
-  test('should return expected value', done => {
-    let value;
-
-    //12 Dec 2020 00:00
-    from([18136.17, 18092.15, 18082.39, 18065.4, 18046.47])
-      .pipe(ema(5, it => it))
-      .subscribe({
-        next: it => (value = it.value),
-        complete: () => {
-          expect(parseFloat(value.toFixed(2))).toBe(18076.28);
-          done();
-        }
-      });
-  });*/
-});

package/src/indicator/ema.ts

@@ -1,26 +0,0 @@
-import { map, Observable, share } from 'rxjs';
-
-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;
-
-    return source.pipe(
-      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;
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/envelope.ts

@@ -1,20 +0,0 @@
-import { map, Observable, share } from 'rxjs';
-
-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 }> {
-    return source.pipe(
-      sma(length, valueFn),
-      map(([it, sma]) => {
-        const offset = (sma * percent) / 100;
-
-        return {
-          min: sma - offset,
-          max: sma + offset
-        };
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/index.ts

@@ -1,17 +0,0 @@
-export * from './atr';
-export * from './cross';
-export * from './donchian';
-export * from './drawdown';
-export * from './ema';
-export * from './envelope';
-export * from './macd';
-export * from './min-max';
-export * from './ring-buffer';
-export * from './rma';
-export * from './sma';
-export * from './swma';
-export * from './tma';
-export * from './trailing';
-export * from './truerange';
-export * from './window';
-export * from './wma';

package/src/indicator/macd.ts

@@ -1,21 +0,0 @@
-import { map, Observable, share, withLatestFrom } from 'rxjs';
-
-import { ema } from './ema';
-
-export function macd<T>(
-  fast: number,
-  slow: number,
-  length: number,
-  fn: (it: T) => number
-) {
-  return function (source: Observable<T>): Observable<number> {
-    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),
-      share()
-    );
-  };
-}

package/src/indicator/min-max.ts

@@ -1,25 +0,0 @@
-import { filter, map, Observable, share } from 'rxjs';
-
-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 }]> {
-    return source.pipe(
-      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;
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/ring-buffer.ts

@@ -1,63 +0,0 @@
-export class RingBuffer<T> {
-  private _elements = new Array<T>(this.capacity);
-  private _first = 0;
-  private _last = 0;
-  private _size = 0;
-
-  get size(): number {
-    return this._size;
-  }
-
-  get isEmpty(): boolean {
-    return this.size == 0;
-  }
-
-  get isFull(): boolean {
-    return this.size == this.capacity;
-  }
-
-  constructor(readonly capacity: number) {}
-
-  peek(): T {
-    return this._elements[this._first];
-  }
-
-  dequeue(): T {
-    const element = this.peek();
-
-    this._size--;
-    this._first = (this._first + 1) % this.capacity;
-
-    return element;
-  }
-
-  enqueue(element: T): T {
-    this._last = (this._first + this.size) % this.capacity;
-    const full = this.isFull;
-    let removed = null;
-
-    if (full) {
-      removed = this._elements[this._last];
-    }
-
-    this._elements[this._last] = element;
-
-    if (full) {
-      this._first = (this._first + 1) % this.capacity;
-    } else {
-      this._size++;
-    }
-
-    return removed;
-  }
-
-  forEach(fn: (value: T, index: number) => void) {
-    for (let i = 0; i < this.size; i++) {
-      fn(this.at(i), i);
-    }
-  }
-
-  at(index: number): T {
-    return this._elements[(this._first + index) % this.capacity];
-  }
-}

package/src/indicator/rma.ts

@@ -1,25 +0,0 @@
-import { map, Observable, share } from 'rxjs';
-
-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;
-
-    return source.pipe(
-      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;
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/sma.spec.ts

@@ -1,20 +0,0 @@
-import { from } from 'rxjs';
-
-import { sma } from './sma';
-
-describe('sma', () => {
-  test('should return expected value', done => {
-    let value;
-
-    //12 Dec 2020 00:00
-    from([18136.17, 18092.15, 18082.39, 18065.4, 18046.47])
-      .pipe(sma(5, it => it))
-      .subscribe({
-        next: ([, it]) => (value = it),
-        complete: () => {
-          expect(parseFloat(value.toFixed(2))).toBe(18084.52);
-          done();
-        }
-      });
-  });
-});

package/src/indicator/sma.ts

@@ -1,24 +0,0 @@
-import { filter, map, Observable, share, tap } from 'rxjs';
-
-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;
-
-    return source.pipe(
-      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 tuple;
-      }),
-      share()
-    );
-  };
-}