aw-highstock_rails 7.0.3

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

@@ -0,0 +1,131 @@
+/* *
+ *
+ *  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 sumArray(array) {
+    return array.reduce(function (prev, cur) {
+        return prev + cur;
+    }, 0);
+}
+
+function meanDeviation(arr, sma) {
+    var len = arr.length,
+        sum = 0,
+        i;
+
+    for (i = 0; i < len; i++) {
+        sum += Math.abs(sma - (arr[i]));
+    }
+
+    return sum;
+}
+
+/**
+ * The CCI series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.cci
+ *
+ * @augments Highcharts.Series
+ */
+seriesType(
+    'cci',
+    'sma',
+    /**
+     * Commodity Channel Index (CCI). This series requires `linkedTo` option to
+     * be set.
+     *
+     * @sample stock/indicators/cci
+     *         CCI indicator
+     *
+     * @extends      plotOptions.sma
+     * @since        6.0.0
+     * @product      highstock
+     * @optionparent plotOptions.cci
+     */
+    {
+        params: {
+            period: 14
+        }
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        getValues: function (series, params) {
+            var period = params.period,
+                xVal = series.xData,
+                yVal = series.yData,
+                yValLen = yVal ? yVal.length : 0,
+                TP = [],
+                periodTP = [],
+                range = 1,
+                CCI = [],
+                xData = [],
+                yData = [],
+                CCIPoint, p, len, smaTP, TPtemp, meanDev, i;
+
+            // CCI requires close value
+            if (
+                xVal.length <= period ||
+                !isArray(yVal[0]) ||
+                yVal[0].length !== 4
+            ) {
+                return false;
+            }
+
+            // accumulate first N-points
+            while (range < period) {
+                p = yVal[range - 1];
+                TP.push((p[1] + p[2] + p[3]) / 3);
+                range++;
+            }
+
+            for (i = period; i <= yValLen; i++) {
+
+                p = yVal[i - 1];
+                TPtemp = (p[1] + p[2] + p[3]) / 3;
+                len = TP.push(TPtemp);
+                periodTP = TP.slice(len - period);
+
+                smaTP = sumArray(periodTP) / period;
+                meanDev = meanDeviation(periodTP, smaTP) / period;
+
+                CCIPoint = ((TPtemp - smaTP) / (0.015 * meanDev));
+
+                CCI.push([xVal[i - 1], CCIPoint]);
+                xData.push(xVal[i - 1]);
+                yData.push(CCIPoint);
+            }
+
+            return {
+                values: CCI,
+                xData: xData,
+                yData: yData
+            };
+        }
+    }
+);
+
+/**
+ * A `CCI` series. If the [type](#series.cci.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.cci
+ * @since     6.0.0
+ * @excluding dataParser, dataURL
+ * @product   highstock
+ * @apioption series.cci
+ */

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

@@ -0,0 +1,167 @@
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import './accumulation-distribution.src.js';
+import '../parts/Utilities.js';
+import requiredIndicatorMixin from '../mixins/indicator-required.js';
+
+var EMA = H.seriesTypes.ema,
+    AD = H.seriesTypes.ad,
+    error = H.error,
+    correctFloat = H.correctFloat,
+    requiredIndicator = requiredIndicatorMixin;
+
+/**
+ * The Chaikin series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.chaikin
+ *
+ * @augments Highcharts.Series
+ */
+H.seriesType(
+    'chaikin',
+    'ema',
+    /**
+     * Chaikin Oscillator. This series requires the `linkedTo` option to
+     * be set and should be loaded after the `stock/indicators/indicators.js`
+     * and `stock/indicators/ema.js`.
+     *
+     * @sample {highstock} stock/indicators/chaikin
+     *         Chaikin Oscillator
+     *
+     * @extends      plotOptions.ema
+     * @since        7.0.0
+     * @product      highstock
+     * @excluding    allAreas, colorAxis, joinBy, keys, navigatorOptions,
+     *               pointInterval, pointIntervalUnit, pointPlacement,
+     *               pointRange, pointStart, showInNavigator, stacking
+     * @optionparent plotOptions.chaikin
+     */
+    {
+        /**
+         * Paramters used in calculation of Chaikin Oscillator
+         * series points.
+         *
+         * @excluding index, period
+         */
+        params: {
+            /**
+             * 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',
+            /**
+             * Periods for Chaikin Oscillator calculations.
+             *
+             * @type    {Array<number>}
+             * @default [3, 10]
+             */
+            periods: [3, 10]
+        }
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        nameBase: 'Chaikin Osc',
+        nameComponents: ['periods'],
+        init: function () {
+            var args = arguments,
+                ctx = this;
+
+            requiredIndicator.isParentLoaded(
+                EMA,
+                'ema',
+                ctx.type,
+                function (indicator) {
+                    indicator.prototype.init.apply(ctx, args);
+                }
+            );
+        },
+        getValues: function (series, params) {
+            var periods = params.periods,
+                period = params.period,
+                ADL, // Accumulation Distribution Line data
+                CHA = [], // 0- date, 1- Chaikin Oscillator
+                xData = [],
+                yData = [],
+                periodsOffset,
+                SPE, // Shorter Period EMA
+                LPE, // Longer Period EMA
+                oscillator,
+                i;
+
+            // Check if periods are correct
+            if (periods.length !== 2 || periods[1] <= periods[0]) {
+                error(
+                    'Error: "Chaikin requires two periods. Notice, first ' +
+                    'period should be lower than the second one."'
+                );
+                return false;
+            }
+
+            ADL = AD.prototype.getValues.call(this, series, {
+                volumeSeriesID: params.volumeSeriesID,
+                period: period
+            });
+
+            // Check if adl is calculated properly, if not skip
+            if (!ADL) {
+                return false;
+            }
+
+            SPE = EMA.prototype.getValues.call(this, ADL, {
+                period: periods[0]
+            });
+
+            LPE = EMA.prototype.getValues.call(this, ADL, {
+                period: periods[1]
+            });
+
+            // Check if ema is calculated properly, if not skip
+            if (!SPE || !LPE) {
+                return false;
+            }
+
+            periodsOffset = periods[1] - periods[0];
+
+            for (i = 0; i < LPE.yData.length; i++) {
+                oscillator = correctFloat(
+                    SPE.yData[i + periodsOffset] - LPE.yData[i]
+                );
+
+                CHA.push([LPE.xData[i], oscillator]);
+                xData.push(LPE.xData[i]);
+                yData.push(oscillator);
+            }
+
+            return {
+                values: CHA,
+                xData: xData,
+                yData: yData
+            };
+        }
+    }
+);
+
+/**
+ * A `Chaikin Oscillator` series. If the [type](#series.chaikin.type)
+ * option is not specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.chaikin
+ * @since     7.0.0
+ * @product   highstock
+ * @excluding allAreas, colorAxis, dataParser, dataURL, joinBy, keys,
+ *            navigatorOptions, pointInterval, pointIntervalUnit,
+ *            pointPlacement, pointRange, pointStart, stacking, showInNavigator
+ * @apioption series.chaikin
+ */

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

@@ -0,0 +1,246 @@
+/* *
+ *
+ *  (c) 2010-2019 Highsoft AS
+ *
+ *  Author: Sebastian Domas
+ *
+ *  Chaikin Money Flow indicator for Highstock
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+/**
+ * @private
+ * @interface Highcharts.CmfValuesObject
+ *//**
+ * Combined xData and yData values into a tuple.
+ * @name Highcharts.CmfValuesObject#values
+ * @type {Array<Array<number,number>>}
+ *//**
+ * Values represent x timestamp values
+ * @name Highcharts.CmfValuesObject#xData
+ * @type {Array<number>}
+ *//**
+ * Values represent y values
+ * @name Highcharts.CmfValuesObject#yData
+ * @type {Array<number>}
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+
+/**
+ * The CMF series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.cmf
+ *
+ * @augments Highcharts.Series
+ */
+H.seriesType('cmf', 'sma',
+    /**
+     * Chaikin Money Flow indicator (cmf).
+     *
+     * @sample stock/indicators/cmf/
+     *         Chaikin Money Flow indicator
+     *
+     * @extends      plotOptions.sma
+     * @since        6.0.0
+     * @excluding    animationLimit
+     * @product      highstock
+     * @optionparent plotOptions.cmf
+     */
+    {
+        params: {
+            period: 14,
+            /**
+             * The id of another series to use its data as volume data for the
+             * indiator calculation.
+             */
+            volumeSeriesID: 'volume'
+        }
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        nameBase: 'Chaikin Money Flow',
+        /**
+         * Checks if the series and volumeSeries are accessible, number of
+         * points.x is longer than period, is series has OHLC data
+         * @private
+         * @return {boolean} True if series is valid and can be computed,
+         * otherwise false.
+         */
+        isValid: function () {
+            var chart = this.chart,
+                options = this.options,
+                series = this.linkedParent,
+                volumeSeries = (
+                    this.volumeSeries ||
+                    (
+                        this.volumeSeries =
+                        chart.get(options.params.volumeSeriesID)
+                    )
+                ),
+                isSeriesOHLC = (
+                    series &&
+                    series.yData &&
+                    series.yData[0].length === 4
+                );
+
+            function isLengthValid(serie) {
+                return serie.xData &&
+                    serie.xData.length >= options.params.period;
+            }
+
+            return !!(
+                series &&
+                volumeSeries &&
+                isLengthValid(series) &&
+                isLengthValid(volumeSeries) && isSeriesOHLC
+            );
+        },
+
+        /**
+         * Returns indicator's data.
+         * @private
+         * @return {boolean|Highcharts.CmfValuesObject} Returns false if the
+         * indicator is not valid, otherwise returns Values object.
+         */
+        getValues: function (series, params) {
+            if (!this.isValid()) {
+                return false;
+            }
+
+            return this.getMoneyFlow(
+                series.xData,
+                series.yData,
+                this.volumeSeries.yData,
+                params.period
+            );
+        },
+
+        /**
+         * @private
+         * @param {Array<number>} xData - x timestamp values
+         * @param {Array<number>} seriesYData - yData of basic series
+         * @param {Array<number>} volumeSeriesYData - yData of volume series
+         * @param {number} period - indicator's param
+         * @return {Highcharts.CmfValuesObject} object containing computed money
+         * flow data
+         */
+        getMoneyFlow: function (xData, seriesYData, volumeSeriesYData, period) {
+            var len = seriesYData.length,
+                moneyFlowVolume = [],
+                sumVolume = 0,
+                sumMoneyFlowVolume = 0,
+                moneyFlowXData = [],
+                moneyFlowYData = [],
+                values = [],
+                i,
+                point,
+                nullIndex = -1;
+
+            /**
+             * Calculates money flow volume, changes i, nullIndex vars from
+             * upper scope!
+             * @private
+             * @param {Array<number>} ohlc - OHLC point
+             * @param {number} volume - Volume point's y value
+             * @return {number} - volume * moneyFlowMultiplier
+             **/
+            function getMoneyFlowVolume(ohlc, volume) {
+                var high = ohlc[1],
+                    low = ohlc[2],
+                    close = ohlc[3],
+
+                    isValid =
+                        volume !== null &&
+                        high !== null &&
+                        low !== null &&
+                        close !== null &&
+                        high !== low;
+
+
+                /**
+                 * @private
+                 * @param {number} h - High value
+                 * @param {number} l - Low value
+                 * @param {number} c - Close value
+                 * @return {number} calculated multiplier for the point
+                 **/
+                function getMoneyFlowMultiplier(h, l, c) {
+                    return ((c - l) - (h - c)) / (h - l);
+                }
+
+                return isValid ?
+                    getMoneyFlowMultiplier(high, low, close) * volume :
+                    ((nullIndex = i), null);
+            }
+
+
+            if (period > 0 && period <= len) {
+                for (i = 0; i < period; i++) {
+                    moneyFlowVolume[i] = getMoneyFlowVolume(
+                        seriesYData[i],
+                        volumeSeriesYData[i]
+                    );
+                    sumVolume += volumeSeriesYData[i];
+                    sumMoneyFlowVolume += moneyFlowVolume[i];
+                }
+
+                moneyFlowXData.push(xData[i - 1]);
+                moneyFlowYData.push(
+                    i - nullIndex >= period && sumVolume !== 0 ?
+                        sumMoneyFlowVolume / sumVolume :
+                        null
+                );
+                values.push([moneyFlowXData[0], moneyFlowYData[0]]);
+
+                for (; i < len; i++) {
+                    moneyFlowVolume[i] = getMoneyFlowVolume(
+                        seriesYData[i],
+                        volumeSeriesYData[i]
+                    );
+
+                    sumVolume -= volumeSeriesYData[i - period];
+                    sumVolume += volumeSeriesYData[i];
+
+                    sumMoneyFlowVolume -= moneyFlowVolume[i - period];
+                    sumMoneyFlowVolume += moneyFlowVolume[i];
+
+                    point = [
+                        xData[i],
+                        i - nullIndex >= period ?
+                            sumMoneyFlowVolume / sumVolume :
+                            null
+                    ];
+
+                    moneyFlowXData.push(point[0]);
+                    moneyFlowYData.push(point[1]);
+                    values.push([point[0], point[1]]);
+                }
+            }
+
+            return {
+                values: values,
+                xData: moneyFlowXData,
+                yData: moneyFlowYData
+            };
+        }
+    });
+
+/**
+ * A `CMF` series. If the [type](#series.cmf.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.cmf
+ * @since     6.0.0
+ * @product   highstock
+ * @excluding dataParser, dataURL
+ * @apioption series.cmf
+ */