talib.js

var semver = require("semver");
var _ = require('lodash');

// validate that talib is installed, if not we'll throw an exception which will
// prevent further loading or out outside this module
try {
    var talib = require("talib");
} catch (e) {
    module.exports = null;
    return;
}

var talibError = 'Gekko was unable to configure talib indicator:\n\t';
var talibGTEv103 = semver.gte(talib.version, '1.0.3');

// Wrapper that executes a talib indicator
var execute = function(callback, params) {
    // talib callback style since talib-v1.0.3
    var talibCallback = function(err, result) {
        if(err) return callback(err);
        callback(null, result.result);
    };

    // talib legacy callback style before talib-v1.0.3
    var talibLegacyCallback = function(result) {
        var error = result.error;
        talibCallback.apply(this, [error, result]);
    };

    return talib.execute(params, talibGTEv103 ? talibCallback : talibLegacyCallback);
}

// Helper that makes sure all required parameters
// for a specific talib indicator are present.
var verifyParams = (methodName, params) => {
    var requiredParams = methods[methodName].requires;

    _.each(requiredParams, paramName => {
        if(!_.has(params, paramName)) {
            throw new Error(talibError + methodName + ' requires ' + paramName + '.');
        }

        var val = params[paramName];

        if(!_.isNumber(val)) {
            throw new Error(talibError + paramName + ' needs to be a number');
        }
    });
}

var methods = {};


//////////////////////////////Pattern Recognition//////////////////////////////
methods.cdl2crows = {
    requires: [],
    create: (params) => {
        verifyParams('cdl2crows', params);
        return (data, callback) => execute(callback, {
            name: "CDL2CROWS",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdl3blackcrows = {
    requires: [],
    create: (params) => {
        verifyParams('cdl3blackcrows', params);
        return (data, callback) => execute(callback, {
            name: "CDL3BLACKCROWS",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdl3inside = {
    requires: [],
    create: (params) => {
        verifyParams('cdl3inside', params);
        return (data, callback) => execute(callback, {
            name: "CDL3INSIDE",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdl3linestrike = {
    requires: [],
    create: (params) => {
        verifyParams('cdl3linestrike', params);
        return (data, callback) => execute(callback, {
            name: "CDL3LINESTRIKE",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdl3outside = {
    requires: [],
    create: (params) => {
        verifyParams('cdl3outside', params);
        return (data, callback) => execute(callback, {
            name: "CDL3OUTSIDE",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdl3starsinsouth = {
    requires: [],
    create: (params) => {
        verifyParams('cdl3starsinsouth', params);
        return (data, callback) => execute(callback, {
            name: "CDL3STARSINSOUTH",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdl3whitesoldiers = {
    requires: [],
    create: (params) => {
        verifyParams('cdl3whitesoldiers', params);
        return (data, callback) => execute(callback, {
            name: "CDL3WHITESOLDIERS",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlabandonedbaby = {
    requires: ['optInPenetration'],
    create: (params) => {
        verifyParams('cdlabandonedbaby', params);
        return (data, callback) => execute(callback, {
            name: "CDLABANDONEDBABY",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            optInPenetration: params.optInPenetration
        });
    }
}
methods.cdladvanceblock = {
    requires: [],
    create: (params) => {
        verifyParams('cdladvanceblock', params);
        return (data, callback) => execute(callback, {
            name: "CDLADVANCEBLOCK",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlbelthold = {
    requires: [],
    create: (params) => {
        verifyParams('cdlbelthold', params);
        return (data, callback) => execute(callback, {
            name: "CDLBELTHOLD",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlbreakaway = {
    requires: [],
    create: (params) => {
        verifyParams('cdlbreakaway', params);
        return (data, callback) => execute(callback, {
            name: "CDLBREAKAWAY",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlclosingmarubozu = {
    requires: [],
    create: (params) => {
        verifyParams('cdlclosingmarubozu', params);
        return (data, callback) => execute(callback, {
            name: "CDLCLOSINGMARUBOZU",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlconcealbabyswall = {
    requires: [],
    create: (params) => {
        verifyParams('cdlconcealbabyswall', params);
        return (data, callback) => execute(callback, {
            name: "CDLCONCEALBABYSWALL",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlcounterattack = {
    requires: [],
    create: (params) => {
        verifyParams('cdlcounterattack', params);
        return (data, callback) => execute(callback, {
            name: "CDLCOUNTERATTACK",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdldarkcloudcover = {
    requires: ['optInPenetration'],
    create: (params) => {
        verifyParams('cdldarkcloudcover', params);
        return (data, callback) => execute(callback, {
            name: "CDLDARKCLOUDCOVER",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            optInPenetration: params.optInPenetration
        });
    }
}
methods.cdldoji = {
    requires: [],
    create: (params) => {
        verifyParams('cdldoji', params);
        return (data, callback) => execute(callback, {
            name: "CDLDOJI",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdldojistar = {
    requires: [],
    create: (params) => {
        verifyParams('cdldojistar', params);
        return (data, callback) => execute(callback, {
            name: "CDLDOJISTAR",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdldragonflydoji = {
    requires: [],
    create: (params) => {
        verifyParams('cdldragonflydoji', params);
        return (data, callback) => execute(callback, {
            name: "CDLDRAGONFLYDOJI",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlengulfing = {
    requires: [],
    create: (params) => {
        verifyParams('cdlengulfing', params);
        return (data, callback) => execute(callback, {
            name: "CDLENGULFING",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdleveningdojistar = {
    requires: ['optInPenetration'],
    create: (params) => {
        verifyParams('cdleveningdojistar', params);
        return (data, callback) => execute(callback, {
            name: "CDLEVENINGDOJISTAR",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            optInPenetration: params.optInPenetration
        });
    }
}
methods.cdleveningstar = {
    requires: ['optInPenetration'],
    create: (params) => {
        verifyParams('cdleveningstar', params);
        return (data, callback) => execute(callback, {
            name: "CDLEVENINGSTAR",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            optInPenetration: params.optInPenetration
        });
    }
}
methods.cdlgapsidesidewhite = {
    requires: [],
    create: (params) => {
        verifyParams('cdlgapsidesidewhite', params);
        return (data, callback) => execute(callback, {
            name: "CDLGAPSIDESIDEWHITE",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlgravestonedoji = {
    requires: [],
    create: (params) => {
        verifyParams('cdlgravestonedoji', params);
        return (data, callback) => execute(callback, {
            name: "CDLGRAVESTONEDOJI",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlhammer = {
    requires: [],
    create: (params) => {
        verifyParams('cdlhammer', params);
        return (data, callback) => execute(callback, {
            name: "CDLHAMMER",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlhangingman = {
    requires: [],
    create: (params) => {
        verifyParams('cdlhangingman', params);
        return (data, callback) => execute(callback, {
            name: "CDLHANGINGMAN",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlharami = {
    requires: [],
    create: (params) => {
        verifyParams('cdlharami', params);
        return (data, callback) => execute(callback, {
            name: "CDLHARAMI",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlharamicross = {
    requires: [],
    create: (params) => {
        verifyParams('cdlharamicross', params);
        return (data, callback) => execute(callback, {
            name: "CDLHARAMICROSS",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlhighwave = {
    requires: [],
    create: (params) => {
        verifyParams('cdlhighwave', params);
        return (data, callback) => execute(callback, {
            name: "CDLHIGHWAVE",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlhikkake = {
    requires: [],
    create: (params) => {
        verifyParams('cdlhikkake', params);
        return (data, callback) => execute(callback, {
            name: "CDLHIKKAKE",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlhikkakemod = {
    requires: [],
    create: (params) => {
        verifyParams('cdlhikkakemod', params);
        return (data, callback) => execute(callback, {
            name: "CDLHIKKAKEMOD",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlhomingpigeon = {
    requires: [],
    create: (params) => {
        verifyParams('cdlhomingpigeon', params);
        return (data, callback) => execute(callback, {
            name: "CDLHOMINGPIGEON",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlidentical3crows = {
    requires: [],
    create: (params) => {
        verifyParams('cdlidentical3crows', params);
        return (data, callback) => execute(callback, {
            name: "CDLIDENTICAL3CROWS",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlinneck = {
    requires: [],
    create: (params) => {
        verifyParams('cdlinneck', params);
        return (data, callback) => execute(callback, {
            name: "CDLINNECK",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlinvertedhammer = {
    requires: [],
    create: (params) => {
        verifyParams('cdlinvertedhammer', params);
        return (data, callback) => execute(callback, {
            name: "CDLINVERTEDHAMMER",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlkicking = {
    requires: [],
    create: (params) => {
        verifyParams('cdlkicking', params);
        return (data, callback) => execute(callback, {
            name: "CDLKICKING",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlkickingbylength = {
    requires: [],
    create: (params) => {
        verifyParams('cdlkickingbylength', params);
        return (data, callback) => execute(callback, {
            name: "CDLKICKINGBYLENGTH",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlladderbottom = {
    requires: [],
    create: (params) => {
        verifyParams('cdlladderbottom', params);
        return (data, callback) => execute(callback, {
            name: "CDLLADDERBOTTOM",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdllongleggeddoji = {
    requires: [],
    create: (params) => {
        verifyParams('cdllongleggeddoji', params);
        return (data, callback) => execute(callback, {
            name: "CDLLONGLEGGEDDOJI",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdllongline = {
    requires: [],
    create: (params) => {
        verifyParams('cdllongline', params);
        return (data, callback) => execute(callback, {
            name: "CDLLONGLINE",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlmarubozu = {
    requires: [],
    create: (params) => {
        verifyParams('cdlmarubozu', params);
        return (data, callback) => execute(callback, {
            name: "CDLMARUBOZU",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlmatchinglow = {
    requires: [],
    create: (params) => {
        verifyParams('cdlmatchinglow', params);
        return (data, callback) => execute(callback, {
            name: "CDLMATCHINGLOW",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlmathold = {
    requires: ['optInPenetration'],
    create: (params) => {
        verifyParams('cdlmathold', params);
        return (data, callback) => execute(callback, {
            name: "CDLMATHOLD",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            optInPenetration: params.optInPenetration
        });
    }
}
methods.cdlmorningdojistar = {
    requires: ['optInPenetration'],
    create: (params) => {
        verifyParams('cdlmorningdojistar', params);
        return (data, callback) => execute(callback, {
            name: "CDLMORNINGDOJISTAR",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            optInPenetration: params.optInPenetration
        });
    }
}
methods.cdlmorningstar = {
    requires: ['optInPenetration'],
    create: (params) => {
        verifyParams('cdlmorningstar', params);
        return (data, callback) => execute(callback, {
            name: "CDLMORNINGSTAR",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            optInPenetration: params.optInPenetration
        });
    }
}
methods.cdlonneck = {
    requires: [],
    create: (params) => {
        verifyParams('cdlonneck', params);
        return (data, callback) => execute(callback, {
            name: "CDLONNECK",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlpiercing = {
    requires: [],
    create: (params) => {
        verifyParams('cdlpiercing', params);
        return (data, callback) => execute(callback, {
            name: "CDLPIERCING",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlrickshawman = {
    requires: [],
    create: (params) => {
        verifyParams('cdlrickshawman', params);
        return (data, callback) => execute(callback, {
            name: "CDLRICKSHAWMAN",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlrisefall3methods = {
    requires: [],
    create: (params) => {
        verifyParams('cdlrisefall3methods', params);
        return (data, callback) => execute(callback, {
            name: "CDLRISEFALL3METHODS",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlseparatinglines = {
    requires: [],
    create: (params) => {
        verifyParams('cdlseparatinglines', params);
        return (data, callback) => execute(callback, {
            name: "CDLSEPARATINGLINES",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlshootingstar = {
    requires: [],
    create: (params) => {
        verifyParams('cdlshootingstar', params);
        return (data, callback) => execute(callback, {
            name: "CDLSHOOTINGSTAR",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlshortline = {
    requires: [],
    create: (params) => {
        verifyParams('cdlshortline', params);
        return (data, callback) => execute(callback, {
            name: "CDLSHORTLINE",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlspinningtop = {
    requires: [],
    create: (params) => {
        verifyParams('cdlspinningtop', params);
        return (data, callback) => execute(callback, {
            name: "CDLSPINNINGTOP",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlstalledpattern = {
    requires: [],
    create: (params) => {
        verifyParams('cdlstalledpattern', params);
        return (data, callback) => execute(callback, {
            name: "CDLSTALLEDPATTERN",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlsticksandwich = {
    requires: [],
    create: (params) => {
        verifyParams('cdlsticksandwich', params);
        return (data, callback) => execute(callback, {
            name: "CDLSTICKSANDWICH",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdltakuri = {
    requires: [],
    create: (params) => {
        verifyParams('cdltakuri', params);
        return (data, callback) => execute(callback, {
            name: "CDLTAKURI",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdltasukigap = {
    requires: [],
    create: (params) => {
        verifyParams('cdltasukigap', params);
        return (data, callback) => execute(callback, {
            name: "CDLTASUKIGAP",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlthrusting = {
    requires: [],
    create: (params) => {
        verifyParams('cdlthrusting', params);
        return (data, callback) => execute(callback, {
            name: "CDLTHRUSTING",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdltristar = {
    requires: [],
    create: (params) => {
        verifyParams('cdltristar', params);
        return (data, callback) => execute(callback, {
            name: "CDLTRISTAR",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlunique3river = {
    requires: [],
    create: (params) => {
        verifyParams('cdlunique3river', params);
        return (data, callback) => execute(callback, {
            name: "CDLUNIQUE3RIVER",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlupsidegap2crows = {
    requires: [],
    create: (params) => {
        verifyParams('cdlupsidegap2crows', params);
        return (data, callback) => execute(callback, {
            name: "CDLUPSIDEGAP2CROWS",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}
methods.cdlxsidegap3methods = {
    requires: [],
    create: (params) => {
        verifyParams('cdlxsidegap3methods', params);
        return (data, callback) => execute(callback, {
            name: "CDLXSIDEGAP3METHODS",
            startIdx: 0,
            endIdx: data.close.length - 1,
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close
        });
    }
}

//////////////////////////////Pattern Recognition//////////////////////////////

methods.accbands = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('accbands', params);

        return (data, callback) => execute(callback, {
            name: "ACCBANDS",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.ad = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('accbands', params);

        return (data, callback) => execute(callback, {
            name: "AD",
            high: data.high,
            low: data.low,
            close: data.close,
            volume: data.volume,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.adosc = {
    requires: ['optInFastPeriod', 'optInSlowPeriod'],
    create: (params) => {
        verifyParams('adosc', params);

        return (data, callback) => execute(callback, {
            name: "ADOSC",
            high: data.high,
            low: data.low,
            close: data.close,
            volume: data.volume,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInFastPeriod: params.optInFastPeriod,
            optInSlowPeriod: params.optInSlowPeriod
        });
    }
}

methods.adx = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('adx', params);

        return (data, callback) => execute(callback, {
            name: "ADX",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.adxr = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('adxr', params);

        return (data, callback) => execute(callback, {
            name: "ADXR",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.apo = {
    requires: ['optInFastPeriod', 'optInSlowPeriod', 'optInMAType'],
    create: (params) => {
        verifyParams('apo', params);

        return (data, callback) => execute(callback, {
            name: "APO",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.length - 1,
            optInFastPeriod: params.optInFastPeriod,
            optInSlowPeriod: params.optInSlowPeriod,
            optInMAType: params.optInMAType
        });
    }
}

methods.aroon = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('aroon', params);

        return (data, callback) => execute(callback, {
            name: "AROON",
            high: data.high,
            low: data.low,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.aroonosc = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('aroonosc', params);

        return (data, callback) => execute(callback, {
            name: "AROONOSC",
            high: data.high,
            low: data.low,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.atr = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('atr', params);

        return (data, callback) => execute(callback, {
            name: "ATR",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.avgprice = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('avgprice', params);

        return (data, callback) => execute(callback, {
            name: "AVGPRICE",
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.open.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.bbands = {
    requires: ['optInTimePeriod', 'optInNbDevUp', 'optInNbDevDn', 'optInMAType'],
    create: (params) => {
        verifyParams('bbands', params);

        return (data, callback) => execute(callback, {
            name: "BBANDS",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod,
            optInNbDevUp: params.optInNbDevUp,
            optInNbDevDn: params.optInNbDevDn,
            optInMAType: params.optInMAType
        });
    }
}

///////////////////////////////////////////////////////////////


// this.beta = function(data_0, data_1, period) {
//     return talibWrapper({
//         name: "BETA",
//         inReal0: data_0,
//         inReal1: data_1,
//         startIdx: 0,
//         endIdx: data_0.length - 1,
//         optInTimePeriod: period
//     });
// };

methods.bop = {
    requires: [],
    create: (params) => {
        verifyParams('bop', params);

        return (data, callback) => execute(callback, {
            name: "BOP",
            open: data.open,
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1
        });
    }
}

methods.cci = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('cci', params);

        return (data, callback) => execute(callback, {
            name: "CCI",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.cmo = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('cmo', params);

        return (data, callback) => execute(callback, {
            name: "CMO",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

// this.correl = function(data_0, data_1, period) {
//     return talibWrapper({
//         name: "CORREL",
//         inReal0: data_0,
//         inReal1: data_1,
//         startIdx: 0,
//         endIdx: data_0.length - 1,
//         optInTimePeriod: period
//     });
// };

methods.dema = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('dema', params);

        return (data, callback) => execute(callback, {
            name: "DEMA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.dx = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('dx', params);

        return (data, callback) => execute(callback, {
            name: "DX",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.ema = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('ema', params);

        return (data, callback) => execute(callback, {
            name: "EMA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.ht_dcperiod = {
    requires: [],
    create: (params) => {
        verifyParams('ht_dcperiod', params);

        return (data, callback) => execute(callback, {
            name: "HT_DCPERIOD",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1
        });
    }
}

methods.ht_dcphase = {
    requires: [],
    create: (params) => {
        verifyParams('ht_dcphase', params);

        return (data, callback) => execute(callback, {
            name: "HT_DCPHASE",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1
        });
    }
}

methods.ht_phasor = {
    requires: [],
    create: (params) => {
        verifyParams('ht_phasor', params);

        return (data, callback) => execute(callback, {
            name: "HT_PHASOR",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1
        });
    }
}

methods.ht_sine = {
    requires: [],
    create: (params) => {
        verifyParams('ht_sine', params);

        return (data, callback) => execute(callback, {
            name: "HT_SINE",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1
        });
    }
}


methods.ht_trendline = {
    requires: [],
    create: (params) => {
        verifyParams('ht_trendline', params);

        return (data, callback) => execute(callback, {
            name: "HT_TRENDLINE",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1
        });
    }
}

methods.ht_trendmode = {
    requires: [],
    create: (params) => {
        verifyParams('ht_trendmode', params);

        return (data, callback) => execute(callback, {
            name: "HT_TRENDMODE",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1
        });
    }
}

methods.imi = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('imi', params);

        return (data, callback) => execute(callback, {
            name: "IMI",
            open: data.open,
            close: data.close,
            startIdx: 0,
            endIdx: data.open.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.kama = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('kama', params);

        return (data, callback) => execute(callback, {
            name: "KAMA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.linearreg = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('linearreg', params);

        return (data, callback) => execute(callback, {
            name: "LINEARREG",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.linearreg_angle = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('linearreg_angle', params);

        return (data, callback) => execute(callback, {
            name: "LINEARREG_ANGLE",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.linearreg_intercept = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('linearreg_intercept', params);

        return (data, callback) => execute(callback, {
            name: "LINEARREG_INTERCEPT",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.linearreg_slope = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('linearreg_slope', params);

        return (data, callback) => execute(callback, {
            name: "LINEARREG_SLOPE",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.ma = {
    requires: ['optInTimePeriod', 'optInMAType'],
    create: (params) => {
        verifyParams('ma', params);

        return (data, callback) => execute(callback, {
            name: "MA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod,
            optInMAType: params.optInMAType
        });
    }
}

methods.macd = {
    requires: ['optInFastPeriod', 'optInSlowPeriod', 'optInSignalPeriod'],
    create: (params) => {
        verifyParams('macd', params);

        return (data, callback) => execute(callback, {
            name: "MACD",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInFastPeriod: params.optInFastPeriod,
            optInSlowPeriod: params.optInSlowPeriod,
            optInSignalPeriod: params.optInSignalPeriod
        });
    }
}

methods.macdext = {
    requires: [
        'optInFastPeriod',
        'optInFastMAType',
        'optInSlowPeriod',
        'optInSlowMAType',
        'optInSignalPeriod',
        'optInSignalMAType'
    ],
    create: (params) => {
        verifyParams('macdext', params);

        return (data, callback) => execute(callback, {
            name: "MACDEXT",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInFastPeriod: params.optInFastPeriod,
            optInFastMAType: params.optInFastMAType,
            optInSlowPeriod: params.optInSlowPeriod,
            optInSlowMAType: params.optInSlowMAType,
            optInSignalPeriod: params.optInSignalPeriod,
            optInSignalMAType: params.optInSignalMAType
        });
    }
}

methods.macdfix = {
    requires: ['optInSignalPeriod'],
    create: (params) => {
        verifyParams('macdfix', params);

        return (data, callback) => execute(callback, {
            name: "MACDFIX",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInSignalPeriod: params.optInSignalPeriod
        });
    }
}

methods.mama = {
    requires: ['optInFastLimit', 'optInSlowLimit'],
    create: (params) => {
        verifyParams('mama', params);

        return (data, callback) => execute(callback, {
            name: "MAMA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInFastLimit: params.optInFastLimit,
            optInSlowLimit: params.optInSlowLimit
        });
    }
}

methods.mavp = {
    requires: ['inPeriods', 'optInMinPeriod', 'optInMaxPeriod', 'optInMAType'],
    create: (params) => {
        verifyParams('mavp', params);

        return (data, callback) => execute(callback, {
            name: "MAVP",
            inReal: data.close,
            inPeriods: params.inPeriods,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInMinPeriod: params.optInMinPeriod,
            optInMaxPeriod: params.optInMaxPeriod,
            optInMAType: params.optInMAType
        });
    }
}


methods.max = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('max', params);

        return (data, callback) => execute(callback, {
            name: "MAX",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}


methods.maxindex = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('maxindex', params);

        return (data, callback) => execute(callback, {
            name: "MAXINDEX",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.medprice = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('medprice', params);

        return (data, callback) => execute(callback, {
            name: "MEDPRICE",
            high: data.high,
            low: data.low,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.mfi = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('mfi', params);

        return (data, callback) => execute(callback, {
            name: "MFI",
            high: data.high,
            low: data.low,
            close: data.close,
            volume: data.volume,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.midpoint = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('midpoint', params);

        return (data, callback) => execute(callback, {
            name: "MIDPOINT",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.midprice = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('midprice', params);

        return (data, callback) => execute(callback, {
            name: "MIDPRICE",
            high: data.high,
            low: data.low,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.min = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('min', params);

        return (data, callback) => execute(callback, {
            name: "MIN",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.minindex = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('minindex', params);

        return (data, callback) => execute(callback, {
            name: "MININDEX",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.minmax = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('minmax', params);

        return (data, callback) => execute(callback, {
            name: "MINMAX",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.minmaxindex = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('minmaxindex', params);

        return (data, callback) => execute(callback, {
            name: "MINMAXINDEX",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.minus_di = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('minus_di', params);

        return (data, callback) => execute(callback, {
            name: "MINUS_DI",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.minus_dm = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('minus_dm', params);

        return (data, callback) => execute(callback, {
            name: "MINUS_DM",
            high: data.high,
            low: data.low,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.mom = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('mom', params);

        return (data, callback) => execute(callback, {
            name: "MOM",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.natr = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('natr', params);

        return (data, callback) => execute(callback, {
            name: "NATR",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.obv = {
    requires: [],
    create: (params) => {
        verifyParams('obv', params);

        return (data, callback) => execute(callback, {
            name: "OBV",
            inReal: data.close,
            volume: data.volume,
            startIdx: 0,
            endIdx: data.close.length - 1
        });
    }
}

methods.plus_di = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('plus_di', params);

        return (data, callback) => execute(callback, {
            name: "PLUS_DI",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.plus_dm = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('plus_dm', params);

        return (data, callback) => execute(callback, {
            name: "PLUS_DM",
            high: data.high,
            low: data.low,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.ppo = {
    requires: ['optInFastPeriod', 'optInSlowPeriod', 'optInMAType'],
    create: (params) => {
        verifyParams('ppo', params);

        return (data, callback) => execute(callback, {
            name: "PPO",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInFastPeriod: params.optInFastPeriod,
            optInSlowPeriod: params.optInSlowPeriod,
            optInMAType: params.optInMAType
        });
    }
}

methods.roc = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('roc', params);

        return (data, callback) => execute(callback, {
            name: "ROC",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.rocp = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('rocp', params);

        return (data, callback) => execute(callback, {
            name: "ROCP",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.rocr = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('rocr', params);

        return (data, callback) => execute(callback, {
            name: "ROCR",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.rocr100 = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('rocr100', params);

        return (data, callback) => execute(callback, {
            name: "ROCR100",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.rsi = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('rsi', params);

        return (data, callback) => execute(callback, {
            name: "RSI",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.sar = {
    requires: ['optInAcceleration', 'optInMaximum'],
    create: (params) => {
        verifyParams('sar', params);

        return (data, callback) => execute(callback, {
            name: "SAR",
            high: data.high,
            low: data.low,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInAcceleration: params.optInAcceleration,
            optInMaximum: params.optInMaximum
        });
    }
}

methods.sarext = {
    requires: [
        'optInStartValue',
        'optInOffsetOnReverse',
        'optInAccelerationInitLong',
        'optInAccelerationLong',
        'optInAccelerationMaxLong',
        'optInAccelerationInitShort',
        'optInAccelerationShort',
        'optInAccelerationMaxShort'

    ],
    create: (params) => {
        verifyParams('sarext', params);

        return (data, callback) => execute(callback, {
            name: "SAREXT",
            high: data.high,
            low: data.low,
            startIdx: 0,
            endIdx: data.high.length - 1,

            optInStartValue: params.optInStartValue,
            optInOffsetOnReverse: params.optInOffsetOnReverse,
            optInAccelerationInitLong: params.optInAccelerationInitLong,
            optInAccelerationLong: params.optInAccelerationLong,
            optInAccelerationMaxLong: params.optInAccelerationMaxLong,
            optInAccelerationInitShort: params.optInAccelerationInitShort,
            optInAccelerationShort: params.optInAccelerationShort,
            optInAccelerationMaxShort: params.optInAccelerationMaxShort
        });
    }
}

methods.sma = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('sma', params);

        return (data, callback) => execute(callback, {
            name: "SMA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.stddev = {
    requires: ['optInTimePeriod', 'optInNbDev'],
    create: (params) => {
        verifyParams('stddev', params);

        return (data, callback) => execute(callback, {
            name: "STDDEV",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod,
            optInNbDev: params.optInNbDev
        });
    }
}

methods.stoch = {
    requires: [
        'optInFastK_Period',
        'optInSlowK_Period',
        'optInSlowK_MAType',
        'optInSlowD_Period',
        'optInSlowD_MAType'
    ],
    create: (params) => {
        verifyParams('stoch', params);

        return (data, callback) => execute(callback, {
            name: "STOCH",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,

            optInFastK_Period: params.optInFastK_Period,
            optInSlowK_Period: params.optInSlowK_Period,
            optInSlowK_MAType: params.optInSlowK_MAType,
            optInSlowD_Period: params.optInSlowD_Period,
            optInSlowD_MAType: params.optInSlowD_MAType
        });
    }
}


methods.stochf = {
    requires: [
        'optInFastK_Period',
        'optInFastD_Period',
        'optInFastD_MAType'
    ],
    create: (params) => {
        verifyParams('stochf', params);

        return (data, callback) => execute(callback, {
            name: "STOCHF",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,

            optInFastK_Period: params.optInFastK_Period,
            optInFastD_Period: params.optInFastD_Period,
            optInFastD_MAType: params.optInFastD_MAType
        });
    }
}

methods.stochrsi = {
    requires: [
        'optInTimePeriod',
        'optInFastK_Period',
        'optInFastD_Period',
        'optInFastD_MAType'
    ],
    create: (params) => {
        verifyParams('stochrsi', params);

        return (data, callback) => execute(callback, {
            name: "STOCHRSI",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,

            optInTimePeriod: params.optInTimePeriod,
            optInFastK_Period: params.optInFastK_Period,
            optInFastD_Period: params.optInFastD_Period,
            optInFastD_MAType: params.optInFastD_MAType
        });
    }
}

methods.t3 = {
    requires: [
        'optInTimePeriod',
        'optInFastK_Period',
        'optInFastD_Period',
        'optInFastD_MAType'
    ],
    create: (params) => {
        verifyParams('t3', params);

        return (data, callback) => execute(callback, {
            name: "T3",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod,
            optInVFactor: params.optInVFactor
        });
    }
}

methods.tema = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('tema', params);

        return (data, callback) => execute(callback, {
            name: "TEMA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.trange = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('trange', params);

        return (data, callback) => execute(callback, {
            name: "TRANGE",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.trima = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('trima', params);

        return (data, callback) => execute(callback, {
            name: "TRIMA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.trix = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('trix', params);

        return (data, callback) => execute(callback, {
            name: "TRIX",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.tsf = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('tsf', params);

        return (data, callback) => execute(callback, {
            name: "TSF",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.typprice = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('typprice', params);

        return (data, callback) => execute(callback, {
            name: "TYPPRICE",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.ultosc = {
    requires: ['optInTimePeriod1', 'optInTimePeriod2', 'optInTimePeriod3'],
    create: (params) => {
        verifyParams('ultosc', params);

        return (data, callback) => execute(callback, {
            name: "ULTOSC",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod1: params.optInTimePeriod1,
            optInTimePeriod2: params.optInTimePeriod2,
            optInTimePeriod3: params.optInTimePeriod3
        });
    }
}

methods.variance = {
    requires: ['optInTimePeriod', 'optInNbDev'],
    create: (params) => {
        verifyParams('variance', params);

        return (data, callback) => execute(callback, {
            name: "VAR",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod,
            optInNbDev: params.optInTimePeriod
        });
    }
}

methods.wclprice = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('wclprice', params);

        return (data, callback) => execute(callback, {
            name: "WCLPRICE",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.willr = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('willr', params);

        return (data, callback) => execute(callback, {
            name: "WILLR",
            high: data.high,
            low: data.low,
            close: data.close,
            startIdx: 0,
            endIdx: data.high.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

methods.wma = {
    requires: ['optInTimePeriod'],
    create: (params) => {
        verifyParams('wma', params);

        return (data, callback) => execute(callback, {
            name: "WMA",
            inReal: data.close,
            startIdx: 0,
            endIdx: data.close.length - 1,
            optInTimePeriod: params.optInTimePeriod
        });
    }
}

module.exports = methods;