hyperformula-dc
Version:
HyperFormula is a JavaScript engine for efficient processing of spreadsheet-like data and formulas
915 lines (792 loc) • 29.2 kB
JavaScript
"use strict";
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
require("core-js/modules/es.object.get-prototype-of.js");
require("core-js/modules/es.reflect.construct.js");
require("core-js/modules/es.object.to-string.js");
require("core-js/modules/es.function.name.js");
require("core-js/modules/es.symbol.js");
require("core-js/modules/es.symbol.description.js");
require("core-js/modules/es.symbol.iterator.js");
require("core-js/modules/es.array.iterator.js");
require("core-js/modules/web.dom-collections.iterator.js");
exports.__esModule = true;
exports.NumericAggregationPlugin = void 0;
require("core-js/modules/es.number.is-finite.js");
require("core-js/modules/es.number.constructor.js");
require("core-js/modules/es.array.reduce.js");
require("core-js/modules/es.array.slice.js");
require("core-js/modules/es.array.filter.js");
require("core-js/modules/es.array.map.js");
require("core-js/modules/es.array.from.js");
require("core-js/modules/es.string.iterator.js");
var _AbsoluteCellRange = require("../../AbsoluteCellRange");
var _Cell = require("../../Cell");
var _errorMessage = require("../../error-message");
var _errors = require("../../errors");
var _parser = require("../../parser");
var _ArithmeticHelper = require("../ArithmeticHelper");
var _InterpreterValue = require("../InterpreterValue");
var _SimpleRangeValue = require("../SimpleRangeValue");
var _FunctionPlugin2 = require("./FunctionPlugin");
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function zeroForInfinite(value) {
if ((0, _InterpreterValue.isExtendedNumber)(value) && !Number.isFinite((0, _InterpreterValue.getRawValue)(value))) {
return 0;
} else {
return value;
}
}
var MomentsAggregate = /*#__PURE__*/function () {
function MomentsAggregate(sumsq, sum, count) {
_classCallCheck(this, MomentsAggregate);
this.sumsq = sumsq;
this.sum = sum;
this.count = count;
}
_createClass(MomentsAggregate, [{
key: "compose",
value: function compose(other) {
return new MomentsAggregate(this.sumsq + other.sumsq, this.sum + other.sum, this.count + other.count);
}
}, {
key: "averageValue",
value: function averageValue() {
if (this.count > 0) {
return this.sum / this.count;
} else {
return undefined;
}
}
}, {
key: "varSValue",
value: function varSValue() {
if (this.count > 1) {
return (this.sumsq - this.sum * this.sum / this.count) / (this.count - 1);
} else {
return undefined;
}
}
}, {
key: "varPValue",
value: function varPValue() {
if (this.count > 0) {
return (this.sumsq - this.sum * this.sum / this.count) / this.count;
} else {
return undefined;
}
}
}], [{
key: "single",
value: function single(arg) {
return new MomentsAggregate(arg * arg, arg, 1);
}
}]);
return MomentsAggregate;
}();
MomentsAggregate.empty = new MomentsAggregate(0, 0, 0);
var NumericAggregationPlugin = /*#__PURE__*/function (_FunctionPlugin) {
_inherits(NumericAggregationPlugin, _FunctionPlugin);
var _super = _createSuper(NumericAggregationPlugin);
function NumericAggregationPlugin() {
var _this;
_classCallCheck(this, NumericAggregationPlugin);
_this = _super.apply(this, arguments);
_this.addWithEpsilonRaw = function (left, right) {
return _this.arithmeticHelper.addWithEpsilonRaw(left, right);
};
return _this;
}
/**
* Corresponds to SUM(Number1, Number2, ...).
*
* Returns a sum of given numbers.
*
* @param ast
* @param state
*/
_createClass(NumericAggregationPlugin, [{
key: "sum",
value: function sum(ast, state) {
return this.doSum(ast.args, state);
}
}, {
key: "sumsq",
value: function sumsq(ast, state) {
return this.reduce(ast.args, state, 0, 'SUMSQ', this.addWithEpsilonRaw, function (arg) {
return Math.pow((0, _InterpreterValue.getRawValue)(arg), 2);
}, strictlyNumbers);
}
/**
* Corresponds to MAX(Number1, Number2, ...).
*
* Returns a max of given numbers.
*
* @param ast
* @param state
*/
}, {
key: "max",
value: function max(ast, state) {
return this.doMax(ast.args, state);
}
}, {
key: "maxa",
value: function maxa(ast, state) {
var value = this.reduce(ast.args, state, Number.NEGATIVE_INFINITY, 'MAXA', function (left, right) {
return Math.max(left, right);
}, _InterpreterValue.getRawValue, numbersBooleans);
return zeroForInfinite(value);
}
/**
* Corresponds to MIN(Number1, Number2, ...).
*
* Returns a min of given numbers.
*
* @param ast
* @param state
*/
}, {
key: "min",
value: function min(ast, state) {
return this.doMin(ast.args, state);
}
}, {
key: "mina",
value: function mina(ast, state) {
var value = this.reduce(ast.args, state, Number.POSITIVE_INFINITY, 'MINA', function (left, right) {
return Math.min(left, right);
}, _InterpreterValue.getRawValue, numbersBooleans);
return zeroForInfinite(value);
}
}, {
key: "count",
value: function count(ast, state) {
return this.doCount(ast.args, state);
}
}, {
key: "counta",
value: function counta(ast, state) {
return this.doCounta(ast.args, state);
}
}, {
key: "average",
value: function average(ast, state) {
return this.doAverage(ast.args, state);
}
}, {
key: "averagea",
value: function averagea(ast, state) {
var _a;
var result = this.reduce(ast.args, state, MomentsAggregate.empty, '_AGGREGATE_A', function (left, right) {
return left.compose(right);
}, function (arg) {
return MomentsAggregate.single((0, _InterpreterValue.getRawValue)(arg));
}, numbersBooleans);
if (result instanceof _Cell.CellError) {
return result;
} else {
return (_a = result.averageValue()) !== null && _a !== void 0 ? _a : new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO);
}
}
}, {
key: "vars",
value: function vars(ast, state) {
return this.doVarS(ast.args, state);
}
}, {
key: "varp",
value: function varp(ast, state) {
return this.doVarP(ast.args, state);
}
}, {
key: "vara",
value: function vara(ast, state) {
var _a;
var result = this.reduceAggregateA(ast.args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
return (_a = result.varSValue()) !== null && _a !== void 0 ? _a : new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO);
}
}
}, {
key: "varpa",
value: function varpa(ast, state) {
var _a;
var result = this.reduceAggregateA(ast.args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
return (_a = result.varPValue()) !== null && _a !== void 0 ? _a : new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO);
}
}
}, {
key: "stdevs",
value: function stdevs(ast, state) {
return this.doStdevS(ast.args, state);
}
}, {
key: "stdevp",
value: function stdevp(ast, state) {
return this.doStdevP(ast.args, state);
}
}, {
key: "stdeva",
value: function stdeva(ast, state) {
var result = this.reduceAggregateA(ast.args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
var val = result.varSValue();
return val === undefined ? new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO) : Math.sqrt(val);
}
}
}, {
key: "stdevpa",
value: function stdevpa(ast, state) {
var result = this.reduceAggregateA(ast.args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
var val = result.varPValue();
return val === undefined ? new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO) : Math.sqrt(val);
}
}
}, {
key: "product",
value: function product(ast, state) {
return this.doProduct(ast.args, state);
}
}, {
key: "subtotal",
value: function subtotal(ast, state) {
if (ast.args.length < 2) {
return new _Cell.CellError(_Cell.ErrorType.NA, _errorMessage.ErrorMessage.WrongArgNumber);
}
var functionType = this.coerceToType(this.evaluateAst(ast.args[0], state), {
argumentType: _FunctionPlugin2.ArgumentTypes.NUMBER
}, state);
var args = ast.args.slice(1);
switch (functionType) {
case 1:
case 101:
return this.doAverage(args, state);
case 2:
case 102:
return this.doCount(args, state);
case 3:
case 103:
return this.doCounta(args, state);
case 4:
case 104:
return this.doMax(args, state);
case 5:
case 105:
return this.doMin(args, state);
case 6:
case 106:
return this.doProduct(args, state);
case 7:
case 107:
return this.doStdevS(args, state);
case 8:
case 108:
return this.doStdevP(args, state);
case 9:
case 109:
return this.doSum(args, state);
case 10:
case 110:
return this.doVarS(args, state);
case 11:
case 111:
return this.doVarP(args, state);
default:
return new _Cell.CellError(_Cell.ErrorType.VALUE, _errorMessage.ErrorMessage.BadMode);
}
}
}, {
key: "reduceAggregate",
value: function reduceAggregate(args, state) {
return this.reduce(args, state, MomentsAggregate.empty, '_AGGREGATE', function (left, right) {
return left.compose(right);
}, function (arg) {
return MomentsAggregate.single((0, _InterpreterValue.getRawValue)(arg));
}, strictlyNumbers);
}
}, {
key: "reduceAggregateA",
value: function reduceAggregateA(args, state) {
return this.reduce(args, state, MomentsAggregate.empty, '_AGGREGATE_A', function (left, right) {
return left.compose(right);
}, function (arg) {
return MomentsAggregate.single((0, _InterpreterValue.getRawValue)(arg));
}, numbersBooleans);
}
}, {
key: "doAverage",
value: function doAverage(args, state) {
var _a;
var result = this.reduceAggregate(args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
return (_a = result.averageValue()) !== null && _a !== void 0 ? _a : new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO);
}
}
}, {
key: "doVarS",
value: function doVarS(args, state) {
var _a;
var result = this.reduceAggregate(args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
return (_a = result.varSValue()) !== null && _a !== void 0 ? _a : new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO);
}
}
}, {
key: "doVarP",
value: function doVarP(args, state) {
var _a;
var result = this.reduceAggregate(args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
return (_a = result.varPValue()) !== null && _a !== void 0 ? _a : new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO);
}
}
}, {
key: "doStdevS",
value: function doStdevS(args, state) {
var result = this.reduceAggregate(args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
var val = result.varSValue();
return val === undefined ? new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO) : Math.sqrt(val);
}
}
}, {
key: "doStdevP",
value: function doStdevP(args, state) {
var result = this.reduceAggregate(args, state);
if (result instanceof _Cell.CellError) {
return result;
} else {
var val = result.varPValue();
return val === undefined ? new _Cell.CellError(_Cell.ErrorType.DIV_BY_ZERO) : Math.sqrt(val);
}
}
}, {
key: "doCount",
value: function doCount(args, state) {
return this.reduce(args, state, 0, 'COUNT', function (left, right) {
return left + right;
}, _InterpreterValue.getRawValue, function (arg) {
return (0, _InterpreterValue.isExtendedNumber)(arg) ? 1 : 0;
});
}
}, {
key: "doCounta",
value: function doCounta(args, state) {
return this.reduce(args, state, 0, 'COUNTA', function (left, right) {
return left + right;
}, _InterpreterValue.getRawValue, function (arg) {
return arg === _InterpreterValue.EmptyValue ? 0 : 1;
});
}
}, {
key: "doMax",
value: function doMax(args, state) {
var value = this.reduce(args, state, Number.NEGATIVE_INFINITY, 'MAX', function (left, right) {
return Math.max(left, right);
}, _InterpreterValue.getRawValue, strictlyNumbers);
return zeroForInfinite(value);
}
}, {
key: "doMin",
value: function doMin(args, state) {
var value = this.reduce(args, state, Number.POSITIVE_INFINITY, 'MIN', function (left, right) {
return Math.min(left, right);
}, _InterpreterValue.getRawValue, strictlyNumbers);
return zeroForInfinite(value);
}
}, {
key: "doSum",
value: function doSum(args, state) {
return this.reduce(args, state, 0, 'SUM', this.addWithEpsilonRaw, _InterpreterValue.getRawValue, strictlyNumbers);
}
}, {
key: "doProduct",
value: function doProduct(args, state) {
return this.reduce(args, state, 1, 'PRODUCT', function (left, right) {
return left * right;
}, _InterpreterValue.getRawValue, strictlyNumbers);
}
/**
* Reduces procedure arguments with given reducing function
*
* @param args
* @param state
* @param initialAccValue - "neutral" value (equivalent of 0)
* @param functionName - function name to use as cache key
* @param reducingFunction - reducing function
* @param mapFunction
* @param coercionFunction
* */
}, {
key: "reduce",
value: function reduce(args, state, initialAccValue, functionName, reducingFunction, mapFunction, coercionFunction) {
var _this2 = this;
if (args.length < 1) {
return new _Cell.CellError(_Cell.ErrorType.NA, _errorMessage.ErrorMessage.WrongArgNumber);
}
return args.reduce(function (acc, arg) {
if (acc instanceof _Cell.CellError) {
return acc;
}
if (arg.type === _parser.AstNodeType.CELL_RANGE || arg.type === _parser.AstNodeType.COLUMN_RANGE || arg.type === _parser.AstNodeType.ROW_RANGE) {
var val = _this2.evaluateRange(arg, state, initialAccValue, functionName, reducingFunction, mapFunction, coercionFunction);
if (val instanceof _Cell.CellError) {
return val;
}
return reducingFunction(val, acc);
}
var value;
value = _this2.evaluateAst(arg, state);
if (value instanceof _SimpleRangeValue.SimpleRangeValue) {
var coercedRangeValues = Array.from(value.valuesFromTopLeftCorner()).map(coercionFunction).filter(function (arg) {
return arg !== undefined;
});
return coercedRangeValues.map(function (arg) {
if (arg instanceof _Cell.CellError) {
return arg;
} else {
return mapFunction(arg);
}
}).reduce(function (left, right) {
if (left instanceof _Cell.CellError) {
return left;
} else if (right instanceof _Cell.CellError) {
return right;
} else {
return reducingFunction(left, right);
}
}, acc);
} else if (arg.type === _parser.AstNodeType.CELL_REFERENCE) {
value = coercionFunction(value);
if (value === undefined) {
return acc;
}
} else {
value = _this2.coerceScalarToNumberOrError(value);
value = coercionFunction(value);
if (value === undefined) {
return acc;
}
}
if (value instanceof _Cell.CellError) {
return value;
}
return reducingFunction(acc, mapFunction(value));
}, initialAccValue);
}
/**
* Performs range operation on given range
*
* @param ast - cell range ast
* @param state
* @param initialAccValue - initial accumulator value for reducing function
* @param functionName - function name to use as cache key
* @param reducingFunction - reducing function
* @param mapFunction
* @param coercionFunction
*/
}, {
key: "evaluateRange",
value: function evaluateRange(ast, state, initialAccValue, functionName, reducingFunction, mapFunction, coercionFunction) {
var range;
try {
range = _AbsoluteCellRange.AbsoluteCellRange.fromAst(ast, state.formulaAddress);
} catch (err) {
if (err instanceof _errors.SheetsNotEqual) {
return new _Cell.CellError(_Cell.ErrorType.REF, _errorMessage.ErrorMessage.RangeManySheets);
} else {
throw err;
}
}
var rangeStart = range.start;
var rangeEnd = range.end;
var rangeVertex = this.dependencyGraph.getRange(rangeStart, rangeEnd);
if (rangeVertex === undefined) {
throw new Error('Range does not exists in graph');
}
var value = rangeVertex.getFunctionValue(functionName);
if (value === undefined) {
var rangeValues = this.getRangeValues(functionName, range, mapFunction, coercionFunction);
value = rangeValues.reduce(function (arg1, arg2) {
if (arg1 instanceof _Cell.CellError) {
return arg1;
} else if (arg2 instanceof _Cell.CellError) {
return arg2;
} else {
return reducingFunction(arg1, arg2);
}
}, initialAccValue);
rangeVertex.setFunctionValue(functionName, value);
}
return value;
}
/**
* Returns list of values for given range and function name
*
* If range is dependent on smaller range, list will contain value of smaller range for this function
* and values of cells that are not present in smaller range
*
* @param functionName - function name (e.g. SUM)
* @param range - cell range
* @param mapFunction
* @param coercionFunction
*/
}, {
key: "getRangeValues",
value: function getRangeValues(functionName, range, mapFunction, coercionFunction) {
var rangeResult = [];
var _this$dependencyGraph = this.dependencyGraph.rangeMapping.findSmallerRange(range),
smallerRangeVertex = _this$dependencyGraph.smallerRangeVertex,
restRange = _this$dependencyGraph.restRange;
var currentRangeVertex = this.dependencyGraph.getRange(range.start, range.end);
var actualRange;
if (smallerRangeVertex !== undefined && this.dependencyGraph.existsEdge(smallerRangeVertex, currentRangeVertex)) {
var cachedValue = smallerRangeVertex.getFunctionValue(functionName);
if (cachedValue !== undefined) {
rangeResult.push(cachedValue);
} else {
var _iterator = _createForOfIteratorHelper(smallerRangeVertex.range.addresses(this.dependencyGraph)),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var cellFromRange = _step.value;
var val = coercionFunction(this.dependencyGraph.getScalarValue(cellFromRange));
if (val instanceof _Cell.CellError) {
rangeResult.push(val);
} else if (val !== undefined) {
rangeResult.push(mapFunction(val));
}
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
}
actualRange = restRange;
} else {
actualRange = range;
}
var _iterator2 = _createForOfIteratorHelper(actualRange.addresses(this.dependencyGraph)),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var _cellFromRange = _step2.value;
var _val = coercionFunction(this.dependencyGraph.getScalarValue(_cellFromRange));
if (_val instanceof _Cell.CellError) {
rangeResult.push(_val);
} else if (_val !== undefined) {
rangeResult.push(mapFunction(_val));
}
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
return rangeResult;
}
}]);
return NumericAggregationPlugin;
}(_FunctionPlugin2.FunctionPlugin);
exports.NumericAggregationPlugin = NumericAggregationPlugin;
NumericAggregationPlugin.implementedFunctions = {
'SUM': {
method: 'sum',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'SUMSQ': {
method: 'sumsq',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'MAX': {
method: 'max',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'MIN': {
method: 'min',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'MAXA': {
method: 'maxa',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'MINA': {
method: 'mina',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'COUNT': {
method: 'count',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'COUNTA': {
method: 'counta',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'AVERAGE': {
method: 'average',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'AVERAGEA': {
method: 'averagea',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'PRODUCT': {
method: 'product',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'VAR.S': {
method: 'vars',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'VAR.P': {
method: 'varp',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'VARA': {
method: 'vara',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'VARPA': {
method: 'varpa',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'STDEV.S': {
method: 'stdevs',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'STDEV.P': {
method: 'stdevp',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'STDEVA': {
method: 'stdeva',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'STDEVPA': {
method: 'stdevpa',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
},
'SUBTOTAL': {
method: 'subtotal',
parameters: [{
argumentType: _FunctionPlugin2.ArgumentTypes.NUMBER
}, {
argumentType: _FunctionPlugin2.ArgumentTypes.ANY
}],
repeatLastArgs: 1
}
};
NumericAggregationPlugin.aliases = {
VAR: 'VAR.S',
VARP: 'VAR.P',
STDEV: 'STDEV.S',
STDEVP: 'STDEV.P',
VARS: 'VAR.S',
STDEVS: 'STDEV.S'
};
function strictlyNumbers(arg) {
if ((0, _InterpreterValue.isExtendedNumber)(arg) || arg instanceof _Cell.CellError) {
return arg;
} else {
return undefined;
}
}
function numbersBooleans(arg) {
if (typeof arg === 'boolean') {
return (0, _ArithmeticHelper.coerceBooleanToNumber)(arg);
} else if ((0, _InterpreterValue.isExtendedNumber)(arg) || arg instanceof _Cell.CellError) {
return arg;
} else if (typeof arg === 'string') {
return 0;
} else {
return undefined;
}
}