@tradingaction/indicators 2.0.1

package/src/calculator/compare.ts

@@ -0,0 +1,68 @@
+import { path } from "../utils";
+import { Change as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface CompareOptions {
+    readonly basePath: string;
+    readonly compareKeys: string[];
+    readonly mainKeys: string[];
+    readonly sourcePath?: string;
+}
+
+export default function () {
+    let options: CompareOptions = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { basePath, mainKeys, compareKeys } = options;
+
+        const base = path(basePath);
+
+        const first = data[0];
+        const b = base(first);
+
+        const firsts: any = {};
+
+        const compareData = data.map((d) => {
+            const result = {};
+
+            mainKeys.forEach((key) => {
+                if (typeof d[key] === "object") {
+                    // @ts-ignore
+                    result[key] = {};
+                    Object.keys(d[key]).forEach((subkey) => {
+                        // @ts-ignore
+                        result[key][subkey] = (d[key][subkey] - b) / b;
+                    });
+                } else {
+                    // @ts-ignore
+                    result[key] = (d[key] - b) / b;
+                }
+            });
+
+            compareKeys.forEach((key) => {
+                if (d[key] !== undefined && firsts[key] === undefined) {
+                    // @ts-ignore
+                    firsts[key] = d[key];
+                }
+                if (d[key] !== undefined && firsts[key] !== undefined) {
+                    // @ts-ignore
+                    result[key] = (d[key] - firsts[key]) / firsts[key];
+                }
+            });
+            return result;
+        });
+
+        return compareData;
+    };
+
+    calculator.options = (newOptions?: CompareOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/defaultOptionsForComputation.ts

@@ -0,0 +1,117 @@
+export const BollingerBand = {
+    windowSize: 20,
+    // source: d => d.close, // "high", "low", "open", "close"
+    sourcePath: "close",
+    multiplier: 2,
+    movingAverageType: "sma",
+};
+
+export const ATR = {
+    windowSize: 14,
+};
+
+export const ForceIndex = {
+    sourcePath: "close", // "high", "low", "open", "close"
+    volumePath: "volume",
+};
+
+export const SmoothedForceIndex = {
+    sourcePath: "close", // "high", "low", "open", "close"
+    volumePath: "volume",
+    smoothingType: "ema",
+    smoothingWindow: 13,
+};
+
+export const Change = {
+    sourcePath: "close", // "high", "low", "open", "close"
+    basePath: "close",
+    mainKeys: [],
+    compareKeys: [],
+};
+
+export const Compare = {
+    basePath: "close",
+    mainKeys: ["open", "high", "low", "close"],
+    compareKeys: [],
+};
+
+export const ElderRay = {
+    windowSize: 13,
+    // source: d => d.close, // "high", "low", "open", "close"
+    sourcePath: "close", // "high", "low", "open", "close"
+    movingAverageType: "sma",
+};
+
+export const ElderImpulse = {
+    sourcePath: "close", // "high", "low", "open", "close"
+};
+
+export const SAR = {
+    accelerationFactor: 0.02,
+    maxAccelerationFactor: 0.2,
+};
+
+export const MACD = {
+    fast: 12,
+    slow: 26,
+    signal: 9,
+    // source: d => d.close, // "high", "low", "open", "close"
+    sourcePath: "close",
+};
+
+export const FullStochasticOscillator = {
+    windowSize: 12,
+    kWindowSize: 3,
+    dWindowSize: 3,
+};
+
+export const RSI = {
+    windowSize: 14,
+    // source: d => d.close, // "high", "low", "open", "close"
+    sourcePath: "close", // "high", "low", "open", "close"
+};
+
+export const EMA = {
+    // source: d => d.close, // "high", "low", "open", "close"
+    sourcePath: "close",
+    windowSize: 10,
+};
+
+export const SMA = {
+    // source: d => d.close, // "high", "low", "open", "close"
+    sourcePath: "close",
+    windowSize: 10,
+};
+
+export const WMA = {
+    // source: d => d.close, // "high", "low", "open", "close"
+    sourcePath: "close",
+    windowSize: 10,
+};
+
+export const TMA = {
+    // source: d => d.close, // "high", "low", "open", "close"
+    sourcePath: "close",
+    windowSize: 10,
+};
+
+export const Kagi = {
+    reversalType: "ATR", // "ATR", "FIXED"
+    windowSize: 14,
+    reversal: 2,
+    sourcePath: "close", // "high", "low", "open", "close"
+};
+
+export const Renko = {
+    reversalType: "ATR", // "ATR", "FIXED", "Percentage LTP"
+    windowSize: 14,
+    fixedBrickSize: 2,
+    sourcePath: "high/low", // "close", "high/low"
+    percentage: 1,
+};
+
+export const PointAndFigure = {
+    boxSize: 0.5,
+    reversal: 3,
+    sourcePath: "high/low", // "close", "high/low"
+};

package/src/calculator/elderRay.ts

@@ -0,0 +1,90 @@
+/*
+https://github.com/ScottLogic/d3fc/blob/master/src/indicator/algorithm/calculator/elderRay.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, zip } from "d3-array";
+import { slidingWindow } from "../utils";
+import ema from "./ema";
+import { ElderRay as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface ElderRayOptions {
+    readonly movingAverageType: string;
+    readonly sourcePath: string;
+    readonly windowSize: number;
+}
+
+export default function () {
+    let options = defaultOptions;
+    let ohlc = (d: any) => ({ open: d.open, high: d.high, low: d.low, close: d.close });
+
+    const calculator = (data: any[]) => {
+        const { windowSize, sourcePath, movingAverageType } = options;
+
+        const meanAlgorithm =
+            movingAverageType === "ema"
+                ? ema().options({ windowSize, sourcePath })
+                : slidingWindow()
+                      .windowSize(windowSize)
+                      .accumulator((values: any) => mean(values))
+                      .sourcePath(sourcePath);
+
+        return zip(data, meanAlgorithm(data)).map((d) => {
+            const datum = d[0];
+            const meanValue = d[1];
+
+            const bullPower = meanValue !== undefined ? ohlc(datum).high - meanValue : undefined;
+            const bearPower = meanValue !== undefined ? ohlc(datum).low - meanValue : undefined;
+            return { bullPower, bearPower };
+        });
+    };
+
+    calculator.undefinedLength = () => {
+        const { windowSize } = options;
+
+        return windowSize - 1;
+    };
+
+    calculator.ohlc = (ohlcAccessor?: (d: any) => any) => {
+        if (ohlcAccessor === undefined) {
+            return ohlc;
+        }
+
+        ohlc = ohlcAccessor;
+
+        return calculator;
+    };
+
+    calculator.options = (newOptions?: ElderRayOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/ema.ts

@@ -0,0 +1,92 @@
+/*
+https://github.com/ScottLogic/d3fc/blob/master/src/indicator/algorithm/calculator/exponentialMovingAverage.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 { path } from "../utils";
+import { EMA as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface EMAOptions {
+    readonly windowSize: number;
+    readonly sourcePath?: string;
+}
+
+interface EMACalculator {
+    (data: any[]): (number | undefined)[];
+    undefinedLength(): number;
+    options(): EMAOptions;
+    options(newOptions: EMAOptions): EMACalculator;
+}
+
+export default function () {
+    let options: EMAOptions = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { windowSize, sourcePath } = options;
+
+        const source = path(sourcePath);
+        const alpha = 2 / (windowSize + 1);
+        let previous: any;
+        let initialAccumulator = 0;
+        let skip = 0;
+
+        return data.map(function (d, i) {
+            const v = source(d, i);
+            if (previous === undefined && v === undefined) {
+                skip++;
+                return undefined;
+            } else if (i < windowSize + skip - 1) {
+                initialAccumulator += v;
+                return undefined;
+            } else if (i === windowSize + skip - 1) {
+                initialAccumulator += v;
+                const initialValue = initialAccumulator / windowSize;
+                previous = initialValue;
+                return initialValue;
+            } else {
+                const nextValue = v * alpha + (1 - alpha) * previous;
+                previous = nextValue;
+                return nextValue;
+            }
+        });
+    };
+
+    calculator.undefinedLength = () => {
+        const { windowSize } = options;
+
+        return windowSize - 1;
+    };
+
+    calculator.options = (newOptions?: EMAOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator as EMACalculator;
+}

package/src/calculator/forceIndex.ts

@@ -0,0 +1,43 @@
+import { path, slidingWindow } from "../utils";
+import { ForceIndex as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface ForceIndexOptions {
+    readonly sourcePath: string;
+    readonly volumePath: string;
+}
+
+export default function () {
+    let options = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { sourcePath, volumePath } = options;
+
+        const source = path(sourcePath);
+
+        const volume = path(volumePath);
+
+        const forceIndexCalulator = slidingWindow()
+            .windowSize(2)
+            .accumulator(([prev, curr]: any) => (source(curr) - source(prev)) * volume(curr));
+
+        const forceIndex = forceIndexCalulator(data);
+
+        return forceIndex;
+    };
+
+    calculator.undefinedLength = () => {
+        return 2;
+    };
+
+    calculator.options = (newOptions?: ForceIndexOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/heikinAshi.ts

@@ -0,0 +1,38 @@
+import { mappedSlidingWindow } from "../utils";
+
+export default function () {
+    let source = (x: any) => x;
+
+    const calculator = (data: any[]) => {
+        const algorithm = mappedSlidingWindow()
+            .windowSize(2)
+            .undefinedValue(
+                ({ open, high, low, close }: { open: number; high: number; low: number; close: number }) => {
+                    close = (open + high + low + close) / 4;
+                    return { open, high, low, close };
+                },
+            )
+            .accumulator(([prev, now]: any) => {
+                const { date, volume } = now;
+                const close = (now.open + now.high + now.low + now.close) / 4;
+                const open = (prev.open + prev.close) / 2;
+                const high = Math.max(open, now.high, close);
+                const low = Math.min(open, now.low, close);
+                return { date, open, high, low, close, volume };
+            });
+
+        return algorithm(data);
+    };
+
+    calculator.source = (newSource?: any) => {
+        if (newSource === undefined) {
+            return source;
+        }
+
+        source = newSource;
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/index.ts

@@ -0,0 +1,19 @@
+export { default as ema } from "./ema";
+export { default as sma } from "./sma";
+export { default as wma } from "./wma";
+export { default as tma } from "./tma";
+export { default as bollingerband } from "./bollingerband";
+export { default as heikinAshi } from "./heikinAshi";
+export { default as kagi } from "./kagi";
+export { default as pointAndFigure } from "./pointAndFigure";
+export { default as renko } from "./renko";
+export { default as macd } from "./macd";
+export { default as rsi } from "./rsi";
+export { default as sto } from "./sto";
+export { default as atr } from "./atr";
+export { default as forceIndex } from "./forceIndex";
+export { default as smoothedForceIndex } from "./smoothedForceIndex";
+export { default as elderRay } from "./elderRay";
+export { default as sar } from "./sar";
+export { default as compare } from "./compare";
+export { default as change } from "./change";