hot-formula-parser
Version:
2,092 lines (1,783 loc) • 425 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define("formulaParser", [], factory);
else if(typeof exports === 'object')
exports["formulaParser"] = factory();
else
root["formulaParser"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 15);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {
exports.nil = new Error('#NULL!');
exports.div0 = new Error('#DIV/0!');
exports.value = new Error('#VALUE!');
exports.ref = new Error('#REF!');
exports.name = new Error('#NAME?');
exports.num = new Error('#NUM!');
exports.na = new Error('#N/A');
exports.error = new Error('#ERROR!');
exports.data = new Error('#GETTING_DATA');
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
var error = __webpack_require__(0);
exports.flattenShallow = function(array) {
if (!array || !array.reduce) {
return array;
}
return array.reduce(function(a, b) {
var aIsArray = Array.isArray(a);
var bIsArray = Array.isArray(b);
if (aIsArray && bIsArray ) {
return a.concat(b);
}
if (aIsArray) {
a.push(b);
return a;
}
if (bIsArray) {
return [a].concat(b);
}
return [a, b];
});
};
exports.isFlat = function(array) {
if (!array) {
return false;
}
for (var i = 0; i < array.length; ++i) {
if (Array.isArray(array[i])) {
return false;
}
}
return true;
};
exports.flatten = function() {
var result = exports.argsToArray.apply(null, arguments);
while (!exports.isFlat(result)) {
result = exports.flattenShallow(result);
}
return result;
};
exports.argsToArray = function(args) {
var result = [];
exports.arrayEach(args, function(value) {
result.push(value);
});
return result;
};
exports.numbers = function() {
var possibleNumbers = this.flatten.apply(null, arguments);
return possibleNumbers.filter(function(el) {
return typeof el === 'number';
});
};
exports.cleanFloat = function(number) {
var power = 1e14;
return Math.round(number * power) / power;
};
exports.parseBool = function(bool) {
if (typeof bool === 'boolean') {
return bool;
}
if (bool instanceof Error) {
return bool;
}
if (typeof bool === 'number') {
return bool !== 0;
}
if (typeof bool === 'string') {
var up = bool.toUpperCase();
if (up === 'TRUE') {
return true;
}
if (up === 'FALSE') {
return false;
}
}
if (bool instanceof Date && !isNaN(bool)) {
return true;
}
return error.value;
};
exports.parseNumber = function(string) {
if (string === undefined || string === '') {
return error.value;
}
if (!isNaN(string)) {
return parseFloat(string);
}
return error.value;
};
exports.parseNumberArray = function(arr) {
var len;
if (!arr || (len = arr.length) === 0) {
return error.value;
}
var parsed;
while (len--) {
parsed = exports.parseNumber(arr[len]);
if (parsed === error.value) {
return parsed;
}
arr[len] = parsed;
}
return arr;
};
exports.parseMatrix = function(matrix) {
var n;
if (!matrix || (n = matrix.length) === 0) {
return error.value;
}
var pnarr;
for (var i = 0; i < matrix.length; i++) {
pnarr = exports.parseNumberArray(matrix[i]);
matrix[i] = pnarr;
if (pnarr instanceof Error) {
return pnarr;
}
}
return matrix;
};
var d1900 = new Date(Date.UTC(1900, 0, 1));
exports.parseDate = function(date) {
if (!isNaN(date)) {
if (date instanceof Date) {
return new Date(date);
}
var d = parseInt(date, 10);
if (d < 0) {
return error.num;
}
if (d <= 60) {
return new Date(d1900.getTime() + (d - 1) * 86400000);
}
return new Date(d1900.getTime() + (d - 2) * 86400000);
}
if (typeof date === 'string') {
date = new Date(date);
if (!isNaN(date)) {
return date;
}
}
return error.value;
};
exports.parseDateArray = function(arr) {
var len = arr.length;
var parsed;
while (len--) {
parsed = this.parseDate(arr[len]);
if (parsed === error.value) {
return parsed;
}
arr[len] = parsed;
}
return arr;
};
exports.anyIsError = function() {
var n = arguments.length;
while (n--) {
if (arguments[n] instanceof Error) {
return true;
}
}
return false;
};
exports.arrayValuesToNumbers = function(arr) {
var n = arr.length;
var el;
while (n--) {
el = arr[n];
if (typeof el === 'number') {
continue;
}
if (el === true) {
arr[n] = 1;
continue;
}
if (el === false) {
arr[n] = 0;
continue;
}
if (typeof el === 'string') {
var number = this.parseNumber(el);
if (number instanceof Error) {
arr[n] = 0;
} else {
arr[n] = number;
}
}
}
return arr;
};
exports.rest = function(array, idx) {
idx = idx || 1;
if (!array || typeof array.slice !== 'function') {
return array;
}
return array.slice(idx);
};
exports.initial = function(array, idx) {
idx = idx || 1;
if (!array || typeof array.slice !== 'function') {
return array;
}
return array.slice(0, array.length - idx);
};
exports.arrayEach = function(array, iteratee) {
var index = -1, length = array.length;
while (++index < length) {
if (iteratee(array[index], index, array) === false) {
break;
}
}
return array;
};
exports.transpose = function(matrix) {
if(!matrix) {
return error.value;
}
return matrix[0].map(function(col, i) {
return matrix.map(function(row) {
return row[i];
});
});
};
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
exports["default"] = error;
exports.isValidStrict = isValidStrict;
exports.ERROR_VALUE = exports.ERROR_REF = exports.ERROR_NUM = exports.ERROR_NULL = exports.ERROR_NOT_AVAILABLE = exports.ERROR_NAME = exports.ERROR_DIV_ZERO = exports.ERROR = void 0;
var _errors;
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var ERROR = 'ERROR';
exports.ERROR = ERROR;
var ERROR_DIV_ZERO = 'DIV/0';
exports.ERROR_DIV_ZERO = ERROR_DIV_ZERO;
var ERROR_NAME = 'NAME';
exports.ERROR_NAME = ERROR_NAME;
var ERROR_NOT_AVAILABLE = 'N/A';
exports.ERROR_NOT_AVAILABLE = ERROR_NOT_AVAILABLE;
var ERROR_NULL = 'NULL';
exports.ERROR_NULL = ERROR_NULL;
var ERROR_NUM = 'NUM';
exports.ERROR_NUM = ERROR_NUM;
var ERROR_REF = 'REF';
exports.ERROR_REF = ERROR_REF;
var ERROR_VALUE = 'VALUE';
exports.ERROR_VALUE = ERROR_VALUE;
var errors = (_errors = {}, _defineProperty(_errors, ERROR, '#ERROR!'), _defineProperty(_errors, ERROR_DIV_ZERO, '#DIV/0!'), _defineProperty(_errors, ERROR_NAME, '#NAME?'), _defineProperty(_errors, ERROR_NOT_AVAILABLE, '#N/A'), _defineProperty(_errors, ERROR_NULL, '#NULL!'), _defineProperty(_errors, ERROR_NUM, '#NUM!'), _defineProperty(_errors, ERROR_REF, '#REF!'), _defineProperty(_errors, ERROR_VALUE, '#VALUE!'), _errors);
/**
* Return error type based on provided error id.
*
* @param {String} type Error type.
* @returns {String|null} Returns error id.
*/
function error(type) {
var result;
type = (type + '').replace(/#|!|\?/g, '');
if (errors[type]) {
result = errors[type];
}
return result ? result : null;
}
/**
* Check if error type is strict valid with knows errors.
*
* @param {String} Error type.
* @return {Boolean}
*/
function isValidStrict(type) {
var valid = false;
for (var i in errors) {
if (Object.prototype.hasOwnProperty.call(errors, i) && errors[i] === type) {
valid = true;
break;
}
}
return valid;
}
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
exports.toNumber = toNumber;
exports.invertNumber = invertNumber;
/**
* Convert value into number.
*
* @param {String|Number} number
* @returns {*}
*/
function toNumber(number) {
var result;
if (typeof number === 'number') {
result = number;
} else if (typeof number === 'string') {
result = number.indexOf('.') > -1 ? parseFloat(number) : parseInt(number, 10);
}
return result;
}
/**
* Invert provided number.
*
* @param {Number} number
* @returns {Number} Returns inverted number.
*/
function invertNumber(number) {
return -1 * toNumber(number);
}
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
var utils = __webpack_require__(1);
var error = __webpack_require__(0);
var statistical = __webpack_require__(5);
var information = __webpack_require__(8);
var evalExpression = __webpack_require__(7);
exports.ABS = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var result = Math.abs(number);
return result;
};
exports.ACOS = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var result = Math.acos(number);
if (isNaN(result)) {
result = error.num;
}
return result;
};
exports.ACOSH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var result = Math.log(number + Math.sqrt(number * number - 1));
if (isNaN(result)) {
result = error.num;
}
return result;
};
exports.ACOT = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var result = Math.atan(1 / number);
return result;
};
exports.ACOTH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var result = 0.5 * Math.log((number + 1) / (number - 1));
if (isNaN(result)) {
result = error.num;
}
return result;
};
//TODO: use options
exports.AGGREGATE = function(function_num, options, ref1, ref2) {
function_num = utils.parseNumber(function_num);
options = utils.parseNumber(function_num);
if (utils.anyIsError(function_num, options)) {
return error.value;
}
switch (function_num) {
case 1:
return statistical.AVERAGE(ref1);
case 2:
return statistical.COUNT(ref1);
case 3:
return statistical.COUNTA(ref1);
case 4:
return statistical.MAX(ref1);
case 5:
return statistical.MIN(ref1);
case 6:
return exports.PRODUCT(ref1);
case 7:
return statistical.STDEV.S(ref1);
case 8:
return statistical.STDEV.P(ref1);
case 9:
return exports.SUM(ref1);
case 10:
return statistical.VAR.S(ref1);
case 11:
return statistical.VAR.P(ref1);
case 12:
return statistical.MEDIAN(ref1);
case 13:
return statistical.MODE.SNGL(ref1);
case 14:
return statistical.LARGE(ref1, ref2);
case 15:
return statistical.SMALL(ref1, ref2);
case 16:
return statistical.PERCENTILE.INC(ref1, ref2);
case 17:
return statistical.QUARTILE.INC(ref1, ref2);
case 18:
return statistical.PERCENTILE.EXC(ref1, ref2);
case 19:
return statistical.QUARTILE.EXC(ref1, ref2);
}
};
exports.ARABIC = function(text) {
// Credits: Rafa? Kukawski
if (!/^M*(?:D?C{0,3}|C[MD])(?:L?X{0,3}|X[CL])(?:V?I{0,3}|I[XV])$/.test(text)) {
return error.value;
}
var r = 0;
text.replace(/[MDLV]|C[MD]?|X[CL]?|I[XV]?/g, function(i) {
r += {
M: 1000,
CM: 900,
D: 500,
CD: 400,
C: 100,
XC: 90,
L: 50,
XL: 40,
X: 10,
IX: 9,
V: 5,
IV: 4,
I: 1
}[i];
});
return r;
};
exports.ASIN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var result = Math.asin(number);
if (isNaN(result)) {
result = error.num;
}
return result;
};
exports.ASINH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.log(number + Math.sqrt(number * number + 1));
};
exports.ATAN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.atan(number);
};
exports.ATAN2 = function(number_x, number_y) {
number_x = utils.parseNumber(number_x);
number_y = utils.parseNumber(number_y);
if (utils.anyIsError(number_x, number_y)) {
return error.value;
}
return Math.atan2(number_x, number_y);
};
exports.ATANH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var result = Math.log((1 + number) / (1 - number)) / 2;
if (isNaN(result)) {
result = error.num;
}
return result;
};
exports.BASE = function(number, radix, min_length) {
min_length = min_length || 0;
number = utils.parseNumber(number);
radix = utils.parseNumber(radix);
min_length = utils.parseNumber(min_length);
if (utils.anyIsError(number, radix, min_length)) {
return error.value;
}
min_length = (min_length === undefined) ? 0 : min_length;
var result = number.toString(radix);
return new Array(Math.max(min_length + 1 - result.length, 0)).join('0') + result;
};
exports.CEILING = function(number, significance, mode) {
significance = (significance === undefined) ? 1 : Math.abs(significance);
mode = mode || 0;
number = utils.parseNumber(number);
significance = utils.parseNumber(significance);
mode = utils.parseNumber(mode);
if (utils.anyIsError(number, significance, mode)) {
return error.value;
}
if (significance === 0) {
return 0;
}
var precision = -Math.floor(Math.log(significance) / Math.log(10));
if (number >= 0) {
return exports.ROUND(Math.ceil(number / significance) * significance, precision);
} else {
if (mode === 0) {
return -exports.ROUND(Math.floor(Math.abs(number) / significance) * significance, precision);
} else {
return -exports.ROUND(Math.ceil(Math.abs(number) / significance) * significance, precision);
}
}
};
exports.CEILING.MATH = exports.CEILING;
exports.CEILING.PRECISE = exports.CEILING;
exports.COMBIN = function(number, number_chosen) {
number = utils.parseNumber(number);
number_chosen = utils.parseNumber(number_chosen);
if (utils.anyIsError(number, number_chosen)) {
return error.value;
}
return exports.FACT(number) / (exports.FACT(number_chosen) * exports.FACT(number - number_chosen));
};
exports.COMBINA = function(number, number_chosen) {
number = utils.parseNumber(number);
number_chosen = utils.parseNumber(number_chosen);
if (utils.anyIsError(number, number_chosen)) {
return error.value;
}
return (number === 0 && number_chosen === 0) ? 1 : exports.COMBIN(number + number_chosen - 1, number - 1);
};
exports.COS = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.cos(number);
};
exports.COSH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return (Math.exp(number) + Math.exp(-number)) / 2;
};
exports.COT = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return 1 / Math.tan(number);
};
exports.COTH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var e2 = Math.exp(2 * number);
return (e2 + 1) / (e2 - 1);
};
exports.CSC = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return 1 / Math.sin(number);
};
exports.CSCH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return 2 / (Math.exp(number) - Math.exp(-number));
};
exports.DECIMAL = function(number, radix) {
if (arguments.length < 1) {
return error.value;
}
return parseInt(number, radix);
};
exports.DEGREES = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return number * 180 / Math.PI;
};
exports.EVEN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return exports.CEILING(number, -2, -1);
};
exports.EXP = function(number) {
if (arguments.length < 1) {
return error.na;
}
if (typeof number !== 'number' || arguments.length > 1) {
return error.error;
}
number = Math.exp(number);
return number;
};
var MEMOIZED_FACT = [];
exports.FACT = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var n = Math.floor(number);
if (n === 0 || n === 1) {
return 1;
} else if (MEMOIZED_FACT[n] > 0) {
return MEMOIZED_FACT[n];
} else {
MEMOIZED_FACT[n] = exports.FACT(n - 1) * n;
return MEMOIZED_FACT[n];
}
};
exports.FACTDOUBLE = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var n = Math.floor(number);
if (n <= 0) {
return 1;
} else {
return n * exports.FACTDOUBLE(n - 2);
}
};
exports.FLOOR = function(number, significance) {
number = utils.parseNumber(number);
significance = utils.parseNumber(significance);
if (utils.anyIsError(number, significance)) {
return error.value;
}
if (significance === 0) {
return 0;
}
if (!(number > 0 && significance > 0) && !(number < 0 && significance < 0)) {
return error.num;
}
significance = Math.abs(significance);
var precision = -Math.floor(Math.log(significance) / Math.log(10));
if (number >= 0) {
return exports.ROUND(Math.floor(number / significance) * significance, precision);
} else {
return -exports.ROUND(Math.ceil(Math.abs(number) / significance), precision);
}
};
//TODO: Verify
exports.FLOOR.MATH = function(number, significance, mode) {
significance = (significance === undefined) ? 1 : significance;
mode = (mode === undefined) ? 0 : mode;
number = utils.parseNumber(number);
significance = utils.parseNumber(significance);
mode = utils.parseNumber(mode);
if (utils.anyIsError(number, significance, mode)) {
return error.value;
}
if (significance === 0) {
return 0;
}
significance = significance ? Math.abs(significance) : 1;
var precision = -Math.floor(Math.log(significance) / Math.log(10));
if (number >= 0) {
return exports.ROUND(Math.floor(number / significance) * significance, precision);
} else if (mode === 0 || mode === undefined) {
return -exports.ROUND(Math.ceil(Math.abs(number) / significance) * significance, precision);
}
return -exports.ROUND(Math.floor(Math.abs(number) / significance) * significance, precision);
};
// Deprecated
exports.FLOOR.PRECISE = exports.FLOOR.MATH;
// adapted http://rosettacode.org/wiki/Greatest_common_divisor#JavaScript
exports.GCD = function() {
var range = utils.parseNumberArray(utils.flatten(arguments));
if (range instanceof Error) {
return range;
}
var n = range.length;
var r0 = range[0];
var x = r0 < 0 ? -r0 : r0;
for (var i = 1; i < n; i++) {
var ri = range[i];
var y = ri < 0 ? -ri : ri;
while (x && y) {
if (x > y) {
x %= y;
} else {
y %= x;
}
}
x += y;
}
return x;
};
exports.INT = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.floor(number);
};
//TODO: verify
exports.ISO = {
CEILING: exports.CEILING
};
exports.LCM = function() {
// Credits: Jonas Raoni Soares Silva
var o = utils.parseNumberArray(utils.flatten(arguments));
if (o instanceof Error) {
return o;
}
for (var i, j, n, d, r = 1;
(n = o.pop()) !== undefined;) {
while (n > 1) {
if (n % 2) {
for (i = 3, j = Math.floor(Math.sqrt(n)); i <= j && n % i; i += 2) {
//empty
}
d = (i <= j) ? i : n;
} else {
d = 2;
}
for (n /= d, r *= d, i = o.length; i;
(o[--i] % d) === 0 && (o[i] /= d) === 1 && o.splice(i, 1)) {
//empty
}
}
}
return r;
};
exports.LN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.log(number);
};
exports.LN10 = function() {
return Math.log(10);
};
exports.LN2 = function() {
return Math.log(2);
};
exports.LOG10E = function() {
return Math.LOG10E;
};
exports.LOG2E = function() {
return Math.LOG2E;
};
exports.LOG = function(number, base) {
number = utils.parseNumber(number);
base = utils.parseNumber(base);
if (utils.anyIsError(number, base)) {
return error.value;
}
base = (base === undefined) ? 10 : base;
return Math.log(number) / Math.log(base);
};
exports.LOG10 = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.log(number) / Math.log(10);
};
exports.MOD = function(dividend, divisor) {
dividend = utils.parseNumber(dividend);
divisor = utils.parseNumber(divisor);
if (utils.anyIsError(dividend, divisor)) {
return error.value;
}
if (divisor === 0) {
return error.div0;
}
var modulus = Math.abs(dividend % divisor);
return (divisor > 0) ? modulus : -modulus;
};
exports.MROUND = function(number, multiple) {
number = utils.parseNumber(number);
multiple = utils.parseNumber(multiple);
if (utils.anyIsError(number, multiple)) {
return error.value;
}
if (number * multiple < 0) {
return error.num;
}
return Math.round(number / multiple) * multiple;
};
exports.MULTINOMIAL = function() {
var args = utils.parseNumberArray(utils.flatten(arguments));
if (args instanceof Error) {
return args;
}
var sum = 0;
var divisor = 1;
for (var i = 0; i < args.length; i++) {
sum += args[i];
divisor *= exports.FACT(args[i]);
}
return exports.FACT(sum) / divisor;
};
exports.ODD = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var temp = Math.ceil(Math.abs(number));
temp = (temp & 1) ? temp : temp + 1;
return (number > 0) ? temp : -temp;
};
exports.PI = function() {
return Math.PI;
};
exports.E = function() {
return Math.E;
};
exports.POWER = function(number, power) {
number = utils.parseNumber(number);
power = utils.parseNumber(power);
if (utils.anyIsError(number, power)) {
return error.value;
}
var result = Math.pow(number, power);
if (isNaN(result)) {
return error.num;
}
return result;
};
exports.PRODUCT = function() {
var args = utils.parseNumberArray(utils.flatten(arguments));
if (args instanceof Error) {
return args;
}
var result = 1;
for (var i = 0; i < args.length; i++) {
result *= args[i];
}
return result;
};
exports.QUOTIENT = function(numerator, denominator) {
numerator = utils.parseNumber(numerator);
denominator = utils.parseNumber(denominator);
if (utils.anyIsError(numerator, denominator)) {
return error.value;
}
return parseInt(numerator / denominator, 10);
};
exports.RADIANS = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return number * Math.PI / 180;
};
exports.RAND = function() {
return Math.random();
};
exports.RANDBETWEEN = function(bottom, top) {
bottom = utils.parseNumber(bottom);
top = utils.parseNumber(top);
if (utils.anyIsError(bottom, top)) {
return error.value;
}
// Creative Commons Attribution 3.0 License
// Copyright (c) 2012 eqcode
return bottom + Math.ceil((top - bottom + 1) * Math.random()) - 1;
};
// TODO
exports.ROMAN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
// The MIT License
// Copyright (c) 2008 Steven Levithan
var digits = String(number).split('');
var key = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'];
var roman = '';
var i = 3;
while (i--) {
roman = (key[+digits.pop() + (i * 10)] || '') + roman;
}
return new Array(+digits.join('') + 1).join('M') + roman;
};
exports.ROUND = function(number, digits) {
number = utils.parseNumber(number);
digits = utils.parseNumber(digits);
if (utils.anyIsError(number, digits)) {
return error.value;
}
return Math.round(number * Math.pow(10, digits)) / Math.pow(10, digits);
};
exports.ROUNDDOWN = function(number, digits) {
number = utils.parseNumber(number);
digits = utils.parseNumber(digits);
if (utils.anyIsError(number, digits)) {
return error.value;
}
var sign = (number > 0) ? 1 : -1;
return sign * (Math.floor(Math.abs(number) * Math.pow(10, digits))) / Math.pow(10, digits);
};
exports.ROUNDUP = function(number, digits) {
number = utils.parseNumber(number);
digits = utils.parseNumber(digits);
if (utils.anyIsError(number, digits)) {
return error.value;
}
var sign = (number > 0) ? 1 : -1;
return sign * (Math.ceil(Math.abs(number) * Math.pow(10, digits))) / Math.pow(10, digits);
};
exports.SEC = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return 1 / Math.cos(number);
};
exports.SECH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return 2 / (Math.exp(number) + Math.exp(-number));
};
exports.SERIESSUM = function(x, n, m, coefficients) {
x = utils.parseNumber(x);
n = utils.parseNumber(n);
m = utils.parseNumber(m);
coefficients = utils.parseNumberArray(coefficients);
if (utils.anyIsError(x, n, m, coefficients)) {
return error.value;
}
var result = coefficients[0] * Math.pow(x, n);
for (var i = 1; i < coefficients.length; i++) {
result += coefficients[i] * Math.pow(x, n + i * m);
}
return result;
};
exports.SIGN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
if (number < 0) {
return -1;
} else if (number === 0) {
return 0;
} else {
return 1;
}
};
exports.SIN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.sin(number);
};
exports.SINH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return (Math.exp(number) - Math.exp(-number)) / 2;
};
exports.SQRT = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
if (number < 0) {
return error.num;
}
return Math.sqrt(number);
};
exports.SQRTPI = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.sqrt(number * Math.PI);
};
exports.SQRT1_2 = function() {
return 1 / Math.sqrt(2);
};
exports.SQRT2 = function() {
return Math.sqrt(2);
};
exports.SUBTOTAL = function(function_code, ref1) {
function_code = utils.parseNumber(function_code);
if (function_code instanceof Error) {
return function_code;
}
switch (function_code) {
case 1:
return statistical.AVERAGE(ref1);
case 2:
return statistical.COUNT(ref1);
case 3:
return statistical.COUNTA(ref1);
case 4:
return statistical.MAX(ref1);
case 5:
return statistical.MIN(ref1);
case 6:
return exports.PRODUCT(ref1);
case 7:
return statistical.STDEV.S(ref1);
case 8:
return statistical.STDEV.P(ref1);
case 9:
return exports.SUM(ref1);
case 10:
return statistical.VAR.S(ref1);
case 11:
return statistical.VAR.P(ref1);
// no hidden values for us
case 101:
return statistical.AVERAGE(ref1);
case 102:
return statistical.COUNT(ref1);
case 103:
return statistical.COUNTA(ref1);
case 104:
return statistical.MAX(ref1);
case 105:
return statistical.MIN(ref1);
case 106:
return exports.PRODUCT(ref1);
case 107:
return statistical.STDEV.S(ref1);
case 108:
return statistical.STDEV.P(ref1);
case 109:
return exports.SUM(ref1);
case 110:
return statistical.VAR.S(ref1);
case 111:
return statistical.VAR.P(ref1);
}
};
exports.ADD = function (num1, num2) {
if (arguments.length !== 2) {
return error.na;
}
num1 = utils.parseNumber(num1);
num2 = utils.parseNumber(num2);
if (utils.anyIsError(num1, num2)) {
return error.value;
}
return num1 + num2;
};
exports.MINUS = function (num1, num2) {
if (arguments.length !== 2) {
return error.na;
}
num1 = utils.parseNumber(num1);
num2 = utils.parseNumber(num2);
if (utils.anyIsError(num1, num2)) {
return error.value;
}
return num1 - num2;
};
exports.DIVIDE = function (dividend, divisor) {
if (arguments.length !== 2) {
return error.na;
}
dividend = utils.parseNumber(dividend);
divisor = utils.parseNumber(divisor);
if (utils.anyIsError(dividend, divisor)) {
return error.value;
}
if (divisor === 0) {
return error.div0;
}
return dividend / divisor;
};
exports.MULTIPLY = function (factor1, factor2) {
if (arguments.length !== 2) {
return error.na;
}
factor1 = utils.parseNumber(factor1);
factor2 = utils.parseNumber(factor2);
if (utils.anyIsError(factor1, factor2)) {
return error.value;
}
return factor1 * factor2;
};
exports.GTE = function (num1, num2) {
if (arguments.length !== 2) {
return error.na;
}
num1 = utils.parseNumber(num1);
num2 = utils.parseNumber(num2);
if (utils.anyIsError(num1, num2)) {
return error.error;
}
return num1 >= num2;
};
exports.LT = function (num1, num2) {
if (arguments.length !== 2) {
return error.na;
}
num1 = utils.parseNumber(num1);
num2 = utils.parseNumber(num2);
if (utils.anyIsError(num1, num2)) {
return error.error;
}
return num1 < num2;
};
exports.LTE = function (num1, num2) {
if (arguments.length !== 2) {
return error.na;
}
num1 = utils.parseNumber(num1);
num2 = utils.parseNumber(num2);
if (utils.anyIsError(num1, num2)) {
return error.error;
}
return num1 <= num2;
};
exports.EQ = function (value1, value2) {
if (arguments.length !== 2) {
return error.na;
}
return value1 === value2;
};
exports.NE = function (value1, value2) {
if (arguments.length !== 2) {
return error.na;
}
return value1 !== value2;
};
exports.POW = function (base, exponent) {
if (arguments.length !== 2) {
return error.na;
}
base = utils.parseNumber(base);
exponent = utils.parseNumber(exponent);
if (utils.anyIsError(base, exponent)) {
return error.error;
}
return exports.POWER(base, exponent);
};
exports.SUM = function() {
var result = 0;
utils.arrayEach(utils.argsToArray(arguments), function(value) {
if (typeof value === 'number') {
result += value;
} else if (typeof value === 'string') {
var parsed = parseFloat(value);
!isNaN(parsed) && (result += parsed);
} else if (Array.isArray(value)) {
result += exports.SUM.apply(null, value);
}
});
return result;
};
exports.SUMIF = function(range, criteria) {
range = utils.parseNumberArray(utils.flatten(range));
if (range instanceof Error) {
return range;
}
var result = 0;
var isWildcard = criteria === void 0 || criteria === '*';
var tokenizedCriteria = isWildcard ? null : evalExpression.parse(criteria + '');
for (var i = 0; i < range.length; i++) {
var value = range[i];
if (isWildcard) {
result += value;
} else {
var tokens = [evalExpression.createToken(value, evalExpression.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria);
result += (evalExpression.compute(tokens) ? value : 0);
}
}
return result;
};
exports.SUMIFS = function() {
var args = utils.argsToArray(arguments);
var range = utils.parseNumberArray(utils.flatten(args.shift()));
if (range instanceof Error) {
return range;
}
var criterias = args;
var n_range_elements = range.length;
var criteriaLength = criterias.length;
var result = 0;
for (var i = 0; i < n_range_elements; i++) {
var value = range[i];
var isMeetCondition = false;
for (var j = 0; j < criteriaLength; j++) {
var criteria = criterias[j];
var isWildcard = criteria === void 0 || criteria === '*';
var computedResult = false;
if (isWildcard) {
computedResult = true;
} else {
var tokenizedCriteria = evalExpression.parse(criteria + '');
var tokens = [evalExpression.createToken(value, evalExpression.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria);
computedResult = evalExpression.compute(tokens);
}
// Criterias are calculated as AND so any `false` breakes the loop as unmeet condition
if (!computedResult) {
isMeetCondition = false;
break;
}
isMeetCondition = true;
}
if (isMeetCondition) {
result += value;
}
}
return result;
};
exports.SUMPRODUCT = function() {
if (!arguments || arguments.length === 0) {
return error.value;
}
var arrays = arguments.length + 1;
var result = 0;
var product;
var k;
var _i;
var _ij;
for (var i = 0; i < arguments[0].length; i++) {
if (!(arguments[0][i] instanceof Array)) {
product = 1;
for (k = 1; k < arrays; k++) {
_i = utils.parseNumber(arguments[k - 1][i]);
if (_i instanceof Error) {
return _i;
}
product *= _i;
}
result += product;
} else {
for (var j = 0; j < arguments[0][i].length; j++) {
product = 1;
for (k = 1; k < arrays; k++) {
_ij = utils.parseNumber(arguments[k - 1][i][j]);
if (_ij instanceof Error) {
return _ij;
}
product *= _ij;
}
result += product;
}
}
}
return result;
};
exports.SUMSQ = function() {
var numbers = utils.parseNumberArray(utils.flatten(arguments));
if (numbers instanceof Error) {
return numbers;
}
var result = 0;
var length = numbers.length;
for (var i = 0; i < length; i++) {
result += (information.ISNUMBER(numbers[i])) ? numbers[i] * numbers[i] : 0;
}
return result;
};
exports.SUMX2MY2 = function(array_x, array_y) {
array_x = utils.parseNumberArray(utils.flatten(array_x));
array_y = utils.parseNumberArray(utils.flatten(array_y));
if (utils.anyIsError(array_x, array_y)) {
return error.value;
}
var result = 0;
for (var i = 0; i < array_x.length; i++) {
result += array_x[i] * array_x[i] - array_y[i] * array_y[i];
}
return result;
};
exports.SUMX2PY2 = function(array_x, array_y) {
array_x = utils.parseNumberArray(utils.flatten(array_x));
array_y = utils.parseNumberArray(utils.flatten(array_y));
if (utils.anyIsError(array_x, array_y)) {
return error.value;
}
var result = 0;
array_x = utils.parseNumberArray(utils.flatten(array_x));
array_y = utils.parseNumberArray(utils.flatten(array_y));
for (var i = 0; i < array_x.length; i++) {
result += array_x[i] * array_x[i] + array_y[i] * array_y[i];
}
return result;
};
exports.SUMXMY2 = function(array_x, array_y) {
array_x = utils.parseNumberArray(utils.flatten(array_x));
array_y = utils.parseNumberArray(utils.flatten(array_y));
if (utils.anyIsError(array_x, array_y)) {
return error.value;
}
var result = 0;
array_x = utils.flatten(array_x);
array_y = utils.flatten(array_y);
for (var i = 0; i < array_x.length; i++) {
result += Math.pow(array_x[i] - array_y[i], 2);
}
return result;
};
exports.TAN = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
return Math.tan(number);
};
exports.TANH = function(number) {
number = utils.parseNumber(number);
if (number instanceof Error) {
return number;
}
var e2 = Math.exp(2 * number);
return (e2 - 1) / (e2 + 1);
};
exports.TRUNC = function(number, digits) {
digits = (digits === undefined) ? 0 : digits;
number = utils.parseNumber(number);
digits = utils.parseNumber(digits);
if (utils.anyIsError(number, digits)) {
return error.value;
}
var sign = (number > 0) ? 1 : -1;
return sign * (Math.floor(Math.abs(number) * Math.pow(10, digits))) / Math.pow(10, digits);
};
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
var mathTrig = __webpack_require__(4);
var text = __webpack_require__(6);
var jStat = __webpack_require__(10);
var utils = __webpack_require__(1);
var evalExpression = __webpack_require__(7);
var error = __webpack_require__(0);
var misc = __webpack_require__(11);
var SQRT2PI = 2.5066282746310002;
exports.AVEDEV = function() {
var range = utils.parseNumberArray(utils.flatten(arguments));
if (range instanceof Error) {
return range;
}
return jStat.sum(jStat(range).subtract(jStat.mean(range)).abs()[0]) / range.length;
};
exports.AVERAGE = function() {
var range = utils.numbers(utils.flatten(arguments));
var n = range.length;
var sum = 0;
var count = 0;
var result;
for (var i = 0; i < n; i++) {
sum += range[i];
count += 1;
}
result = sum / count;
if (isNaN(result)) {
result = error.num;
}
return result;
};
exports.AVERAGEA = function() {
var range = utils.flatten(arguments);
var n = range.length;
var sum = 0;
var count = 0;
var result;
for (var i = 0; i < n; i++) {
var el = range[i];
if (typeof el === 'number') {
sum += el;
}
if (el === true) {
sum++;
}
if (el !== null) {
count++;
}
}
result = sum / count;
if (isNaN(result)) {
result = error.num;
}
return result;
};
exports.AVERAGEIF = function(range, criteria, average_range) {
if (arguments.length <= 1) {
return error.na;
}
average_range = average_range || range;
range = utils.flatten(range);
average_range = utils.parseNumberArray(utils.flatten(average_range));
if (average_range instanceof Error) {
return average_range;
}
var average_count = 0;
var result = 0;
var isWildcard = criteria === void 0 || criteria === '*';
var tokenizedCriteria = isWildcard ? null : evalExpression.parse(criteria + '');
for (var i = 0; i < range.length; i++) {
var value = range[i];
if (isWildcard) {
result += average_range[i];
average_count++;
} else {
var tokens = [evalExpression.createToken(value, evalExpression.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria);
if (evalExpression.compute(tokens)) {
result += average_range[i];
average_count++;
}
}
}
return result / average_count;
};
exports.AVERAGEIFS = function() {
// Does not work with multi dimensional ranges yet!
//http://office.microsoft.com/en-001/excel-help/averageifs-function-HA010047493.aspx
var args = utils.argsToArray(arguments);
var criteriaLength = (args.length - 1) / 2;
var range = utils.flatten(args[0]);
var count = 0;
var result = 0;
for (var i = 0; i < range.length; i++) {
var isMeetCondition = false;
for (var j = 0; j < criteriaLength; j++) {
var value = args[2 * j + 1][i];
var criteria = args[2 * j + 2];
var isWildcard = criteria === void 0 || criteria === '*';
var computedResult = false;
if (isWildcard) {
computedResult = true;
} else {
var tokenizedCriteria = evalExpression.parse(criteria + '');
var tokens = [evalExpression.createToken(value, evalExpression.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria);
computedResult = evalExpression.compute(tokens);
}
// Criterias are calculated as AND so any `false` breakes the loop as unmeet condition
if (!computedResult) {
isMeetCondition = false;
break;
}
isMeetCondition = true;
}
if (isMeetCondition) {
result += range[i];
count++;
}
}
var average = result / count;
if (isNaN(average)) {
return 0;
} else {
return average;
}
};
exports.BETA = {};
exports.BETA.DIST = function(x, alpha, beta, cumulative, A, B) {
if (arguments.length < 4) {
return error.value;
}
A = (A === undefined) ? 0 : A;
B = (B === undefined) ? 1 : B;
x = utils.parseNumber(x);
alpha = utils.parseNumber(alpha);
beta = utils.parseNumber(beta);
A = utils.parseNumber(A);
B = utils.parseNumber(B);
if (utils.anyIsError(x, alpha, beta, A, B)) {
return error.value;
}
x = (x - A) / (B - A);
return (cumulative) ? jStat.beta.cdf(x, alpha, beta) : jStat.beta.pdf(x, alpha, beta);
};
exports.BETA.INV = function(probability, alpha, beta, A, B) {
A = (A === undefined) ? 0 : A;
B = (B === undefined) ? 1 : B;
probability = utils.parseNumber(probability);
alpha = utils.parseNumber(alpha);
beta = utils.parseNumber(beta);
A = utils.parseNumber(A);
B = utils.parseNumber(B);
if (utils.anyIsError(probability, alpha, beta, A, B)) {
return error.value;
}
return jStat.beta.inv(probability, alpha, beta) * (B - A) + A;
};
exports.BINOM = {};
exports.BINOM.DIST = function(successes, trials, probability, cumulative) {
successes = utils.parseNumber(successes);
trials = utils.parseNumber(trials);
probability = utils.parseNumber(probability);
cumulative = utils.parseNumber(cumulative);
if (utils.anyIsError(successes, trials, probability, cumulative)) {
return error.value;
}
return (cumulative) ? jStat.binomial.cdf(successes, trials, probability) : jStat.binomial.pdf(successes, trials, probability);
};
exports.BINOM.DIST.RANGE = function(trials, probability, successes, successes2) {
successes2 = (successes2 === undefined) ? successes : successes2;
trials = utils.parseNumber(trials);
probability = utils.parseNumber(probability);
successes = utils.parseNumber(successes);
successes2 = utils.parseNumber(successes2);
if (utils.anyIsError(trials, probability, successes, successes2)) {
return error.value;
}
var result = 0;
for (var i = successes; i <= successes2; i++) {
result += mathTrig.COMBIN(trials, i) * Math.pow(probability, i) * Math.pow(1 - probability, trials - i);
}
return result;
};
exports.BINOM.INV = function(trials, probability, alpha) {
trials = utils.parseNumber(trials);
probability = utils.parseNumber(probability);
alpha = utils.parseNumber(alpha);
if (utils.anyIsError(trials, probability, alpha)) {
return error.value;
}
var x = 0;
while (x <= trials) {
if (jStat.binomial.cdf(x, trials, probability) >= alpha) {
return x;
}
x++;
}
};
exports.CHISQ = {};
exports.CHISQ.DIST = function(x, k, cumulative) {
x = utils.parseNumber(x);
k = utils.parseNumber(k);
if (utils.anyIsError(x, k)) {
return error.value;
}
return (cumulative) ? jStat.chisquare.cdf(x, k) : jStat.chisquare.pdf(x, k);
};
exports.CHISQ.DIST.RT = function(x, k) {
if (!x | !k) {
return error.na;
}
if (x < 1 || k > Math.pow(10, 10)) {
return error.num;
}
if ((typeof x !== 'number') || (typeof k !== 'number')) {
return error.value;
}
return 1 - jStat.chisquare.cdf(x, k);
};
exports.CHISQ.INV = function(probability, k) {
probability = utils.parseNumber(probability);
k = utils.parseNumber(k);
if (utils.anyIsError(probability, k)) {
return error.value;
}
return jStat.chisquare.inv(probability, k);
};
exports.CHISQ.INV.RT = function(p, k) {
if (!p | !k) {
return error.na;
}
if (p < 0 || p > 1 || k < 1 || k > Math.pow(10, 10)) {
return error.num;
}
if ((typeof p !== 'number') || (typeof k !== 'number')) {
return error.value;
}
return jStat.chisquare.inv(1.0 - p, k);
};
exports.CHISQ.TEST = function(observed, expected) {
if (arguments.length !== 2) {
return error.na;
}
if ((!(observed instanceof Array)) || (!(expected instanceof Array))) {
return error.value;
}
if (observed.length !== expected.length) {
return error.value;
}
if (observed[0] && expected[0] &&
observed[0].length !== expected[0].length) {
return error.value;
}
var row = observed.length;
var tmp, i, j;
// Convert single-dimension array into two-dimension array
for (i = 0; i < row; i ++) {
if (!(observed[i] instanceof Array)) {
tmp = observed[i];
observed[i] = [];
observed[i].push(tmp);
}
if (!(expected[i] instanceof Array)) {
tmp = expected[i];
expected[i] = [];
expected[i].push(tmp);
}
}
var col = observed[0].length;
var dof = (col === 1) ? row-1 : (row-1)*(col-1);
var xsqr = 0;
var Pi =Math.PI;
for (i = 0; i < row; i ++) {
for (j = 0; j < col; j ++) {
xsqr += Math.pow((observed[i][j] - expected[i][j]), 2) / expected[i][j];
}
}
// Get independency by X square and its degree of freedom
function ChiSq(xsqr, dof) {
var p = Math.exp(-0.5 * xsqr);
if((dof%2) === 1) {
p = p * Math.sqrt(2 * xsqr/Pi);
}
var k = dof;
while(k >= 2) {
p = p * xsqr/k;
k = k - 2;
}
var t = p;
var a = dof;
while (t > 0.0000000001*p) {
a = a + 2;
t = t * xsqr/a;
p = p + t;
}
return 1-p;
}
return Math.round(ChiSq(xsqr, dof) * 1000000) / 1000000;
};
exports.COLUMN = function(matrix, index) {
if (arguments.length !== 2) {
return error.na;
}
if (index < 0) {
return error.num;
}
if (!(matrix instanceof Array) || (typeof index !== 'number')) {
return error.value;
}
if (matrix.length === 0) {
return undefined;
}
return jStat.col(matrix, index);
};
exports.COLUMNS = function(matrix) {
if (arguments.length !== 1) {
return error.na;
}
if (!(matrix instanceof Array)) {
return error.value;
}
if (matrix.length === 0) {
return 0;
}
return jStat.cols(matrix);
};
exports.CONFIDENCE = {};
exports.CONFIDENCE.NORM = function(alpha, sd, n) {
alpha = utils.parseNumber(alpha);
sd = utils.parseNumber(sd);