smartxtrader 3.8.1-xm.0

package/packages/webtrader-charts/src/indicators/macd.js

@@ -0,0 +1,188 @@
+import {uuid, toFixed} from '../common/utils.js';
+import _ from 'lodash';
+/**
+ * Created by Mahboob.M on 1/30/16.
+ */
+var MACD = function (data, options, indicators) {
+
+    options.fastMaType = (options.fastMaType || 'SMA').toUpperCase();
+    options.slowMaType = (options.slowMaType || 'SMA').toUpperCase();
+    options.signalMaType = (options.signalMaType || 'SMA').toUpperCase();
+    IndicatorBase.call(this, data, options, indicators);
+    var slowOptions = { maType: options.slowMaType, period: options.slowPeriod, appliedTo: options.appliedTo },
+        fastOprions = { maType: options.fastMaType, period: options.fastPeriod, appliedTo: options.appliedTo },
+        signalOptions = { maType: options.signalMaType, period: options.signalPeriod + options.slowPeriod - 1 };
+    this.fastMa = new window[options.fastMaType](data, fastOprions, indicators);
+    this.slowMa = new window[options.slowMaType](data, slowOptions, indicators);
+    this.histogramData = [];
+    //3 unique IDs for 3 series to be rendered
+    //macd, signal, histogarm
+    this.uniqueID = [uuid(), uuid(), uuid()];
+
+    /*
+    MACD 
+    *MACD Line: (12-day EMA - 26-day EMA)
+    * Signal Line: 9-day EMA of MACD Line
+    * MACD Histogram: MACD Line - Signal Line
+    */
+    for (var index = 0; index < data.length; index++) {
+        var macdValue = toFixed((this.fastMa.indicatorData[index].value - this.slowMa.indicatorData[index].value), 4);
+        this.indicatorData.push({ time: data[index].time, value: macdValue ,close :macdValue});
+    }
+    this.signalMa = new window[options.signalMaType](this.indicatorData, signalOptions, indicators);
+    this.signalData = this.signalMa.indicatorData;
+
+    var index = 0;
+    var _this = this;
+    this.indicatorData.forEach(function (e) {
+        var histogramValue = toFixed((e.value - _this.signalData[index].value), 4);
+        _this.histogramData.push({ time: data[index].time, value: histogramValue });
+        index++;
+    });
+};
+
+MACD.prototype = Object.create(IndicatorBase.prototype);
+MACD.prototype.constructor = MACD;
+
+MACD.prototype.addPoint = function (data) {
+    var fastMa = this.fastMa.addPoint(data)[0].value;
+    var slowMa = this.slowMa.addPoint(data)[0].value;
+    var macdValue = toFixed((fastMa - slowMa), 4);
+    var signalMa = this.signalMa.addPoint({ time: data.time, close: macdValue })[0].value;
+    var histogramValue = toFixed((macdValue - signalMa), 4);
+    this.signalData = this.signalMa.indicatorData;
+    this.histogramData.push({ time: data.time, value: histogramValue });
+    this.indicatorData.push({ time: data.time, value: macdValue });
+    return [{
+        id: this.uniqueID[0],
+        value: macdValue
+    }, {
+        id: this.uniqueID[1],
+        value: signalMa
+    }, {
+        id: this.uniqueID[2],
+        value: histogramValue
+    }];
+};
+
+MACD.prototype.update = function (data) {
+    var index = this.indicatorData.length - 1;
+    var fastMa = this.fastMa.update(data)[0].value;
+    var slowMa = this.slowMa.update(data)[0].value;
+    var macdValue = toFixed((fastMa - slowMa), 4);
+    var signalMa = this.signalMa.update({ time: data.time, close: macdValue })[0].value;
+    var histogramValue = toFixed((macdValue - signalMa), 4);
+    this.signalData = this.signalMa.indicatorData;
+    this.histogramData[index].value = histogramValue;
+    this.indicatorData[index].value = macdValue;
+    return [{
+        id: this.uniqueID[0],
+        value: macdValue
+    }, {
+        id: this.uniqueID[1],
+        value: signalMa
+    }, {
+        id: this.uniqueID[2],
+        value: histogramValue
+    }];
+};
+
+MACD.prototype.toString = function () {
+    return 'MACD (' + this.options.fastPeriod + ', ' + this.options.slowPeriod + ', ' + this.options.signalPeriod + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+/**
+ * @param indicatorMetadata
+ * @returns {*[]}
+ */
+MACD.prototype.buildSeriesAndAxisConfFromData = function (indicatorMetadata) {
+    var macdData = [];
+    //Prepare the data before sending a configuration
+    this.indicatorData.forEach(function (e) {
+        macdData.push([e.time, e.value]);
+    });
+    var signaldata = [];
+    this.signalData.forEach(function (e) {
+        signaldata.push([e.time, e.value]);
+    });
+    var histogramData = [];
+    this.histogramData.forEach(function (e) {
+        histogramData.push([e.time, e.value]);
+    });
+
+    return [{
+            axisConf: { // Secondary yAxis
+                id: indicatorMetadata.id + '-' + this.uniqueID[0],
+                title: {
+                    text: this.toString(),
+                    align: 'high',
+                    offset: 0,
+                    rotation: 0,
+                    y: 10, //Trying to show title inside the indicator chart
+                    x: 30+ this.toString().length * 7.5
+                },
+                lineWidth: 2,
+                plotLines: this.options.levels
+             }
+         },
+         {
+             seriesConf: {
+                 id: this.uniqueID[2],
+                 name: 'Histogram - ' + this.toString(),
+                 data: histogramData,
+                 type: 'column',
+                 yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                 color: this.options.macdHstgrmColor,
+                 lineWidth: this.options.strokeWidth,
+                 dashStyle: this.options.dashStyle,
+                 onChartIndicator: false
+             }
+         },
+         {
+             seriesConf: {
+                 id: this.uniqueID[0],
+                 name: 'MACD - ' + this.toString(),
+                 data: macdData,
+                 type: 'line',
+                 yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                 color: this.options.macdStroke,
+                 lineWidth: this.options.strokeWidth,
+                 dashStyle: this.options.dashStyle,
+                 onChartIndicator: false
+             }
+         },
+         {
+             seriesConf: {
+                 id: this.uniqueID[1],
+                 name: 'SIGNAL - ' + this.toString(),
+                 data: signaldata,
+                 type: 'line',
+                 yAxis: indicatorMetadata.id + '-' + this.uniqueID[0],
+                 color: this.options.signalLineStroke,
+                 lineWidth: this.options.strokeWidth,
+                 dashStyle: this.options.dashStyle,
+                 onChartIndicator: false
+             }
+         }];
+};
+
+/**
+ * This method will return all IDs that are used to identify data series configuration
+ * in the buildSeriesAndAxisConfFromData method.
+ * @returns {*[]}
+ */
+MACD.prototype.getIDs = function () {
+    return this.uniqueID;
+};
+
+/**
+ * If all the unique IDs generated by this instance is same as what is passed in the parameter,
+ * then we consider this instance to be same as what caller is looking for
+ * @param uniqueIDArr
+ * @returns {boolean}
+ */
+MACD.prototype.isSameInstance = function (uniqueIDArr) {
+    return _.isEqual(uniqueIDArr.sort(), this.uniqueID);
+};
+
+window.MACD = MACD;

package/packages/webtrader-charts/src/indicators/mama.js

@@ -0,0 +1,178 @@
+import {uuid, toFixed} from '../common/utils.js';
+/**
+ * Created by Mahboob.M on 1/30/16.
+ */
+
+var MAMA = function (data, options, indicators) {
+    IndicatorBase.call(this, data, options, indicators);
+    this.priceData = [];
+    this.smooth = [], this.detrender = [], this.period = [],
+    this.I1 = [], this.Q1 = [], this.I2 = [], this.Q2 = [],
+    this.Re = [], this.Im = [], this.smoothPeriod = [], this.phase = [];
+
+    this.CalculateMAMAValue = function (data, index) {
+        /* MAMA :
+         /*FORMULA
+         Inputs: Price((H+L)/2),   FastLimit(.5),   SlowLimit(.05);
+         Vars: Smooth(0),   Detrender(0),   I1(0),   Q1(0),   jI(0),  jQ(0),  I2(0),  Q2(0),  Re(0),   Im(0),   Period(0),  SmoothPeriod(0),  Phase(0),  DeltaPhase(0),  alpha(0),  MAMA(0),       FAMA(0);
+         If CurrentBar > 5 then begin
+         Smooth = (4*Price + 3*Price[1] + 2*Price[2] + Price[3]) / 10;
+         Detrender = (.0962*Smooth + .5769*Smooth[2] - .5769*Smooth[4] - .0962*Smooth[6])*(.075*Period[1] + .54);
+         //Compute InPhase and Quadrature components
+         Q1 = (.0962*Detrender + .5769*Detrender[2] - .5769*Detrender[4] - .0962*Detrender[6])*(.075*Period[1] + .54);
+         I1 = Detrender[3];
+         //{Advance the phase of I1 and Q1 by 90 degrees}
+         jI = (.0962*I1 + .5769*I1[2] - .5769*I1[4] - .0962*I1[6])*(.075*Period[1] + .54);
+         jQ = (.0962*Q1 + .5769*Q1[2] - .5769*Q1[4] - .0962*Q1[6])*(.075*Period[1] + .54);
+         //{Phasor addition for 3 bar averaging)}
+         I2 = I1 - jQ;
+         Q2 = Q1 + jI;
+         //{Smooth the I and Q components before applying the discriminator}
+         I2 = .2*I2 + .8*I2[1];
+         Q2 = .2*Q2 + .8*Q2[1];
+         //{Homodyne Discriminator}
+         Re = I2*I2[1] + Q2*Q2[1];
+         Im = I2*Q2[1] - Q2*I2[1];
+         Re = .2*Re + .8*Re[1];
+         Im = .2*Im + .8*Im[1];
+         If Im <> 0 and Re <> 0 then Period = 360/ArcTangent(Im/Re);
+         If Period > 1.5*Period[1] then Period = 1.5*Period[1];
+         If Period < .67*Period[1] then Period = .67*Period[1];
+         If Period < 6 then Period = 6;
+         If Period > 50 then Period = 50;
+         Period = .2*Period + .8*Period[1];
+         SmoothPeriod = .33*Period + .67*SmoothPeriod[1];
+         If I1 <> 0 then Phase = (ArcTangent(Q1 / I1));
+         DeltaPhase = Phase[1] - Phase;
+         If DeltaPhase < 1 then DeltaPhase = 1;
+         alpha = FastLimit / DeltaPhase;
+         If alpha < SlowLimit then alpha = SlowLimit;
+         MAMA = alpha*Price + (1 - alpha)*MAMA[1];
+         FAMA = .5*alpha*MAMA + (1 - .5*alpha)*FAMA[1];
+         End; */
+        var mamaValue = this.indicators.getIndicatorOrPriceValue(data[index], this.options.appliedTo);
+        if (index <= 10) {
+            this.smooth.push(0);
+            this.detrender.push(0);
+            this.I1.push(0);
+            this.Q1.push(0);
+            this.I2.push(0);
+            this.Q2.push(0);
+            this.Re.push(0);
+            this.Im.push(0);
+            this.period.push(0);
+            this.smoothPeriod.push(0);
+            this.phase.push(0);
+        }
+        else if (index > 10) {
+            this.smooth.push((4 * this.indicators.getIndicatorOrPriceValue(data[index], this.options.appliedTo)
+                + 3 * this.indicators.getIndicatorOrPriceValue(data[index - 1], this.options.appliedTo)
+                + 2 * this.indicators.getIndicatorOrPriceValue(data[index - 2], this.options.appliedTo)
+                + 1 * this.indicators.getIndicatorOrPriceValue(data[index - 3], this.options.appliedTo)) / 10);
+
+            this.detrender.push((0.0962 * this.smooth[index]
+                + 0.5769 * this.smooth[index - 2]
+                + 0.5769 * this.smooth[index - 4]
+                + 0.0962 * this.smooth[index - 6]) * (0.075 * this.period[index - 1] + 0.054));
+
+            //Compute InPhase and Quadrature components
+            this.Q1.push((0.0962 * this.detrender[index]
+                + 0.5769 * this.detrender[index - 2]
+                + 0.5769 * this.detrender[index - 4]
+                + 0.0962 * this.detrender[index - 6]) * (0.075 * this.period[index - 1] + 0.054));
+            this.I1.push(this.detrender[index - 3]);
+
+            //Advance the this.phase of this.I1 and this.Q1 by 90º
+            var jI = (0.0962 * this.I1[index]
+                + 0.5769 * this.I1[index - 2]
+                + 0.5769 * this.I1[index - 4]
+                + 0.0962 * this.I1[index - 6]) * (0.075 * this.period[index - 1] + 0.054);
+            var jQ = (0.0962 * this.Q1[index]
+                + 0.5769 * this.Q1[index - 2]
+                + 0.5769 * this.Q1[index - 4]
+                + 0.0962 * this.Q1[index - 6]) * (0.075 * this.period[index - 1] + 0.054);
+
+            //Phasor addition for 3 bar averaging
+            this.I2.push(this.I1[index] - jQ);
+            this.Q2.push(this.Q1[index] + jI);
+
+            //Smooth the I and Q components before applying the discriminator
+            this.I2[index] = 0.2 * this.I2[index] + 0.8 * this.I2[index - 1];
+            this.Q2[index] = 0.2 * this.Q2[index] + 0.8 * this.Q2[index - 1];
+
+            //{Homodyne Discriminator}
+            this.Re.push(this.I2[index] * this.I2[index - 1] + this.Q2[index] * this.Q2[index - 1]);
+            this.Im.push(this.I2[index] * this.Q2[index - 1] - this.Q2[index] * this.I2[index - 1]);
+
+            this.Re[index] = 0.2 * this.Re[index] + 0.8 * this.Re[index - 1];
+            this.Im[index] = 0.2 * this.Im[index] + 0.8 * this.Im[index - 1];
+
+            this.period.push(0);
+            if (this.Im[index] !== 0.0 && this.Re[index] !== 0.0)
+                this.period[index] = (360 / (Math.atan(this.Im[index] / this.Re[index]) * (180.0 / 3.14159265359)));
+            if (this.period[index] > 1.5 * this.period[index - 1])
+                this.period[index] = (1.5 * this.period[index - 1]);
+            if (this.period[index] < 0.67 * this.period[index - 1])
+                this.period[index] = (0.67 * this.period[index - 1]);
+            if (this.period[index] < 6)
+                this.period[index] = 6;
+            if (this.period[index] > 50)
+                this.period[index] = 50;
+            this.period[index] = 0.2 * this.period[index] + 0.8 * this.period[index - 1];
+            this.smoothPeriod.push(0.33 * this.period[index] + 0.67 * this.smoothPeriod[index - 1]);
+
+            this.phase.push(0);
+            if (this.I1[index] !== 0.0)
+                this.phase[index] = Math.atan(this.Q1[index] / this.I1[index]) * (180.0 / 3.14159265359);
+            var deltaPhase = this.phase[index - 1] - this.phase[index];
+            if (deltaPhase < 1)
+                deltaPhase = 1;
+            var alpha = this.options.fastLimit / deltaPhase;
+            if (alpha < this.options.slowLimit)
+                alpha = this.options.slowLimit;
+            if (alpha > this.options.fastLimit)
+                alpha = this.options.fastLimit;
+            mamaValue = alpha * this.indicators.getIndicatorOrPriceValue(data[index], this.options.appliedTo) + (1 - alpha) * this.indicatorData[index - 1].value;
+        }
+        return toFixed(mamaValue, 4);
+    };
+
+    for (var index = 0; index < data.length; index++) {
+        var mama = this.CalculateMAMAValue(data, index);
+        this.indicatorData.push({ time: data[index].time, value: mama });
+        this.priceData.push(data[index]);
+    }
+};
+
+MAMA.prototype = Object.create(IndicatorBase.prototype);
+MAMA.prototype.constructor = MAMA;
+
+MAMA.prototype.addPoint = function (data) {
+    this.priceData.push(data);
+    var mama = this.CalculateMAMAValue(this.priceData, this.priceData.length - 1);
+    this.indicatorData.push({ time: data.time, value: mama });
+    return [{
+        id: this.uniqueID,
+        value: mama
+    }];
+};
+
+MAMA.prototype.update = function (data) {
+    var index = this.priceData.length - 1;
+    this.priceData[index].open = data.open;
+    this.priceData[index].high = data.high;
+    this.priceData[index].low = data.low;
+    this.priceData[index].close = data.close;
+    var mama = this.CalculateMAMAValue(this.priceData, index);
+    this.indicatorData[index].value = mama;
+    return [{
+        id: this.uniqueID,
+        value: mama
+    }];
+};
+
+MAMA.prototype.toString = function () {
+    return 'MAMA (' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+window.MAMA = MAMA;

package/packages/webtrader-charts/src/indicators/mass.js

@@ -0,0 +1,93 @@
+import {uuid, toFixed} from '../common/utils.js';
+/**
+ * Created by Mahboob.M on 2/9/16.
+ */
+var MASS = function (data, options, indicators) {
+
+    options.singleMaType = (options.singleMaType || 'SMA').toUpperCase();
+    options.doubleMaType = (options.doubleMaType || 'SMA').toUpperCase();
+    IndicatorBase.call(this, data, options, indicators);
+    /*
+    Single EMA = 9-period exponential moving average (EMA) of the high-low differential  
+    Double EMA = 9-period EMA of the 9-period EMA of the high-low differential 
+    EMA Ratio = Single EMA divided by Double EMA 
+    Mass Index = 25-period sum of the EMA Ratio 
+   */
+
+    this.calculateMassValue = function (index) {
+        var sum = 0;
+        for (var i = 0; i < this.options.period ; i++) {
+            sum += this.ratioData[index - i].value;
+        };
+        return toFixed(sum, 4);
+    };
+
+    var highLowData = [];
+    for (var index = 0; index < data.length; index++) {
+        var value = data[index].high - data[index].low;
+        highLowData.push({ time: data[index].time, close: value });
+    };
+    this.singleMA = new window[options.singleMaType](highLowData, { maType: options.singleMaType, period: options.singlePeriod }, indicators)
+
+    const singleMAData = [];
+    this.singleMA.indicatorData.forEach(function (singleMA) {
+        singleMAData.push({ time: singleMA.time, close: singleMA.value });
+    });
+    this.doubleMA = new window[options.doubleMaType](singleMAData, { maType: options.doubleMaType, period: options.doublePeriod }, indicators);
+
+    var index = 0, _this = this;
+    this.ratioData = [];
+    this.singleMA.indicatorData.forEach(function (singleMA) {
+        var maRatio = 0;
+        if (_this.doubleMA.indicatorData[index].value !== 0) { maRatio = singleMA.value / _this.doubleMA.indicatorData[index].value };
+        _this.ratioData.push({ time: data[index].time, value: maRatio });
+        index++;
+    });
+
+    for (var index = 0; index < data.length; index++) {
+        if (index >= this.options.period) {
+            var mass = this.calculateMassValue(index);
+            this.indicatorData.push({ time: data[index].time, value: mass });
+        }
+        else {
+            this.indicatorData.push({ time: data[index].time, value: 0 });
+        };
+    };
+};
+
+MASS.prototype = Object.create(IndicatorBase.prototype);
+MASS.prototype.constructor = MASS;
+
+MASS.prototype.addPoint = function (data) {
+    var index = this.indicatorData.length - 1;
+    var highLowDiffValue = data.high - data.low;
+    var singleMA = this.singleMA.addPoint({ time: data.time, close: highLowDiffValue })[0].value;
+    var doubleMA = this.doubleMA.addPoint({ time: data.time, close: singleMA })[0].value;
+    this.ratioData.push({ time: data.time, value: (doubleMA !== 0 ? singleMA / doubleMA : 0) });
+    var mass = this.calculateMassValue(index);
+    this.indicatorData.push({ time: data.time, value: mass });
+    return [{
+        id: this.uniqueID,
+        value: mass,
+    }];
+};
+
+MASS.prototype.update = function (data) {
+    var index = this.indicatorData.length - 1;
+    var highLowDiffValue = data.high - data.low;
+    var singleMA = this.singleMA.update({ time: data.time, close: highLowDiffValue })[0].value;
+    var doubleMA = this.doubleMA.update({ time: data.time, close: singleMA })[0].value;
+    this.ratioData[index].value = doubleMA !== 0 ? singleMA / doubleMA : 0;
+    var mass = this.calculateMassValue(index);
+    this.indicatorData[index].value = mass;
+    return [{
+        id: this.uniqueID,
+        value: mass
+    }];
+};
+
+MASS.prototype.toString = function () {
+    return 'MASS (' + this.options.singlePeriod + ', ' + this.options.doublePeriod + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+window.MASS = MASS;

package/packages/webtrader-charts/src/indicators/max.js

@@ -0,0 +1,61 @@
+import {uuid, toFixed} from '../common/utils.js';
+/**
+ * Created by Mahboob.M on 1/29/16.
+ */
+
+var MAX = function (data, options, indicators) {
+    IndicatorBase.call(this, data, options, indicators);
+    this.priceData = [];
+    this.CalculateMAXValue = function (data, index) {
+        /* MAX :
+         max = max price over n, n - period*/
+        var max = this.indicators.getIndicatorOrPriceValue(data[index], this.options.appliedTo);
+        for (var i = 0; i < this.options.period; i++) {
+            var tempValue = this.indicators.getIndicatorOrPriceValue(data[index - i], this.options.appliedTo);
+            max = Math.max(max, tempValue);
+        }
+        return toFixed(max, 4);
+    };
+    for (var index = 0; index < data.length; index++) {
+        if (index >= (this.options.period - 1)) {
+            var max = this.CalculateMAXValue(data, index);
+            this.indicatorData.push({ time: data[index].time, value: max });
+        } else {
+            this.indicatorData.push({ time: data[index].time, value: 0.0 });
+        }
+        this.priceData.push(data[index]);
+    }
+};
+
+MAX.prototype = Object.create(IndicatorBase.prototype);
+MAX.prototype.constructor = MAX;
+
+MAX.prototype.addPoint = function (data) {
+    this.priceData.push(data);
+    var max = this.CalculateMAXValue(this.priceData, this.priceData.length - 1);
+    this.indicatorData.push({ time: data.time, value: max });
+    return [{
+        id: this.uniqueID,
+        value: max
+    }];
+};
+
+MAX.prototype.update = function (data) {
+    var index = this.priceData.length - 1;
+    this.priceData[index].open = data.open;
+    this.priceData[index].high = data.high;
+    this.priceData[index].low = data.low;
+    this.priceData[index].close = data.close;
+    var max = this.CalculateMAXValue(this.priceData, index);
+    this.indicatorData[index].value = max;
+    return [{
+        id: this.uniqueID,
+        value: max
+    }];
+};
+
+MAX.prototype.toString = function () {
+    return 'MAX (' + this.options.period + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+window.MAX = MAX;

package/packages/webtrader-charts/src/indicators/min.js

@@ -0,0 +1,61 @@
+import {uuid, toFixed} from '../common/utils.js';
+/**
+ * Created by Mahboob.M on 1/29/16.
+ */
+
+var MIN = function (data, options, indicators) {
+    IndicatorBase.call(this, data, options, indicators);
+    this.priceData = [];
+    this.CalculateMINValue = function (data, index) {
+        /* MIN :
+         min = min price over n, n - period*/
+        var min = this.indicators.getIndicatorOrPriceValue(data[index], this.options.appliedTo);
+        for (var i = 0; i < this.options.period; i++) {
+            var tempValue = this.indicators.getIndicatorOrPriceValue(data[index - i], this.options.appliedTo);
+            min = Math.min(min, tempValue);
+        }
+        return toFixed(min, 4);
+    };
+    for (var index = 0; index < data.length; index++) {
+        if (index >= (this.options.period - 1)) {
+            var min = this.CalculateMINValue(data, index);
+            this.indicatorData.push({ time: data[index].time, value: min });
+        } else {
+            this.indicatorData.push({ time: data[index].time, value: 0.0 });
+        }
+        this.priceData.push(data[index]);
+    }
+};
+
+MIN.prototype = Object.create(IndicatorBase.prototype);
+MIN.prototype.constructor = MIN;
+
+MIN.prototype.addPoint = function (data) {
+    this.priceData.push(data);
+    var min = this.CalculateMINValue(this.priceData, this.priceData.length - 1);
+    this.indicatorData.push({ time: data.time, value: min });
+    return [{
+        id: this.uniqueID,
+        value: min
+    }];
+};
+
+MIN.prototype.update = function (data) {
+    var index = this.priceData.length - 1;
+    this.priceData[index].open = data.open;
+    this.priceData[index].high = data.high;
+    this.priceData[index].low = data.low;
+    this.priceData[index].close = data.close;
+    var min = this.CalculateMINValue(this.priceData, index);
+    this.indicatorData[index].value = min;
+    return [{
+        id: this.uniqueID,
+        value: min
+    }];
+};
+
+MIN.prototype.toString = function () {
+    return 'MIN (' + this.options.period + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+window.MIN = MIN;

package/packages/webtrader-charts/src/indicators/mom.js

@@ -0,0 +1,63 @@
+import {uuid, toFixed} from '../common/utils.js';
+/**
+ * Created by Mahboob.M on 2/2/16.
+ */
+
+var MOM = function (data, options, indicators) {
+    IndicatorBase.call(this, data, options, indicators);
+    this.priceData = [];
+    /*
+    * Formula(OHLC or Candlestick) -
+    * 	MOM = CLOSE(i) - CLOSE(i-N)*100
+    * 		n - period
+    */
+    for (var index = 0; index < data.length; index++) {
+        if (index >= (this.options.period)) {
+            var price = this.indicators.getIndicatorOrPriceValue(data[index], this.options.appliedTo);
+            var nPrePrice = this.indicators.getIndicatorOrPriceValue(data[index - this.options.period], this.options.appliedTo);
+            var mom = toFixed(((price - nPrePrice) * 100), 4);
+            this.indicatorData.push({ time: data[index].time, value: mom });
+        } else {
+            this.indicatorData.push({ time: data[index].time, value: 0.0 });
+        }
+        this.priceData.push(data[index]);
+    }
+};
+
+MOM.prototype = Object.create(IndicatorBase.prototype);
+MOM.prototype.constructor = MOM;
+
+MOM.prototype.addPoint = function (data) {
+    this.priceData.push(data);
+    var index = this.priceData.length - 1;
+    var price = this.indicators.getIndicatorOrPriceValue(this.priceData[index], this.options.appliedTo);
+    var nPrePrice = this.indicators.getIndicatorOrPriceValue(this.priceData[index - this.options.period], this.options.appliedTo);
+    var mom = toFixed(((price - nPrePrice) * 100), 4);
+    this.indicatorData.push({ time: data.time, value: mom });
+    return [{
+        id: this.uniqueID,
+        value: mom
+    }];
+};
+
+MOM.prototype.update = function (data) {
+    var index = this.priceData.length - 1;
+    this.priceData[index].open = data.open;
+    this.priceData[index].high = data.high;
+    this.priceData[index].low = data.low;
+    this.priceData[index].close = data.close;
+    var price = this.indicators.getIndicatorOrPriceValue(this.priceData[index], this.options.appliedTo);
+    var nPrePrice = this.indicators.getIndicatorOrPriceValue(this.priceData[index - this.options.period], this.options.appliedTo);
+    var mom = toFixed(((price - nPrePrice) * 100), 4);
+    this.indicatorData[index].value = mom;
+    return [{
+        id: this.uniqueID,
+        value: mom
+    }];
+};
+
+MOM.prototype.toString = function () {
+    return 'MOM (' + this.options.period + ', ' + this.indicators.appliedPriceString(this.options.appliedTo) + ')';
+};
+
+window.MOM = MOM;