aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/indicators/vwap.src.js

@@ -0,0 +1,189 @@
+/* *
+ *
+ *  (c) 2010-2019 Paweł Dalek
+ *
+ *  Volume Weighted Average Price (VWAP) indicator for Highstock
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+
+var isArray = H.isArray,
+    seriesType = H.seriesType;
+
+/**
+ * The Volume Weighted Average Price (VWAP) series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.vwap
+ *
+ * @augments Highcharts.Series
+ */
+seriesType('vwap', 'sma',
+    /**
+     * Volume Weighted Average Price indicator.
+     *
+     * This series requires `linkedTo` option to be set.
+     *
+     * @sample stock/indicators/vwap
+     *         Volume Weighted Average Price indicator
+     *
+     * @extends      plotOptions.sma
+     * @since        6.0.0
+     * @product      highstock
+     * @optionparent plotOptions.vwap
+     */
+    {
+        /**
+         * @excluding index
+         */
+        params: {
+            period: 30,
+            /**
+             * The id of volume series which is mandatory. For example using
+             * OHLC data, volumeSeriesID='volume' means the indicator will be
+             * calculated using OHLC and volume values.
+             */
+            volumeSeriesID: 'volume'
+        }
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        /**
+         * Returns the final values of the indicator ready to be presented on a
+         * chart
+         * @private
+         * @param {Highcharts.Series} series - series for indicator
+         * @param {object} params - params
+         * @return {object} - computed VWAP
+         **/
+        getValues: function (series, params) {
+            var indicator = this,
+                chart = series.chart,
+                xValues = series.xData,
+                yValues = series.yData,
+                period = params.period,
+                isOHLC = true,
+                volumeSeries;
+
+            // Checks if volume series exists
+            if (!(volumeSeries = chart.get(params.volumeSeriesID))) {
+                return H.error(
+                    'Series ' +
+                    params.volumeSeriesID +
+                    ' not found! Check `volumeSeriesID`.',
+                    true,
+                    chart
+                );
+            }
+
+            // Checks if series data fits the OHLC format
+            if (!(isArray(yValues[0]))) {
+                isOHLC = false;
+            }
+
+            return indicator.calculateVWAPValues(
+                isOHLC,
+                xValues,
+                yValues,
+                volumeSeries,
+                period
+            );
+        },
+        /**
+         * Main algorithm used to calculate Volume Weighted Average Price (VWAP)
+         * values
+         * @private
+         * @param {boolean} isOHLC - says if data has OHLC format
+         * @param {Array<number>} xValues - array of timestamps
+         * @param {Array<number|Array<number,number,number,number>>} yValues -
+         * array of yValues, can be an array of a four arrays (OHLC) or array of
+         * values (line)
+         * @param {Array<*>} volumeSeries - volume series
+         * @param {number} period - number of points to be calculated
+         * @return {object} - Object contains computed VWAP
+         **/
+        calculateVWAPValues: function (
+            isOHLC,
+            xValues,
+            yValues,
+            volumeSeries,
+            period
+        ) {
+            var volumeValues = volumeSeries.yData,
+                volumeLength = volumeSeries.xData.length,
+                pointsLength = xValues.length,
+                cumulativePrice = [],
+                cumulativeVolume = [],
+                xData = [],
+                yData = [],
+                VWAP = [],
+                commonLength,
+                typicalPrice,
+                cPrice,
+                cVolume,
+                i,
+                j;
+
+            if (pointsLength <= volumeLength) {
+                commonLength = pointsLength;
+            } else {
+                commonLength = volumeLength;
+            }
+
+            for (i = 0, j = 0; i < commonLength; i++) {
+                // Depending on whether series is OHLC or line type, price is
+                // average of the high, low and close or a simple value
+                typicalPrice = isOHLC ?
+                    ((yValues[i][1] + yValues[i][2] + yValues[i][3]) / 3) :
+                    yValues[i];
+                typicalPrice *= volumeValues[i];
+
+                cPrice = j ?
+                    (cumulativePrice[i - 1] + typicalPrice) :
+                    typicalPrice;
+                cVolume = j ?
+                    (cumulativeVolume[i - 1] + volumeValues[i]) :
+                    volumeValues[i];
+
+                cumulativePrice.push(cPrice);
+                cumulativeVolume.push(cVolume);
+
+                VWAP.push([xValues[i], (cPrice / cVolume)]);
+                xData.push(VWAP[i][0]);
+                yData.push(VWAP[i][1]);
+
+                j++;
+
+                if (j === period) {
+                    j = 0;
+                }
+            }
+
+            return {
+                values: VWAP,
+                xData: xData,
+                yData: yData
+            };
+        }
+    });
+
+/**
+ * A `Volume Weighted Average Price (VWAP)` series. If the
+ * [type](#series.vwap.type) option is not specified, it is inherited from
+ * [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.vwap
+ * @since     6.0.0
+ * @product   highstock
+ * @excluding dataParser, dataURL
+ * @apioption series.vwap
+ */

data/vendor/assets/javascripts/highstock/es-modules/indicators/williams-r.src.js

@@ -0,0 +1,128 @@
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import reduceArrayMixin from '../mixins/reduce-array.js';
+
+var isArray = H.isArray,
+    getArrayExtremes = reduceArrayMixin.getArrayExtremes;
+
+/**
+ * The Williams %R series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.williamsr
+ *
+ * @augments Highcharts.Series
+ */
+H.seriesType(
+    'williamsr',
+    'sma',
+    /**
+     * Williams %R. This series requires the `linkedTo` option to be
+     * set and should be loaded after the `stock/indicators/indicators.js`.
+     *
+     * @sample {highstock} stock/indicators/williams-r
+     *         Williams %R
+     *
+     * @extends      plotOptions.sma
+     * @since        7.0.0
+     * @product      highstock
+     * @excluding    allAreas, colorAxis, joinBy, keys, navigatorOptions,
+     *               pointInterval, pointIntervalUnit, pointPlacement,
+     *               pointRange, pointStart, showInNavigator, stacking
+     * @optionparent plotOptions.williamsr
+     */
+    {
+        /**
+         * Paramters used in calculation of Williams %R series points.
+         * @excluding index
+         */
+        params: {
+            /**
+             * Period for Williams %R oscillator
+             */
+            period: 14
+        }
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        nameBase: 'Williams %R',
+        getValues: function (series, params) {
+            var period = params.period,
+                xVal = series.xData,
+                yVal = series.yData,
+                yValLen = yVal ? yVal.length : 0,
+                WR = [], // 0- date, 1- Williams %R
+                xData = [],
+                yData = [],
+                slicedY,
+                close = 3,
+                low = 2,
+                high = 1,
+                extremes,
+                R,
+                HH, // Highest high value in period
+                LL, // Lowest low value in period
+                CC, // Current close value
+                i;
+
+            // Williams %R requires close value
+            if (
+                xVal.length < period ||
+                !isArray(yVal[0]) ||
+                yVal[0].length !== 4
+            ) {
+                return false;
+            }
+
+            // For a N-period, we start from N-1 point, to calculate Nth point
+            // That is why we later need to comprehend slice() elements list
+            // with (+1)
+            for (i = period - 1; i < yValLen; i++) {
+                slicedY = yVal.slice(i - period + 1, i + 1);
+                extremes = getArrayExtremes(slicedY, low, high);
+
+                LL = extremes[0];
+                HH = extremes[1];
+                CC = yVal[i][close];
+
+                R = ((HH - CC) / (HH - LL)) * -100;
+
+                if (xVal[i]) {
+                    WR.push([xVal[i], R]);
+                    xData.push(xVal[i]);
+                    yData.push(R);
+                }
+            }
+
+            return {
+                values: WR,
+                xData: xData,
+                yData: yData
+            };
+        }
+    }
+);
+
+/**
+ * A `Williams %R Oscillator` series. If the [type](#series.williamsr.type)
+ * option is not specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.williamsr
+ * @since     7.0.0
+ * @product   highstock
+ * @excluding allAreas, colorAxis, dataParser, dataURL, joinBy, keys,
+ *            navigatorOptions, pointInterval, pointIntervalUnit,
+ *            pointPlacement, pointRange, pointStart, showInNavigator, stacking
+ * @apioption series.williamsr
+ */

data/vendor/assets/javascripts/highstock/es-modules/indicators/wma.src.js

@@ -0,0 +1,146 @@
+/* *
+ *
+ *  (c) 2010-2019 Kacper Madej
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+
+var isArray = H.isArray,
+    seriesType = H.seriesType;
+
+// Utils:
+function accumulateAverage(points, xVal, yVal, i, index) {
+    var xValue = xVal[i],
+        yValue = index < 0 ? yVal[i] : yVal[i][index];
+
+    points.push([xValue, yValue]);
+}
+
+function weightedSumArray(array, pLen) {
+    // The denominator is the sum of the number of days as a triangular number.
+    // If there are 5 days, the triangular numbers are 5, 4, 3, 2, and 1.
+    // The sum is 5 + 4 + 3 + 2 + 1 = 15.
+    var denominator = (pLen + 1) / 2 * pLen;
+
+    // reduce VS loop => reduce
+    return array.reduce(function (prev, cur, i) {
+        return [null, prev[1] + cur[1] * (i + 1)];
+    })[1] / denominator;
+}
+
+function populateAverage(points, xVal, yVal, i) {
+    var pLen = points.length,
+        wmaY = weightedSumArray(points, pLen),
+        wmaX = xVal[i - 1];
+
+    points.shift(); // remove point until range < period
+
+    return [wmaX, wmaY];
+}
+
+/**
+ * The SMA series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.wma
+ *
+ * @augments Highcharts.Series
+ */
+seriesType(
+    'wma',
+    'sma',
+    /**
+     * Weighted moving average indicator (WMA). This series requires `linkedTo`
+     * option to be set.
+     *
+     * @sample stock/indicators/wma
+     *         Weighted moving average indicator
+     *
+     * @extends      plotOptions.sma
+     * @since        6.0.0
+     * @product      highstock
+     * @optionparent plotOptions.wma
+     */
+    {
+        params: {
+            index: 3,
+            period: 9
+        }
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        getValues: function (series, params) {
+            var period = params.period,
+                xVal = series.xData,
+                yVal = series.yData,
+                yValLen = yVal ? yVal.length : 0,
+                range = 1,
+                xValue = xVal[0],
+                yValue = yVal[0],
+                WMA = [],
+                xData = [],
+                yData = [],
+                index = -1,
+                i, points, WMAPoint;
+
+            if (xVal.length < period) {
+                return false;
+            }
+
+            // Switch index for OHLC / Candlestick
+            if (isArray(yVal[0])) {
+                index = params.index;
+                yValue = yVal[0][index];
+            }
+            // Starting point
+            points = [[xValue, yValue]];
+
+            // Accumulate first N-points
+            while (range !== period) {
+                accumulateAverage(points, xVal, yVal, range, index);
+                range++;
+            }
+
+            // Calculate value one-by-one for each period in visible data
+            for (i = range; i < yValLen; i++) {
+                WMAPoint = populateAverage(points, xVal, yVal, i);
+                WMA.push(WMAPoint);
+                xData.push(WMAPoint[0]);
+                yData.push(WMAPoint[1]);
+
+                accumulateAverage(points, xVal, yVal, i, index);
+            }
+
+            WMAPoint = populateAverage(points, xVal, yVal, i);
+            WMA.push(WMAPoint);
+            xData.push(WMAPoint[0]);
+            yData.push(WMAPoint[1]);
+
+            return {
+                values: WMA,
+                xData: xData,
+                yData: yData
+            };
+        }
+    }
+);
+
+/**
+ * A `WMA` series. If the [type](#series.wma.type) option is not specified, it
+ * is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.wma
+ * @since     6.0.0
+ * @product   highstock
+ * @excluding dataParser, dataURL
+ * @apioption series.wma
+ */