@tradingaction/indicators 2.0.1

package/src/calculator/kagi.ts

@@ -0,0 +1,249 @@
+import { functor, merge, path } from "../utils";
+import atr from "./atr";
+import { Kagi 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 = (data: any[]) => {
+        const { reversalType, windowSize, reversal, sourcePath } = options;
+
+        const source = path(sourcePath);
+
+        let reversalThreshold: any;
+
+        if (reversalType === "ATR") {
+            const atrAlgorithm = atr().options({ windowSize });
+
+            const atrCalculator = merge()
+                .algorithm(atrAlgorithm)
+                .merge((d: any, c: any) => {
+                    d["atr" + windowSize] = c;
+                });
+
+            atrCalculator(data);
+            reversalThreshold = (d: any) => d["atr" + windowSize];
+        } else {
+            reversalThreshold = functor(reversal);
+        }
+
+        const kagiData: any[] = [];
+
+        let prevPeak: any;
+        let prevTrough: any;
+        let direction: any;
+
+        let line: {
+            added?: any;
+            date?: any;
+            from?: any;
+            to?: any;
+            open?: number;
+            high?: number;
+            low?: number;
+            close?: number;
+            current?: any;
+            changePoint?: any;
+            changeTo?: any;
+            volume?: number;
+            reverseAt?: any;
+            startAs?: any;
+            startOfYear?: any;
+            startOfQuarter?: any;
+            startOfMonth?: any;
+            startOfWeek?: any;
+        } = {};
+
+        data.forEach(function (d) {
+            if (line.from === undefined) {
+                dateMutator(line, dateAccessor(d));
+                line.from = dateAccessor(d);
+
+                if (!line.open) {
+                    line.open = d.open;
+                }
+                line.high = d.high;
+                line.low = d.low;
+                if (!line.close) {
+                    line.close = source(d);
+                }
+                line.startOfYear = d.startOfYear;
+                line.startOfQuarter = d.startOfQuarter;
+                line.startOfMonth = d.startOfMonth;
+                line.startOfWeek = d.startOfWeek;
+            }
+
+            if (!line.startOfYear) {
+                line.startOfYear = d.startOfYear;
+                if (line.startOfYear) {
+                    line.date = d.date;
+                }
+            }
+
+            if (!line.startOfQuarter) {
+                line.startOfQuarter = d.startOfQuarter;
+                if (line.startOfQuarter && !line.startOfYear) {
+                    line.date = d.date;
+                }
+            }
+
+            if (!line.startOfMonth) {
+                line.startOfMonth = d.startOfMonth;
+                if (line.startOfMonth && !line.startOfQuarter) {
+                    line.date = d.date;
+                }
+            }
+            if (!line.startOfWeek) {
+                line.startOfWeek = d.startOfWeek;
+                if (line.startOfWeek && !line.startOfMonth) {
+                    line.date = d.date;
+                }
+            }
+            line.volume = (line.volume || 0) + d.volume;
+            // @ts-ignore
+            line.high = Math.max(line.high, d.high);
+            // @ts-ignore
+            line.low = Math.min(line.low, d.low);
+            line.to = dateAccessor(d);
+
+            // @ts-ignore
+            const priceMovement = source(d) - line.close;
+
+            if (
+                // @ts-ignore
+                (line.close >= line.open /* going up */ && priceMovement > 0) /* and moving in same direction */ ||
+                // @ts-ignore
+                (line.close < line.open /* going down */ && priceMovement < 0) /* and moving in same direction */
+            ) {
+                line.close = source(d);
+                // @ts-ignore
+                if (prevTrough && line.close < prevTrough) {
+                    // going below the prevTrough, so change from yang to yin
+                    // A yin line forms when a Kagi line breaks below the prior trough.
+                    line.changePoint = prevTrough;
+                    if (line.startAs !== "yin") {
+                        line.changeTo = "yin";
+                        // line.startAs = "yang";
+                    }
+                }
+
+                // @ts-ignore
+                if (prevPeak && line.close > prevPeak) {
+                    // going above the prevPeak, so change from yin to yang
+                    // A yang line forms when a Kagi line breaks above the prior peak
+                    line.changePoint = prevPeak;
+                    if (line.startAs !== "yang") {
+                        line.changeTo = "yang";
+                        // line.startAs = "yin";
+                    }
+                }
+            } else if (
+                // @ts-ignore
+                (line.close >= line.open /* going up */ &&
+                    priceMovement < 0 /* and moving in other direction */ &&
+                    Math.abs(priceMovement) > reversalThreshold(d)) /* and the movement is big enough for reversal */ ||
+                // @ts-ignore
+                (line.close < line.open /* going down */ &&
+                    priceMovement > 0 /* and moving in other direction */ &&
+                    /* and the movement is big enough for reversal */
+                    Math.abs(priceMovement) > reversalThreshold(d))
+            ) {
+                // reverse direction
+                const nextLineOpen = line.close;
+
+                // @ts-ignore
+                direction = (line.close - line.open) / Math.abs(line.close - line.open);
+
+                let nextChangePoint;
+                let nextChangeTo;
+                if (direction < 0 /* if direction so far has been -ve*/) {
+                    // compare with line.close becomes prevTrough
+                    if (prevPeak === undefined) {
+                        prevPeak = line.open;
+                    }
+                    prevTrough = line.close;
+                    if (source(d) > prevPeak) {
+                        nextChangePoint = prevPeak;
+                        nextChangeTo = "yang";
+                    }
+                } else {
+                    if (prevTrough === undefined) {
+                        prevTrough = line.open;
+                    }
+                    prevPeak = line.close;
+                    if (source(d) < prevTrough) {
+                        nextChangePoint = prevTrough;
+                        nextChangeTo = "yin";
+                    }
+                }
+                if (line.startAs === undefined) {
+                    line.startAs = direction > 0 ? "yang" : "yin";
+                }
+
+                const startAs = line.changeTo || line.startAs;
+                line.added = true;
+                kagiData.push(line);
+                direction = -1 * direction; // direction is reversed
+
+                line = { ...line };
+                line.open = nextLineOpen;
+                line.close = source(d);
+                line.startAs = startAs;
+                line.changePoint = nextChangePoint;
+                line.changeTo = nextChangeTo;
+                line.added = false;
+                line.from = undefined;
+                line.volume = 0;
+            } else {
+                // console.log("MOVING IN REV DIR BUT..", line.open, line.close, source(d));
+            }
+            line.current = source(d);
+            // @ts-ignore
+            let dir = line.close - line.open;
+            dir = dir === 0 ? 1 : dir / Math.abs(dir);
+            // @ts-ignore
+            line.reverseAt = dir > 0 ? line.close - reversalThreshold(d) : line.open - reversalThreshold(d);
+        });
+        if (!line.added) {
+            kagiData.push(line);
+        }
+
+        return kagiData;
+    };
+
+    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/macd.ts

@@ -0,0 +1,90 @@
+/*
+https://github.com/ScottLogic/d3fc/blob/master/src/indicator/algorithm/calculator/macd.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 { zip } from "d3-array";
+import { MACD as defaultOptions } from "./defaultOptionsForComputation";
+import ema from "./ema";
+
+export interface MACDOptions {
+    readonly fast: number;
+    readonly slow: number;
+    readonly signal: number;
+    readonly sourcePath?: string;
+}
+
+interface MACDCalculator {
+    (data: any[]): {
+        macd: number | undefined;
+        signal: number | undefined;
+        divergence: number | undefined;
+    }[];
+    undefinedLength(): number;
+    options(): MACDOptions;
+    options(newOptions: MACDOptions): MACDCalculator;
+}
+
+export default function () {
+    let options: MACDOptions = defaultOptions;
+
+    const calculator = (data: any[]) => {
+        const { fast, slow, signal, sourcePath } = options;
+
+        const fastEMA = ema().options({ windowSize: fast, sourcePath });
+
+        const slowEMA = ema().options({ windowSize: slow, sourcePath });
+
+        const signalEMA = ema().options({ windowSize: signal, sourcePath: undefined });
+
+        const diff = zip(fastEMA(data), slowEMA(data)).map((d) =>
+            d[0] !== undefined && d[1] !== undefined ? d[0] - d[1] : undefined,
+        );
+
+        const averageDiff = signalEMA(diff);
+
+        return zip(diff, averageDiff).map((d) => ({
+            macd: d[0],
+            signal: d[1],
+            divergence: d[0] !== undefined && d[1] !== undefined ? d[0] - d[1] : undefined,
+        }));
+    };
+
+    calculator.undefinedLength = () => {
+        const { slow, signal } = options;
+
+        return slow + signal - 1;
+    };
+
+    calculator.options = (newOptions?: MACDOptions) => {
+        if (newOptions === undefined) {
+            return options;
+        }
+
+        options = { ...defaultOptions, ...newOptions };
+
+        return calculator;
+    };
+
+    return calculator as MACDCalculator;
+}

package/src/calculator/pointAndFigure.ts

@@ -0,0 +1,255 @@
+import { PointAndFigure as defaultOptions } from "./defaultOptionsForComputation";
+
+function createBox(d: any, dateAccessor: any, dateMutator: any) {
+    const box = {
+        open: d.open,
+        fromDate: dateAccessor(d),
+        toDate: dateAccessor(d),
+        startOfYear: d.startOfYear,
+        startOfQuarter: d.startOfQuarter,
+        startOfMonth: d.startOfMonth,
+        startOfWeek: d.startOfWeek,
+    };
+    dateMutator(box, dateAccessor(d));
+    return box;
+}
+
+function updateColumns(columnData: any, dateAccessor: any, dateMutator: any) {
+    columnData.forEach(function (d: any) {
+        d.startOfYear = false;
+        d.startOfQuarter = false;
+        d.startOfMonth = false;
+        d.startOfWeek = false;
+
+        d.boxes.forEach(function (eachBox: any) {
+            if (d.open === undefined) {
+                d.open = eachBox.open;
+            }
+            d.close = eachBox.close;
+            d.high = Math.max(d.open, d.close);
+            d.low = Math.min(d.open, d.close);
+
+            if (d.fromDate === undefined) {
+                d.fromDate = eachBox.fromDate;
+            }
+            if (d.date === undefined) {
+                d.date = eachBox.date;
+            }
+            d.toDate = eachBox.toDate;
+
+            if (eachBox.startOfYear) {
+                d.startOfYear = d.startOfYear || eachBox.startOfYear;
+                d.startOfQuarter = eachBox.startOfQuarter;
+                d.startOfMonth = eachBox.startOfMonth;
+                d.startOfWeek = eachBox.startOfWeek;
+
+                dateMutator(d, dateAccessor(eachBox));
+            }
+            if (d.startOfQuarter !== true && eachBox.startOfQuarter) {
+                d.startOfQuarter = eachBox.startOfQuarter;
+                d.startOfMonth = eachBox.startOfMonth;
+                d.startOfWeek = eachBox.startOfWeek;
+                dateMutator(d, dateAccessor(eachBox));
+            }
+            if (d.startOfMonth !== true && eachBox.startOfMonth) {
+                d.startOfMonth = eachBox.startOfMonth;
+                d.startOfWeek = eachBox.startOfWeek;
+                dateMutator(d, dateAccessor(eachBox));
+            }
+            if (d.startOfWeek !== true && eachBox.startOfWeek) {
+                d.startOfWeek = eachBox.startOfWeek;
+                dateMutator(d, dateAccessor(eachBox));
+            }
+        });
+    });
+
+    return columnData;
+}
+
+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 { reversal, boxSize, sourcePath } = options;
+
+        const source =
+            // eslint-disable-next-line prettier/prettier
+            sourcePath === "high/low" ? ((d: any) => ({ high: d.high, low: d.low })) : ((d: any) => ({ high: d.close, low: d.close }));
+
+        const pricingMethod = source;
+        const columnData: any[] = [];
+
+        // @ts-ignore
+        let column: {
+            boxes: any[];
+            direction: any;
+            open: number;
+            close?: number;
+        } = {
+            boxes: [],
+            open: rawData[0].open,
+        };
+        let box = createBox(rawData[0], dateAccessor, dateMutator);
+
+        columnData.push(column);
+
+        rawData.forEach(function (d) {
+            // @ts-ignore
+            column.volume = (column.volume || 0) + d.volume;
+
+            if (!box.startOfYear) {
+                box.startOfYear = d.startOfYear;
+                if (box.startOfYear) {
+                    dateMutator(box, dateAccessor(d));
+                }
+            }
+
+            if (!box.startOfYear && !box.startOfQuarter) {
+                box.startOfQuarter = d.startOfQuarter;
+                if (box.startOfQuarter && !box.startOfYear) {
+                    dateMutator(box, dateAccessor(d));
+                }
+            }
+
+            if (!box.startOfQuarter && !box.startOfMonth) {
+                box.startOfMonth = d.startOfMonth;
+                if (box.startOfMonth && !box.startOfQuarter) {
+                    dateMutator(box, dateAccessor(d));
+                }
+            }
+            if (!box.startOfMonth && !box.startOfWeek) {
+                box.startOfWeek = d.startOfWeek;
+                if (box.startOfWeek && !box.startOfMonth) {
+                    dateMutator(box, dateAccessor(d));
+                }
+            }
+
+            if (columnData.length === 1 && column.boxes.length === 0) {
+                const upwardMovement = Math.max(pricingMethod(d).high - column.open, 0); // upward movement
+                const downwardMovement = Math.abs(Math.min(column.open - pricingMethod(d).low, 0)); // downward movement
+                column.direction = upwardMovement > downwardMovement ? 1 : -1;
+                if (boxSize * reversal < upwardMovement || boxSize * reversal < downwardMovement) {
+                    // enough movement to trigger a reversal
+                    box.toDate = dateAccessor(d);
+                    box.open = column.open;
+                    const noOfBoxes =
+                        column.direction > 0
+                            ? Math.floor(upwardMovement / boxSize)
+                            : Math.floor(downwardMovement / boxSize);
+                    for (let i = 0; i < noOfBoxes; i++) {
+                        // @ts-ignore
+                        box.close = box.open + column.direction * boxSize;
+                        // @ts-ignore
+                        const prevBoxClose = box.close;
+                        column.boxes.push(box);
+                        box = createBox(box, dateAccessor, dateMutator);
+                        // box = cloneMe(box);
+                        box.open = prevBoxClose;
+                    }
+                    box.fromDate = dateAccessor(d);
+                    // @ts-ignore
+                    box.date = dateAccessor(d);
+                }
+            } else {
+                // one or more boxes already formed in the current column
+                const upwardMovement = Math.max(pricingMethod(d).high - box.open, 0); // upward movement
+                const downwardMovement = Math.abs(Math.min(pricingMethod(d).low - box.open, 0)); // downward movement
+
+                if (
+                    (column.direction > 0 && upwardMovement > boxSize) /* rising column AND box can be formed */ ||
+                    (column.direction < 0 && downwardMovement > boxSize) /* falling column AND box can be formed */
+                ) {
+                    // form another box
+                    // @ts-ignore
+                    box.close = box.open + column.direction * boxSize;
+                    box.toDate = dateAccessor(d);
+
+                    // @ts-ignore
+                    const prevBoxClose = box.close;
+                    column.boxes.push(box);
+                    box = createBox(d, dateAccessor, dateMutator);
+                    box.open = prevBoxClose;
+                    box.fromDate = dateAccessor(d);
+                    dateMutator(box, dateAccessor(d));
+                } else if (
+                    /* rising column and there is downward movement to trigger a reversal */
+                    (column.direction > 0 && downwardMovement > boxSize * reversal) ||
+                    /* falling column and there is downward movement to trigger a reversal */
+                    (column.direction < 0 && upwardMovement > boxSize * reversal)
+                ) {
+                    // reversal
+
+                    box.open = box.open + -1 * column.direction * boxSize;
+                    box.toDate = dateAccessor(d);
+                    // box.displayDate = d.displayDate;
+                    dateMutator(box, dateAccessor(d));
+                    // box.startOfYear = d.startOfYear;
+                    // box.startOfQuarter = d.startOfQuarter;
+                    // box.startOfMonth = d.startOfMonth;
+                    // box.startOfWeek = d.startOfWeek;
+                    // var idx = index + 1;
+                    column = {
+                        boxes: [],
+                        // @ts-ignore
+                        volume: 0,
+                        direction: -1 * column.direction,
+                    };
+                    const noOfBoxes =
+                        column.direction > 0
+                            ? Math.floor(upwardMovement / boxSize)
+                            : Math.floor(downwardMovement / boxSize);
+                    for (let i = 0; i < noOfBoxes; i++) {
+                        // @ts-ignore
+                        box.close = box.open + column.direction * boxSize;
+                        // @ts-ignore
+                        const prevBoxClose = box.close;
+                        column.boxes.push(box);
+                        box = createBox(d, dateAccessor, dateMutator);
+                        box.open = prevBoxClose;
+                    }
+
+                    columnData.push(column);
+                }
+            }
+        });
+        updateColumns(columnData, dateAccessor, dateMutator);
+
+        return columnData;
+    };
+
+    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;
+}