@tradingaction/indicators 2.0.1

package/src/calculator/renko.ts

@@ -0,0 +1,227 @@
+import { functor, merge } from "../utils";
+import atr from "./atr";
+import { Renko as defaultOptions } from "./defaultOptionsForComputation";
+
+export default function () {
+    let options = defaultOptions;
+
+    let dateAccessor = (d: any) => d.date;
+    let dateMutator = (d: any, date: any) => {
+        d.date = date;
+    };
+
+    const calculator = (rawData: any[]) => {
+        const { reversalType, fixedBrickSize, sourcePath, windowSize, percentage } = options;
+
+        const source =
+            sourcePath === "high/low"
+                ? (d: any) => ({ high: d.high, low: d.low })
+                : (d: any) => ({ high: d.close, low: d.close });
+
+        const pricingMethod = source;
+        let brickSize: any;
+
+        if (reversalType === "ATR") {
+            const atrAlgorithm = atr().options({ windowSize });
+
+            const atrCalculator = merge()
+                .algorithm(atrAlgorithm)
+                .merge((d: any, c: any) => {
+                    d["atr" + windowSize] = c;
+                });
+
+            atrCalculator(rawData);
+            brickSize = (d: any) => d["atr" + windowSize];
+        } else if (reversalType === "Percentage LTP") {
+            // Calculate brick size as a percentage of the last price
+            brickSize = (d: any) => d.close * (percentage / 100);
+        } else {
+            brickSize = functor(fixedBrickSize);
+        }
+
+        const renkoData: any[] = [];
+
+        let index = 0;
+        let prevBrickClose = rawData[index].open;
+        let prevBrickOpen = rawData[index].open;
+        let brick: {
+            added?: any;
+            date?: any;
+            direction?: any;
+            from?: any;
+            fromDate?: any;
+            to?: any;
+            toDate?: any;
+            open?: number;
+            high?: number;
+            low?: number;
+            close?: number;
+            fullyFormed?: any;
+            current?: any;
+            changePoint?: any;
+            changeTo?: any;
+            volume?: number;
+            reverseAt?: any;
+            startAs?: any;
+            startOfYear?: any;
+            startOfQuarter?: any;
+            startOfMonth?: any;
+            startOfWeek?: any;
+        } = {};
+        let direction = 0;
+
+        rawData.forEach(function (d, idx) {
+            if (brick.from === undefined) {
+                brick.high = d.high;
+                brick.low = d.low;
+                brick.startOfYear = d.startOfYear;
+                brick.startOfQuarter = d.startOfQuarter;
+                brick.startOfMonth = d.startOfMonth;
+                brick.startOfWeek = d.startOfWeek;
+
+                brick.from = idx;
+                brick.fromDate = dateAccessor(d);
+                dateMutator(brick, dateAccessor(d));
+            }
+            brick.volume = (brick.volume || 0) + d.volume;
+
+            const prevCloseToHigh = prevBrickClose - pricingMethod(d).high;
+            const prevCloseToLow = prevBrickClose - pricingMethod(d).low;
+            const prevOpenToHigh = prevBrickOpen - pricingMethod(d).high;
+            const prevOpenToLow = prevBrickOpen - pricingMethod(d).low;
+            const priceMovement = Math.min(
+                Math.abs(prevCloseToHigh),
+                Math.abs(prevCloseToLow),
+                Math.abs(prevOpenToHigh),
+                Math.abs(prevOpenToLow),
+            );
+
+            // @ts-ignore
+            brick.high = Math.max(brick.high, d.high);
+            // @ts-ignore
+            brick.low = Math.min(brick.low, d.low);
+
+            if (!brick.startOfYear) {
+                brick.startOfYear = d.startOfYear;
+                if (brick.startOfYear) {
+                    dateMutator(brick, dateAccessor(d));
+                }
+            }
+
+            if (!brick.startOfQuarter) {
+                brick.startOfQuarter = d.startOfQuarter;
+                if (brick.startOfQuarter && !brick.startOfYear) {
+                    dateMutator(brick, dateAccessor(d));
+                }
+            }
+
+            if (!brick.startOfMonth) {
+                brick.startOfMonth = d.startOfMonth;
+                if (brick.startOfMonth && !brick.startOfQuarter) {
+                    dateMutator(brick, dateAccessor(d));
+                }
+            }
+            if (!brick.startOfWeek) {
+                brick.startOfWeek = d.startOfWeek;
+                if (brick.startOfWeek && !brick.startOfMonth) {
+                    dateMutator(brick, dateAccessor(d));
+                }
+            }
+
+            if (brickSize(d)) {
+                const noOfBricks = Math.floor(priceMovement / brickSize(d));
+
+                brick.open =
+                    Math.abs(prevCloseToHigh) < Math.abs(prevOpenToHigh) ||
+                    Math.abs(prevCloseToLow) < Math.abs(prevOpenToLow)
+                        ? prevBrickClose
+                        : prevBrickOpen;
+
+                if (noOfBricks >= 1) {
+                    let j = 0;
+                    for (j = 0; j < noOfBricks; j++) {
+                        brick.close =
+                            // @ts-ignore
+                            brick.open < pricingMethod(d).high
+                                ? // if brick open is less than current price it means it is green/hollow brick
+                                  brick.open + brickSize(d)
+                                : // @ts-ignore
+                                  brick.open - brickSize(d);
+                        // @ts-ignore
+                        direction = brick.close > brick.open ? 1 : -1;
+                        brick.direction = direction;
+                        brick.to = idx;
+                        brick.toDate = dateAccessor(d);
+                        // brick.diff = brick.open - brick.close;
+                        // brick.atr = d.atr;
+                        brick.fullyFormed = true;
+                        renkoData.push(brick);
+
+                        prevBrickClose = brick.close;
+                        prevBrickOpen = brick.open;
+
+                        const newBrick = {
+                            high: brick.high,
+                            low: brick.low,
+                            open: brick.close,
+                            startOfYear: false,
+                            startOfMonth: false,
+                            startOfQuarter: false,
+                            startOfWeek: false,
+                        };
+                        brick = newBrick;
+                        brick.from = idx;
+                        brick.fromDate = dateAccessor(d);
+                        // indexMutator(brick, index + j);
+                        dateMutator(brick, dateAccessor(d));
+                        brick.volume = (brick.volume || 0) + d.volume;
+                    }
+                    index = index + j - 1;
+                    brick = {};
+                } else {
+                    if (idx === rawData.length - 1) {
+                        brick.close = direction > 0 ? pricingMethod(d).high : pricingMethod(d).low;
+                        brick.to = idx;
+                        brick.toDate = dateAccessor(d);
+                        dateMutator(brick, dateAccessor(d));
+                        brick.fullyFormed = false;
+                        renkoData.push(brick);
+                    }
+                }
+            }
+        });
+        return renkoData;
+    };
+
+    calculator.options = (newOptions?: any) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    calculator.dateMutator = (newDateMutator?: any) => {
+        if (newDateMutator === undefined) {
+            return dateMutator;
+        }
+
+        dateMutator = newDateMutator;
+
+        return calculator;
+    };
+
+    calculator.dateAccessor = (newDateAccessor?: any) => {
+        if (newDateAccessor === undefined) {
+            return dateAccessor;
+        }
+
+        dateAccessor = newDateAccessor;
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/rsi.ts

@@ -0,0 +1,114 @@
+/*
+https://github.com/ScottLogic/d3fc/blob/master/src/indicator/algorithm/calculator/relativeStrengthIndex.js
+
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Scott Logic Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+import { mean } from "d3-array";
+import { path, slidingWindow } from "../utils";
+import { RSI as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface RSIOptions {
+    windowSize: number;
+    sourcePath?: string;
+}
+
+export default function () {
+    let options = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { windowSize, sourcePath } = options;
+
+        // @ts-ignore
+        const source = path(sourcePath);
+
+        let prevAvgGain: any;
+        let prevAvgLoss: any;
+        const rsiAlgorithm = slidingWindow()
+            .windowSize(windowSize)
+            .accumulator((values: any[]) => {
+                const avgGain =
+                    prevAvgGain !== undefined
+                        ? (prevAvgGain * (windowSize - 1) + values[values.length - 1].gain) / windowSize
+                        : mean<any>(values, (each) => each.gain);
+
+                if (avgGain === undefined) {
+                    return undefined;
+                }
+
+                const avgLoss =
+                    prevAvgLoss !== undefined
+                        ? (prevAvgLoss * (windowSize - 1) + values[values.length - 1].loss) / windowSize
+                        : mean<any>(values, (each) => each.loss);
+
+                if (avgLoss === undefined) {
+                    return undefined;
+                }
+
+                const relativeStrength = avgGain / avgLoss;
+                const rsi = 100 - 100 / (1 + relativeStrength);
+
+                prevAvgGain = avgGain;
+                prevAvgLoss = avgLoss;
+
+                return rsi;
+            });
+
+        const gainsAndLossesCalculator = slidingWindow()
+            .windowSize(2)
+            .undefinedValue(() => [0, 0])
+            .accumulator((tuple: any) => {
+                const prev = tuple[0];
+                const now = tuple[1];
+                const change = source(now) - source(prev);
+                return {
+                    gain: Math.max(change, 0),
+                    loss: Math.abs(Math.min(change, 0)),
+                };
+            });
+
+        const gainsAndLosses = gainsAndLossesCalculator(data);
+
+        const rsiData = rsiAlgorithm(gainsAndLosses);
+
+        return rsiData;
+    };
+
+    calculator.undefinedLength = () => {
+        const { windowSize } = options;
+
+        return windowSize - 1;
+    };
+
+    calculator.options = (newOptions?: RSIOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/sar.ts

@@ -0,0 +1,117 @@
+import { mappedSlidingWindow } from "../utils";
+import { SAR as defaultOptions } from "./defaultOptionsForComputation";
+
+function calc(prev: any, now: any) {
+    const risingSar = prev.risingSar + prev.af * (prev.risingEp - prev.risingSar);
+
+    const fallingSar = prev.fallingSar - prev.af * (prev.fallingSar - prev.fallingEp);
+
+    const risingEp = Math.max(prev.risingEp, now.high);
+    const fallingEp = Math.min(prev.fallingEp, now.low);
+
+    return {
+        risingSar,
+        fallingSar,
+        risingEp,
+        fallingEp,
+    };
+}
+
+export interface SAROptions {
+    readonly accelerationFactor: number;
+    readonly maxAccelerationFactor: number;
+}
+
+export default function () {
+    let options = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { accelerationFactor, maxAccelerationFactor } = options;
+
+        const algorithm = mappedSlidingWindow()
+            .windowSize(2)
+            // @ts-ignore
+            .undefinedValue(({ high, low }) => {
+                return {
+                    risingSar: low,
+                    risingEp: high,
+                    fallingSar: high,
+                    fallingEp: low,
+                    af: accelerationFactor,
+                };
+            })
+            .accumulator(([prev, now]: any) => {
+                const { risingSar, fallingSar, risingEp, fallingEp } = calc(prev, now);
+
+                if (prev.use === undefined && risingSar > now.low && fallingSar < now.high) {
+                    return {
+                        risingSar,
+                        fallingSar,
+                        risingEp,
+                        fallingEp,
+                    };
+                }
+
+                const use =
+                    prev.use !== undefined
+                        ? prev.use === "rising"
+                            ? risingSar > now.low
+                                ? "falling"
+                                : "rising"
+                            : fallingSar < now.high
+                            ? "rising"
+                            : "falling"
+                        : risingSar > now.low
+                        ? "falling"
+                        : "rising";
+
+                const current =
+                    prev.use === use
+                        ? {
+                              af: Math.min(maxAccelerationFactor, prev.af + accelerationFactor),
+                              fallingEp,
+                              risingEp,
+                              fallingSar,
+                              risingSar,
+                          }
+                        : {
+                              af: accelerationFactor,
+                              fallingEp: now.low,
+                              risingEp: now.high,
+                              fallingSar: Math.max(prev.risingEp, now.high),
+                              risingSar: Math.min(prev.fallingEp, now.low),
+                          };
+
+                const { date, high, low } = now;
+
+                return {
+                    date,
+                    high,
+                    low,
+                    ...current,
+                    use,
+                    sar: use === "falling" ? current.fallingSar : current.risingSar,
+                };
+            });
+
+        const calculatedData = algorithm(data).map((d: any) => d.sar);
+
+        return calculatedData;
+    };
+
+    calculator.undefinedLength = () => {
+        return 1;
+    };
+
+    calculator.options = (newOptions?: SAROptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/sma.ts

@@ -0,0 +1,41 @@
+import { mean } from "d3-array";
+import { slidingWindow } from "../utils";
+import { SMA as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface SMAOptions {
+    readonly sourcePath?: string;
+    readonly windowSize: number;
+}
+
+export default function () {
+    let options = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { windowSize, sourcePath } = options;
+
+        const average = slidingWindow()
+            .windowSize(windowSize)
+            .sourcePath(sourcePath)
+            .accumulator((values: any[]) => mean(values));
+
+        return average(data);
+    };
+
+    calculator.undefinedLength = () => {
+        const { windowSize } = options;
+
+        return windowSize - 1;
+    };
+
+    calculator.options = (newOptions?: SMAOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/smoothedForceIndex.ts

@@ -0,0 +1,53 @@
+import { zip } from "d3-array";
+import { SmoothedForceIndex as defaultOptions } from "./defaultOptionsForComputation";
+import ema from "./ema";
+import forceIndex from "./forceIndex";
+import sma from "./sma";
+
+export default function () {
+    const underlyingAlgorithm = forceIndex();
+
+    let options = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { smoothingType, smoothingWindow } = options;
+        const { sourcePath, volumePath } = options;
+
+        const algo = underlyingAlgorithm.options({ sourcePath, volumePath });
+
+        // @ts-ignore
+        const force = algo(data);
+
+        const ma = smoothingType === "ema" ? ema() : sma();
+        const forceMA = ma.options({
+            windowSize: smoothingWindow,
+            sourcePath: undefined,
+        });
+
+        // @ts-ignore
+        const smoothed = forceMA(force);
+
+        return zip(force, smoothed).map((d) => ({
+            force: d[0],
+            smoothed: d[1],
+        }));
+    };
+
+    calculator.undefinedLength = () => {
+        const { smoothingWindow } = options;
+
+        return underlyingAlgorithm.undefinedLength() + smoothingWindow - 1;
+    };
+
+    calculator.options = (newOptions?: any) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/sto.ts

@@ -0,0 +1,118 @@
+/*
+https://github.com/ScottLogic/d3fc/blob/master/src/indicator/algorithm/calculator/stochasticOscillator.js
+
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Scott Logic Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+import { max, mean, min, zip } from "d3-array";
+import { slidingWindow } from "../utils";
+import { FullStochasticOscillator as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface STOOptions {
+    readonly windowSize: number;
+    readonly kWindowSize: number;
+    readonly dWindowSize: number;
+}
+
+export default function () {
+    let options: STOOptions = defaultOptions;
+
+    let source = (d: any) => ({ open: d.open, high: d.high, low: d.low, close: d.close });
+
+    const calculator = (data: any[]) => {
+        const { windowSize, kWindowSize, dWindowSize } = options;
+
+        const high = (d: any) => source(d).high;
+        const low = (d: any) => source(d).low;
+        const close = (d: any) => source(d).close;
+
+        const kWindow = slidingWindow()
+            .windowSize(windowSize)
+            .accumulator((values: any[]) => {
+                const highestHigh = max<any, number>(values, high);
+                if (highestHigh === undefined) {
+                    return undefined;
+                }
+
+                const lowestLow = min<any, number>(values, low);
+                if (lowestLow === undefined) {
+                    return undefined;
+                }
+
+                const currentClose = close(values[values.length - 1]);
+                const k = ((currentClose - lowestLow) / (highestHigh - lowestLow)) * 100;
+
+                return k;
+            });
+
+        const kSmoothed = slidingWindow()
+            .skipInitial(windowSize - 1)
+            .windowSize(kWindowSize)
+            .accumulator((values: any[]) => mean(values));
+
+        const dWindow = slidingWindow()
+            .skipInitial(windowSize - 1 + kWindowSize - 1)
+            .windowSize(dWindowSize)
+            .accumulator((values: any[]) => mean(values));
+
+        const kData = kSmoothed(kWindow(data));
+        const dData = dWindow(kData);
+
+        // @ts-ignore
+        const indicatorData = zip(kData, dData).map((d) => {
+            return {
+                K: d[0],
+                D: d[1],
+            };
+        });
+
+        return indicatorData;
+    };
+
+    calculator.undefinedLength = () => {
+        const { windowSize, kWindowSize, dWindowSize } = options;
+        return windowSize + kWindowSize + dWindowSize;
+    };
+
+    calculator.source = (newSource?: any) => {
+        if (newSource === undefined) {
+            return source;
+        }
+
+        source = newSource;
+
+        return calculator;
+    };
+
+    calculator.options = (newOptions?: any) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}