@tradingaction/indicators 2.0.1

package/src/calculator/tma.ts

@@ -0,0 +1,82 @@
+/*
+ TRIMA (Triangular Moving Average).
+
+ The Triangular Moving Average can be used like any other Moving Average, to
+ obtain a smoother representation of the underlying data.
+ It is important to note that the Triangular Moving Average is typically much
+ smoother than other moving averages.
+
+ Triangular moving averages give greater weight to prices at the centre of the
+ chosen period andi it is calculated as double smoothed SMA (simple moving average).
+
+ Examples:
+   For TimeSerie={a,b,c,d,e,f...} ('a' is the older price)
+
+   1st value for TMA 4-Period is:  ((1*a)+(2*b)+(2*c)+(1*d)) / 6
+   2nd value for TMA 4-Period is:  ((1*b)+(2*c)+(2*d)+(1*e)) / 6
+
+   1st value for TMA 5-Period is:  ((1*a)+(2*b)+(3*c)+(2*d)+(1*e)) / 9
+   2nd value for TMA 5-Period is:  ((1*b)+(2*c)+(3*d)+(2*e)+(1*f)) / 9
+
+ Using algebra, it can be demonstrated that the TMA is equivalent to
+ doing a SMA of a SMA. The following explain the rules:
+
+   (1) When the period is even, TMA(x,period)=SMA(SMA(x,period/2),(period/2)+1)
+   (2) When the period is odd,  TMA(x,period)=SMA(SMA(x,(period+1)/2),(period+1)/2)
+
+ In other word:
+   (1) A period of 4 becomes TMA(x,4) = SMA( SMA( x, 2), 3 )
+   (2) A period of 5 becomes TMA(x,5) = SMA( SMA( x, 3), 3 )
+
+ The SMA of a SMA is the algorithm generally found in books.
+*/
+
+import { sum } from "d3-array";
+import { slidingWindow } from "../utils";
+import { TMA as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface TMAOptions {
+    readonly sourcePath?: string;
+    readonly windowSize: number;
+}
+
+export default function () {
+    let options = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { windowSize, sourcePath } = options;
+
+        const n = Math.floor(windowSize / 2);
+        const weight = windowSize % 2 === 0 ? n * (n + 1) : (n + 1) * (n + 1);
+
+        const triaverage = slidingWindow()
+            .windowSize(windowSize)
+            .sourcePath(sourcePath)
+            .accumulator((values: number[]) => {
+                const total = sum(values, (v, i) => {
+                    return i < n ? (i + 1) * v : (windowSize - i) * v;
+                });
+                return total / weight;
+            });
+
+        return triaverage(data);
+    };
+
+    calculator.undefinedLength = () => {
+        const { windowSize } = options;
+
+        return windowSize - 1;
+    };
+
+    calculator.options = (newOptions?: TMAOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/calculator/wma.ts

@@ -0,0 +1,49 @@
+import { sum } from "d3-array";
+import { slidingWindow } from "../utils";
+import { WMA as defaultOptions } from "./defaultOptionsForComputation";
+
+export interface WMAOptions {
+    sourcePath?: string;
+    windowSize: number;
+}
+
+export default function () {
+    let options = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { windowSize, sourcePath } = options;
+
+        const weight = (windowSize * (windowSize + 1)) / 2;
+
+        const waverage = slidingWindow()
+            .windowSize(windowSize)
+            .sourcePath(sourcePath)
+            .accumulator((values: number[]) => {
+                const total = sum(values, (v, i) => {
+                    return (i + 1) * v;
+                });
+
+                return total / weight;
+            });
+
+        return waverage(data);
+    };
+
+    calculator.undefinedLength = () => {
+        const { windowSize } = options;
+
+        return windowSize - 1;
+    };
+
+    calculator.options = (newOptions?: WMAOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./indicator";

package/src/indicator/algorithm.ts

@@ -0,0 +1,53 @@
+import { identity, merge, slidingWindow } from "../utils";
+
+export interface Algorithm {
+    (data: any[]): any;
+    accumulator(): any;
+    accumulator(newAccumulator: any): Algorithm;
+    windowSize(): number;
+    windowSize(windowSize: number): Algorithm;
+    merge(): any;
+    merge(newMerge: any): Algorithm;
+}
+
+export default function () {
+    let windowSize = 1;
+    let accumulator = identity;
+    let mergeAs = identity;
+
+    function algorithm(data: any[]) {
+        const defaultAlgorithm = slidingWindow().windowSize(windowSize).accumulator(accumulator);
+
+        const calculator = merge().algorithm(defaultAlgorithm).merge(mergeAs);
+
+        const newData = calculator(data);
+
+        return newData;
+    }
+
+    algorithm.accumulator = (newAccumulator?: any) => {
+        if (newAccumulator === undefined) {
+            return accumulator;
+        }
+        accumulator = newAccumulator;
+        return algorithm;
+    };
+
+    algorithm.windowSize = (newWindowSize?: number) => {
+        if (newWindowSize === undefined) {
+            return windowSize;
+        }
+        windowSize = newWindowSize;
+        return algorithm;
+    };
+
+    algorithm.merge = (newMerge?: any) => {
+        if (newMerge === undefined) {
+            return mergeAs;
+        }
+        mergeAs = newMerge;
+        return algorithm;
+    };
+
+    return algorithm as Algorithm;
+}

package/src/indicator/atr.ts

@@ -0,0 +1,58 @@
+import { atr } from "../calculator";
+import { merge, rebind } from "../utils";
+import { ATROptions } from "../calculator/atr";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "ATR";
+
+interface ATRIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): ATRIndicator;
+    accessor(): any;
+    accessor(x: any): ATRIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): ATRIndicator;
+    fill(): string | any;
+    fill(x: string | any): ATRIndicator;
+    echo(): any;
+    echo(x: any): ATRIndicator;
+    type(): string;
+    type(x: string): ATRIndicator;
+    merge(): any;
+    merge(newMerge: any): ATRIndicator;
+    options(): ATROptions;
+    options(newOptions: ATROptions): ATRIndicator;
+    skipUndefined(): boolean;
+    skipUndefined(newSkipUndefined: boolean): ATRIndicator;
+}
+
+export default function () {
+    const base = baseIndicator().type(ALGORITHM_TYPE);
+
+    const underlyingAlgorithm = atr();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.atr = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as ATRIndicator;
+}

package/src/indicator/baseIndicator.ts

@@ -0,0 +1,97 @@
+import { scaleOrdinal } from "d3-scale";
+
+const defaultColors = ["#F44336", "#2196F3", "#8BC34A", "#FF5722", "#3F51B5", "#03A9F4", "#9C27B0", "#4CAF50"];
+
+let i = 0;
+const overlayColors = scaleOrdinal<number, string>(defaultColors);
+
+export interface BaseIndicator {
+    (): () => void;
+    id(): number;
+    id(x: number): BaseIndicator;
+    accessor(): any;
+    accessor(x: any): BaseIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): BaseIndicator;
+    fill(): string | any;
+    fill(x: string | any): BaseIndicator;
+    echo(): any;
+    echo(x: any): BaseIndicator;
+    type(): string;
+    type(x: string): BaseIndicator;
+}
+
+export default function () {
+    let id = i++;
+    let accessor: any;
+    let stroke: string | any;
+    let fill: string | any;
+    let echo: any;
+    let type: string;
+
+    const baseIndicator = () => () => {
+        /** Do Nothing */
+    };
+
+    baseIndicator.id = (newId?: number) => {
+        if (newId === undefined) {
+            return id;
+        }
+
+        id = newId;
+
+        return baseIndicator;
+    };
+
+    baseIndicator.accessor = (newAccessor?: any) => {
+        if (newAccessor === undefined) {
+            return accessor;
+        }
+
+        accessor = newAccessor;
+
+        return baseIndicator;
+    };
+
+    baseIndicator.stroke = (newStroke?: string | any) => {
+        if (newStroke === undefined) {
+            return !stroke ? (stroke = overlayColors(id)) : stroke;
+        }
+
+        stroke = newStroke;
+
+        return baseIndicator;
+    };
+
+    baseIndicator.fill = (newFill?: string | any) => {
+        if (newFill === undefined) {
+            return !fill ? (fill = overlayColors(id)) : fill;
+        }
+
+        fill = newFill;
+
+        return baseIndicator;
+    };
+
+    baseIndicator.echo = (newEcho?: any) => {
+        if (newEcho === undefined) {
+            return echo;
+        }
+
+        echo = newEcho;
+
+        return baseIndicator;
+    };
+
+    baseIndicator.type = (newType?: string) => {
+        if (newType === undefined) {
+            return type;
+        }
+
+        type = newType;
+
+        return baseIndicator;
+    };
+
+    return baseIndicator as BaseIndicator;
+}

package/src/indicator/bollingerBand.ts

@@ -0,0 +1,55 @@
+import { merge, rebind } from "../utils";
+import { bollingerband } from "../calculator";
+import { BollingerBandOptions } from "../calculator/bollingerband";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "BollingerBand";
+
+interface BollingerBandIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): BollingerBandIndicator;
+    accessor(): any;
+    accessor(x: any): BollingerBandIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): BollingerBandIndicator;
+    fill(): string | any;
+    fill(x: string | any): BollingerBandIndicator;
+    echo(): any;
+    echo(x: any): BollingerBandIndicator;
+    type(): string;
+    type(x: string): BollingerBandIndicator;
+    merge(): any;
+    merge(newMerge: any): BollingerBandIndicator;
+    options(): BollingerBandOptions;
+    options(newOptions: BollingerBandOptions): BollingerBandIndicator;
+}
+
+export default function () {
+    const base = baseIndicator().type(ALGORITHM_TYPE);
+
+    const underlyingAlgorithm = bollingerband();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.bollingerBand = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as BollingerBandIndicator;
+}

package/src/indicator/change.ts

@@ -0,0 +1,51 @@
+import { change } from "../calculator";
+import { merge, rebind } from "../utils";
+import { ChangeOptions } from "../calculator/change";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "Change";
+
+interface ChangeIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): ChangeIndicator;
+    accessor(): any;
+    accessor(x: any): ChangeIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): ChangeIndicator;
+    fill(): string | any;
+    fill(x: string | any): ChangeIndicator;
+    echo(): any;
+    echo(x: any): ChangeIndicator;
+    type(): string;
+    type(x: string): ChangeIndicator;
+    merge(): any;
+    merge(newMerge: any): ChangeIndicator;
+    options(): ChangeOptions;
+    options(newOptions: ChangeOptions): ChangeIndicator;
+}
+
+export default function () {
+    const base = baseIndicator().type(ALGORITHM_TYPE);
+
+    const underlyingAlgorithm = change();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: any) => {
+            datum.absoluteChange = i.absoluteChange;
+            datum.percentChange = i.percentChange;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            return mergedAlgorithm(data);
+        }
+        return underlyingAlgorithm(data);
+    };
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as ChangeIndicator;
+}

package/src/indicator/compare.ts

@@ -0,0 +1,57 @@
+import { merge, rebind } from "../utils";
+import { compare } from "../calculator";
+import { CompareOptions } from "../calculator/compare";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "Compare";
+
+interface CompareIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): CompareIndicator;
+    accessor(): any;
+    accessor(x: any): CompareIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): CompareIndicator;
+    fill(): string | any;
+    fill(x: string | any): CompareIndicator;
+    echo(): any;
+    echo(x: any): CompareIndicator;
+    type(): string;
+    type(x: string): CompareIndicator;
+    merge(): any;
+    merge(newMerge: any): CompareIndicator;
+    options(): CompareOptions;
+    options(newOptions: CompareOptions): CompareIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.compare);
+
+    const underlyingAlgorithm = compare();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.compare = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options");
+    rebind(indicator, mergedAlgorithm, "merge");
+
+    return indicator as CompareIndicator;
+}

package/src/indicator/defaultOptionsForAppearance.ts

@@ -0,0 +1,77 @@
+export const themes = {
+    light: {
+        BollingerBand: {
+            stroke: {
+                top: "#964B00",
+                middle: "#000000",
+                bottom: "#964B00",
+            },
+            fill: "#4682B4",
+        },
+        ElderImpulse: {
+            stroke: {
+                up: "#6BA583",
+                down: "#FF0000",
+                neutral: "#0000FF",
+            },
+        },
+        MACD: {
+            fill: {
+                divergence: "#4682B4",
+            },
+            stroke: {
+                macd: "#FF0000",
+                signal: "#00F300",
+            },
+        },
+        FullStochasticOscillator: {
+            stroke: {
+                top: "#37a600",
+                middle: "#b8ab00",
+                bottom: "#37a600",
+                dLine: "#17becf",
+                kLine: "#ff7f0e",
+            },
+        },
+    },
+    dark: {
+        BollingerBand: {
+            stroke: {
+                top: "#964B00",
+                middle: "#FF6600",
+                bottom: "#964B00",
+            },
+            fill: "#4682B4",
+        },
+        ElderImpulse: {
+            stroke: {
+                up: "#6BA583",
+                down: "#FF0000",
+                neutral: "#0000FF",
+            },
+        },
+        MACD: {
+            fill: {
+                divergence: "#FF6600",
+            },
+            stroke: {
+                macd: "#ea2bff",
+                signal: "#74d400",
+            },
+        },
+        FullStochasticOscillator: {
+            stroke: {
+                top: "#37a600",
+                middle: "#b8ab00",
+                bottom: "#37a600",
+                dLine: "#ea2bff",
+                kLine: "#74d400",
+            },
+        },
+    },
+};
+
+export const BollingerBand = themes.light.BollingerBand;
+export const ElderImpulse = themes.light.ElderImpulse;
+export const MACD = themes.light.MACD;
+export const FullStochasticOscillator = themes.light.FullStochasticOscillator;

package/src/indicator/elderImpulse.ts

@@ -0,0 +1,73 @@
+import { merge, rebind, slidingWindow } from "../utils";
+import baseIndicator from "./baseIndicator";
+import { ElderImpulse as appearanceOptions } from "./defaultOptionsForAppearance";
+
+const ALGORITHM_TYPE = "ElderImpulse";
+
+export default function () {
+    let macdSource: any | undefined;
+    let emaSource: any | undefined;
+
+    const base = baseIndicator().type(ALGORITHM_TYPE).stroke(appearanceOptions.stroke).fill(undefined);
+
+    const underlyingAlgorithm = slidingWindow()
+        .windowSize(2)
+        .undefinedValue("neutral")
+        .accumulator(([prev, curr]: any) => {
+            if (macdSource === undefined) {
+                throw new Error(`macdSource not defined for ${ALGORITHM_TYPE} calculator`);
+            }
+            if (emaSource === undefined) {
+                throw new Error(`emaSource not defined for ${ALGORITHM_TYPE} calculator`);
+            }
+
+            const prevMacd = macdSource(prev);
+            const prevEMA = emaSource(prev);
+
+            if (prevMacd !== undefined && prevEMA !== undefined) {
+                const prevMACDDivergence = prevMacd.divergence;
+                const currMACDDivergence = macdSource(curr).divergence;
+
+                const currEMA = emaSource(curr);
+
+                if (currMACDDivergence >= prevMACDDivergence && currEMA >= prevEMA) {
+                    return "up";
+                }
+
+                if (currMACDDivergence <= prevMACDDivergence && currEMA <= prevEMA) {
+                    return "down";
+                }
+            }
+            return "neutral";
+        });
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.elderImpulse = i;
+        });
+
+    const indicator = function (data: any, options = { merge: true }) {
+        const newData = options.merge ? mergedAlgorithm(data) : underlyingAlgorithm(data);
+
+        return newData;
+    };
+    indicator.macdSource = function (x: any) {
+        if (!arguments.length) {
+            return macdSource;
+        }
+        macdSource = x;
+        return indicator;
+    };
+    indicator.emaSource = function (x: any) {
+        if (!arguments.length) {
+            return emaSource;
+        }
+        emaSource = x;
+        return indicator;
+    };
+    rebind(indicator, base, "id", "echo", "type", "stroke");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator;
+}