aw-highstock_rails 7.0.3

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

@@ -0,0 +1,191 @@
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import requiredIndicatorMixin from '../mixins/indicator-required.js';
+
+var isArray = H.isArray,
+    EMAindicator = H.seriesTypes.ema,
+    requiredIndicator = requiredIndicatorMixin,
+    correctFloat = H.correctFloat;
+
+/**
+ * The DEMA series Type
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.dema
+ *
+ * @augments Highcharts.Series
+ */
+H.seriesType(
+    'dema',
+    'ema',
+    /**
+     * Normalized average true range indicator (NATR). This series requires
+     * `linkedTo` option to be set and should be loaded after the
+     * `stock/indicators/indicators.js` and `stock/indicators/ema.js`.
+     *
+     * @sample {highstock} stock/indicators/dema
+     *         DEMA indicator
+     *
+     * @extends      plotOptions.ema
+     * @since        7.0.0
+     * @product      highstock
+     * @excluding    allAreas, colorAxis, compare, compareBase, joinBy, keys,
+     *               navigatorOptions, pointInterval, pointIntervalUnit,
+     *               pointPlacement, pointRange, pointStart, showInNavigator,
+     *               stacking
+     * @optionparent plotOptions.dema
+     */
+    {},
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        init: function () {
+            var args = arguments,
+                ctx = this;
+
+            requiredIndicator.isParentLoaded(
+                EMAindicator,
+                'ema',
+                ctx.type,
+                function (indicator) {
+                    indicator.prototype.init.apply(ctx, args);
+                }
+            );
+        },
+        getEMA: function (
+            yVal,
+            prevEMA,
+            SMA,
+            index,
+            i,
+            xVal
+        ) {
+
+            return EMAindicator.prototype.calculateEma(
+                xVal || [],
+                yVal,
+                i === undefined ? 1 : i,
+                this.chart.series[0].EMApercent,
+                prevEMA,
+                index === undefined ? -1 : index,
+                SMA
+            );
+        },
+        getValues: function (series, params) {
+            var period = params.period,
+                doubledPeriod = 2 * period,
+                xVal = series.xData,
+                yVal = series.yData,
+                yValLen = yVal ? yVal.length : 0,
+                index = -1,
+                accumulatePeriodPoints = 0,
+                SMA = 0,
+                DEMA = [],
+                xDataDema = [],
+                yDataDema = [],
+                EMA = 0,
+                // EMA(EMA)
+                EMAlevel2,
+                // EMA of previous point
+                prevEMA,
+                prevEMAlevel2,
+                // EMA values array
+                EMAvalues = [],
+                i,
+                DEMAPoint;
+
+            series.EMApercent = (2 / (period + 1));
+
+            // Check period, if bigger than EMA points length, skip
+            if (yValLen < 2 * period - 1) {
+                return false;
+            }
+
+            // Switch index for OHLC / Candlestick / Arearange
+            if (isArray(yVal[0])) {
+                index = params.index ? params.index : 0;
+            }
+
+            // Accumulate first N-points
+            accumulatePeriodPoints =
+                EMAindicator.prototype.accumulatePeriodPoints(
+                    period,
+                    index,
+                    yVal
+                );
+
+            // first point
+            SMA = accumulatePeriodPoints / period;
+            accumulatePeriodPoints = 0;
+
+            // Calculate value one-by-one for each period in visible data
+            for (i = period; i < yValLen + 2; i++) {
+                if (i < yValLen + 1) {
+                    EMA = this.getEMA(
+                        yVal,
+                        prevEMA,
+                        SMA,
+                        index,
+                        i
+                    )[1];
+                    EMAvalues.push(EMA);
+                }
+                prevEMA = EMA;
+
+                // Summing first period points for EMA(EMA)
+                if (i < doubledPeriod) {
+                    accumulatePeriodPoints += EMA;
+                } else {
+                    // Calculate DEMA
+                    // First DEMA point
+                    if (i === doubledPeriod) {
+                        SMA = accumulatePeriodPoints / period;
+                    }
+                    EMA = EMAvalues[i - period - 1];
+                    EMAlevel2 = this.getEMA(
+                        [EMA],
+                        prevEMAlevel2,
+                        SMA
+                    )[1];
+                    DEMAPoint = [
+                        xVal[i - 2],
+                        correctFloat(2 * EMA - EMAlevel2)
+                    ];
+                    DEMA.push(DEMAPoint);
+                    xDataDema.push(DEMAPoint[0]);
+                    yDataDema.push(DEMAPoint[1]);
+                    prevEMAlevel2 = EMAlevel2;
+                }
+            }
+
+            return {
+                values: DEMA,
+                xData: xDataDema,
+                yData: yDataDema
+            };
+        }
+    }
+);
+
+/**
+ * A `DEMA` series. If the [type](#series.ema.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.ema
+ * @since     7.0.0
+ * @product   highstock
+ * @excluding allAreas, colorAxis, compare, compareBase, dataParser, dataURL,
+ *            joinBy, keys, navigatorOptions, pointInterval, pointIntervalUnit,
+ *            pointPlacement, pointRange, pointStart, showInNavigator, stacking
+ * @apioption series.dema
+ */

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

@@ -0,0 +1,138 @@
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+
+var correctFloat = H.correctFloat,
+    pick = H.pick;
+
+// Utils
+function accumulatePoints(sum, yVal, i, index, subtract) {
+    var price = pick(yVal[i][index], yVal[i]);
+
+    if (subtract) {
+        return correctFloat(sum - price);
+    }
+    return correctFloat(sum + price);
+}
+
+/**
+ * The DPO series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.dpo
+ *
+ * @augments Highcharts.Series
+ */
+H.seriesType(
+    'dpo',
+    'sma',
+    /**
+     * Detrended Price Oscillator. This series requires the `linkedTo` option to
+     * be set and should be loaded after the `stock/indicators/indicators.js`.
+     *
+     * @sample {highstock} stock/indicators/dpo
+     *         Detrended Price Oscillator
+     *
+     * @extends      plotOptions.sma
+     * @since        7.0.0
+     * @product      highstock
+     * @excluding    allAreas, colorAxis, compare, compareBase, joinBy, keys,
+     *               navigatorOptions, pointInterval, pointIntervalUnit,
+     *               pointPlacement, pointRange, pointStart, showInNavigator,
+     *               stacking
+     * @optionparent plotOptions.dpo
+     */
+    {
+        /**
+         * Parameters used in calculation of Detrended Price Oscillator series
+         * points.
+         */
+        params: {
+            /**
+             * Period for Detrended Price Oscillator
+             */
+            period: 21
+        }
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        nameBase: 'DPO',
+        getValues: function (series, params) {
+            var period = params.period,
+                index = params.index,
+                offset = Math.floor(period / 2 + 1),
+                range = period + offset,
+                xVal = series.xData || [],
+                yVal = series.yData || [],
+                yValLen = yVal.length,
+                DPO = [], // 0- date, 1- Detrended Price Oscillator
+                xData = [],
+                yData = [],
+                sum = 0,
+                oscillator,
+                periodIndex,
+                rangeIndex,
+                price,
+                i,
+                j;
+
+            if (xVal.length <= range) {
+                return false;
+            }
+
+            // Accumulate first N-points for SMA
+            for (i = 0; i < period - 1; i++) {
+                sum = accumulatePoints(sum, yVal, i, index);
+            }
+
+            // Detrended Price Oscillator formula:
+            // DPO = Price - Simple moving average [from (n / 2 + 1) days ago]
+
+            for (j = 0; j <= yValLen - range; j++) {
+                periodIndex = j + period - 1;
+                rangeIndex = j + range - 1;
+
+                // adding the last period point
+                sum = accumulatePoints(sum, yVal, periodIndex, index);
+                price = pick(yVal[rangeIndex][index], yVal[rangeIndex]);
+
+                oscillator = price - sum / period;
+
+                // substracting the first period point
+                sum = accumulatePoints(sum, yVal, j, index, true);
+
+                DPO.push([xVal[rangeIndex], oscillator]);
+                xData.push(xVal[rangeIndex]);
+                yData.push(oscillator);
+            }
+
+            return {
+                values: DPO,
+                xData: xData,
+                yData: yData
+            };
+        }
+    }
+);
+
+/**
+ * A Detrended Price Oscillator. If the [type](#series.dpo.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.dpo
+ * @since     7.0.0
+ * @product   highstock
+ * @excluding allAreas, colorAxis, compare, compareBase, dataParser, dataURL,
+ *            joinBy, keys, navigatorOptions, pointInterval, pointIntervalUnit,
+ *            pointPlacement, pointRange, pointStart, showInNavigator, stacking
+ * @apioption series.dpo
+ */

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

@@ -0,0 +1,166 @@
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+
+var isArray = H.isArray,
+    seriesType = H.seriesType,
+    correctFloat = H.correctFloat;
+
+/**
+ * The EMA series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.ema
+ *
+ * @augments Highcharts.Series
+ */
+seriesType(
+    'ema',
+    'sma',
+    /**
+     * Exponential moving average indicator (EMA). This series requires the
+     * `linkedTo` option to be set.
+     *
+     * @sample stock/indicators/ema
+     *         Exponential moving average indicator
+     *
+     * @extends      plotOptions.sma
+     * @since        6.0.0
+     * @product      highstock
+     * @optionparent plotOptions.ema
+     */
+    {
+        params: {
+            /**
+             * The point index which indicator calculations will base. For
+             * example using OHLC data, index=2 means the indicator will be
+             * calculated using Low values.
+             *
+             * By default index value used to be set to 0. Since Highstock 7
+             * by default index is set to 3 which means that the ema
+             * indicator will be calculated using Close values.
+             */
+            index: 3,
+            period: 9 // @merge 14 in v6.2
+        }
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    {
+        accumulatePeriodPoints: function (
+            period,
+            index,
+            yVal
+        ) {
+            var sum = 0,
+                i = 0,
+                y = 0;
+
+            while (i < period) {
+                y = index < 0 ? yVal[i] : yVal[i][index];
+                sum = sum + y;
+                i++;
+            }
+
+            return sum;
+        },
+        calculateEma: function (
+            xVal,
+            yVal,
+            i,
+            EMApercent,
+            calEMA,
+            index,
+            SMA
+        ) {
+            var x = xVal[i - 1],
+                yValue = index < 0 ? yVal[i - 1] : yVal[i - 1][index],
+                y;
+
+            y = calEMA === undefined ?
+                SMA : correctFloat((yValue * EMApercent) +
+                (calEMA * (1 - EMApercent)));
+
+            return [x, y];
+        },
+        getValues: function (series, params) {
+            var period = params.period,
+                xVal = series.xData,
+                yVal = series.yData,
+                yValLen = yVal ? yVal.length : 0,
+                EMApercent = 2 / (period + 1),
+                sum = 0,
+                EMA = [],
+                xData = [],
+                yData = [],
+                index = -1,
+                SMA = 0,
+                calEMA,
+                EMAPoint,
+                i;
+
+            // Check period, if bigger than points length, skip
+            if (yValLen < period) {
+                return false;
+            }
+
+            // Switch index for OHLC / Candlestick / Arearange
+            if (isArray(yVal[0])) {
+                index = params.index ? params.index : 0;
+            }
+
+            // Accumulate first N-points
+            sum = this.accumulatePeriodPoints(
+                period,
+                index,
+                yVal
+            );
+
+            // first point
+            SMA = sum / period;
+
+            // Calculate value one-by-one for each period in visible data
+            for (i = period; i < yValLen + 1; i++) {
+                EMAPoint = this.calculateEma(
+                    xVal,
+                    yVal,
+                    i,
+                    EMApercent,
+                    calEMA,
+                    index,
+                    SMA
+                );
+                EMA.push(EMAPoint);
+                xData.push(EMAPoint[0]);
+                yData.push(EMAPoint[1]);
+                calEMA = EMAPoint[1];
+            }
+
+            return {
+                values: EMA,
+                xData: xData,
+                yData: yData
+            };
+        }
+    }
+);
+
+/**
+ * A `EMA` series. If the [type](#series.ema.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.ema
+ * @since     6.0.0
+ * @product   highstock
+ * @excluding dataParser, dataURL
+ * @apioption series.ema
+ */