/** * 数学相关的函数,主要参考 fast-formula-parser 里的实现 * https://github.com/LesterLyu/fast-formula-parser */ import FormulaError from '../FormulaError'; import {EvalResult} from '../eval/EvalResult'; import {Factorials, factorial, factorialDouble} from './util/Factorials'; import {functions, regFunc} from './functions'; import { getNumber, getNumberOrThrow, getNumberWithDefault } from './util/getNumber'; import {getNumbers} from './util/getNumbers'; import {getNumber2DArray} from './util/getNumbersWithUndefined'; import {getString, getStringOrThrow} from './util/getString'; import {parseCriteria} from '../parser/parseCriteria'; import {evalCriterial} from '../eval/evalCriterial'; import {getArray} from './util/getArray'; import {evalIFS} from './util/evalIFS'; // https://support.microsoft.com/en-us/office/abs-function-3420200f-5628-4e8c-99da-c99d7c87713c regFunc('ABS', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return Math.abs(num); }); // https://support.microsoft.com/en-us/office/arabic-function-9a8da418-c17b-4ef9-a657-9370a30a674f regFunc('ARABIC', (...args: EvalResult[]) => { const str = getStringOrThrow(args[0]); const roman = str.toUpperCase(); if ( !/^M*(?:D?C{0,3}|C[MD])(?:L?X{0,3}|X[CL])(?:V?I{0,3}|I[XV])$/.test(roman) ) { throw FormulaError.VALUE; } let r = 0; roman.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] || 0; return ''; }); return r; }); // https://support.microsoft.com/en-us/office/base-function-2ef61411-aee9-4f29-a811-1c42456c6342 regFunc('BASE', (...args: EvalResult[]) => { const numbers = getNumbers(args); if (numbers.length < 2) { throw FormulaError.VALUE; } const number = numbers[0]; if (number < 0 || number >= 2 ** 53) { throw FormulaError.NUM; } const radix = numbers[1]; if (radix < 2 || radix > 36) { throw FormulaError.NUM; } const minLength = numbers.length > 2 ? numbers[2] : 0; if (minLength < 0) { throw FormulaError.NUM; } const result = number.toString(radix).toUpperCase(); const res = new Array(Math.max(minLength + 1 - result.length, 0)).join('0') + result; return res; }); // https://support.microsoft.com/en-us/office/ceiling-function-0a5cd7c8-0720-4f0a-bd2c-c943e510899f function CEILING(...args: EvalResult[]) { const numbers = getNumbers(args); if (numbers.length !== 2) { throw FormulaError.VALUE; } const number = numbers[0]; const significance = numbers[1]; if (significance === 0) { return 0; } if ((number / significance) % 1 === 0) { return number; } const absSignificance = Math.abs(significance); const times = Math.floor(Math.abs(number) / absSignificance); if (number < 0) { // round down, away from zero const roundDown = significance < 0; return roundDown ? -absSignificance * (times + 1) : -absSignificance * times; } else { return (times + 1) * absSignificance; } } regFunc('CEILING', CEILING); // https://support.microsoft.com/en-us/office/ceiling-math-function-80f95d2f-b499-4eee-9f16-f795a8e306c8 regFunc('CEILING.MATH', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const significance = getNumber(args[1], number > 0 ? 1 : -1)!; const mode = getNumber(args[2], 0)!; if (number >= 0) { return CEILING(number, significance); } // if round down, away from zero, then significance const offset = mode ? significance : 0; return CEILING(number, significance) - offset; }); // https://support.microsoft.com/en-us/office/ceiling-precise-function-f366a774-527a-4c92-ba49-af0a196e66cb regFunc('CEILING.PRECISE', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const significance = getNumber(args[1], 1)!; return CEILING(number, Math.abs(significance)); }); function COMBIN(number: number, numberChosen: number) { if (number < 0 || numberChosen < 0 || number < numberChosen) { throw FormulaError.NUM; } const nFactorial = FACT(number), kFactorial = FACT(numberChosen); return nFactorial / kFactorial / FACT(number - numberChosen); } // https://support.microsoft.com/en-us/office/combin-function-12a3f276-0a21-423a-8de6-06990aaf638a regFunc('COMBIN', (...args: EvalResult[]) => { const numbers = getNumbers(args); if (numbers.length !== 2) { throw FormulaError.VALUE; } return COMBIN(numbers[0], numbers[1]); }); // https://support.microsoft.com/en-us/office/combina-function-efb49eaa-4f4c-4cd2-8179-0ddfcf9d035d regFunc('COMBINA', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const numberChosen = getNumberOrThrow(args[1]); if ((number === 0 || number === 1) && numberChosen === 0) { return 1; } if (number < 0 || numberChosen < 0) { throw FormulaError.NUM; } return COMBIN(number + numberChosen - 1, number - 1); }); regFunc('DECIMAL', (...args: EvalResult[]) => { if (args.length != 2) { throw FormulaError.VALUE; } const text = getStringOrThrow(args[0]); let radix = getNumberOrThrow(args[1]); radix = Math.trunc(radix); if (radix < 2 || radix > 36) { throw FormulaError.NUM; } const res = parseInt(text, radix); if (isNaN(res)) { throw FormulaError.NUM; } return res; }); regFunc('DEGREES', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return (num * 180) / Math.PI; }); regFunc('EVEN', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return CEILING(num, -2); }); regFunc('EXP', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return Math.exp(num); }); function FACT(num: number) { num = Math.trunc(num); if (num > 170 || num < 0) { throw FormulaError.NUM; } if (num <= 100) { return Factorials[num]; } return factorial(num); } regFunc('FACT', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return FACT(num); }); regFunc('FACTDOUBLE', (arg: EvalResult) => { let number = getNumberOrThrow(arg); number = Math.trunc(number); if (number < -1) { throw FormulaError.NUM; } if (number === -1) { return 1; } return factorialDouble(number); }); export function FLOOR(number: number, significance: number) { if (significance === 0) { return 0; } if (number > 0 && significance < 0) { throw FormulaError.NUM; } if ((number / significance) % 1 === 0) { return number; } const absSignificance = Math.abs(significance); const times = Math.floor(Math.abs(number) / absSignificance); if (number < 0) { // round down, away from zero const roundDown = significance < 0; return roundDown ? -absSignificance * times : -absSignificance * (times + 1); } else { // toward zero return times * absSignificance; } } regFunc('FLOOR', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const significance = getNumber(args[1], 0)!; return FLOOR(number, significance); }); regFunc('FLOOR.MATH', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const significance = getNumber(args[1], number > 0 ? 1 : -1)!; const mode = getNumber(args[2], 0)!; // The Mode argument does not affect positive numbers. if (mode === 0 || number >= 0) { // away from zero return FLOOR(number, Math.abs(significance)); } // towards zero, add a significance return FLOOR(number, significance) + significance; }); regFunc('FLOOR.PRECISE', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const significance = getNumber(args[1], 1)!; return FLOOR(number, Math.abs(significance)); }); regFunc('GCD', (...args: EvalResult[]) => { const numbers = getNumbers(args, arg => { if (arg === undefined) { throw FormulaError.VALUE; } if (arg < 0 || arg > 9007199254740990) { throw FormulaError.NUM; } return Math.trunc(arg); }); // http://rosettacode.org/wiki/Greatest_common_divisor#JavaScript let i, y, n = numbers.length, x = Math.abs(numbers[0]); for (i = 1; i < n; i++) { y = Math.abs(numbers[i]); while (x && y) { x > y ? (x %= y) : (y %= x); } x += y; } return x; }); regFunc('INT', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return Math.floor(num); }); regFunc('ISO.CEILING', (...args: EvalResult[]) => { return functions.get('CEILING.PRECISE')!(...args); }); regFunc('LCM', (...args: EvalResult[]) => { const numbers = getNumbers(args, arg => { if (arg === undefined) { throw FormulaError.VALUE; } if (arg < 0 || arg > 9007199254740990) { throw FormulaError.NUM; } return Math.trunc(arg); }); let n = numbers.length, a = Math.abs(numbers[0]); for (let i = 1; i < n; i++) { let b = Math.abs(numbers[i]), c = a; while (a && b) { a > b ? (a %= b) : (b %= a); } a = Math.abs(c * numbers[i]) / (a + b); } return a; }); regFunc('LN', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return Math.log(num); }); regFunc('LOG', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const base = getNumber(args[1], 10)!; return Math.log(number) / Math.log(base); }); regFunc('LOG10', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return Math.log10(num); }); function getNum(num: number | undefined): number { if (num === undefined) { throw FormulaError.VALUE; } return num; } regFunc('MDETERM', (...args: EvalResult[]) => { if (args.length !== 1) { throw FormulaError.VALUE; } const array = getNumber2DArray(args[0]); if (array.length === 0) { throw FormulaError.VALUE; } if (!Array.isArray(array[0])) { throw FormulaError.VALUE; } if (array[0].length !== array.length) { throw FormulaError.VALUE; } const numRow = array.length, numCol = array[0].length; let det = 0, diagLeft, diagRight; if (numRow === 1) { return array[0][0] || 0; } else if (numRow === 2) { if (!Array.isArray(array[1])) { throw FormulaError.VALUE; } return ( getNum(array[0][0]) * getNum(array[1][1]) - getNum(array[0][1]) * getNum(array[1][0]) ); } for (let col = 0; col < numCol; col++) { diagLeft = getNum(array[0][col]); diagRight = getNum(array[0][col]); for (let row = 1; row < numRow; row++) { const rowArray = array[row]; if (!Array.isArray(rowArray) || rowArray === undefined) { throw FormulaError.VALUE; } diagRight *= getNum(rowArray[(((col + row) % numCol) + numCol) % numCol]); diagLeft *= getNum(rowArray[(((col - row) % numCol) + numCol) % numCol]); } det += diagRight - diagLeft; } return det; }); regFunc('MMULT', (...args: EvalResult[]) => { const array1 = getNumber2DArray(args[0]); const array2 = getNumber2DArray(args[1]); const aNumRows = array1.length, aNumCols = array1[0].length, bNumRows = array2.length, bNumCols = array2[0].length, m = new Array(aNumRows); // initialize array of rows if (aNumCols !== bNumRows) { throw FormulaError.VALUE; } for (let r = 0; r < aNumRows; r++) { m[r] = new Array(bNumCols); // initialize the current row for (let c = 0; c < bNumCols; c++) { m[r][c] = 0; // initialize the current cell for (let i = 0; i < aNumCols; i++) { const v1 = array1[r][i], v2 = array2[i][c]; if (typeof v1 !== 'number' || typeof v2 !== 'number') { throw FormulaError.VALUE; } m[r][c] += array1[r][i]! * array2[i][c]!; } } } return m; }); regFunc('MOD', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const divisor = getNumberOrThrow(args[1]); if (divisor === 0) { throw FormulaError.DIV0; } return number - divisor * Math.floor(number / divisor); }); regFunc('MROUND', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const multiple = getNumberOrThrow(args[1]); if (multiple === 0) { return 0; } if ((number > 0 && multiple < 0) || (number < 0 && multiple > 0)) { throw FormulaError.NUM; } if ((number / multiple) % 1 === 0) { return number; } return Math.round(number / multiple) * multiple; }); regFunc('MULTINOMIAL', (...args: EvalResult[]) => { const numbers = getNumbers(args); let numerator = 0, denominator = 1; for (const num of numbers) { if (num < 0) { throw FormulaError.NUM; } numerator += num; denominator *= factorial(num); } return factorial(numerator) / denominator; }); regFunc('MUNIT', (arg: EvalResult) => { const dimension = parseInt(getNumberOrThrow(arg) + '', 10); if (dimension < 0) { throw FormulaError.NUM; } if (!dimension || dimension <= 0) { throw FormulaError.VALUE; } return Array(dimension) .fill(0) .map(() => Array(dimension).fill(0)) .map((el, i) => { el[i] = 1; return el; }); }); regFunc('ODD', (arg: EvalResult) => { const number = getNumberOrThrow(arg); if (number === 0) { return 1; } let temp = Math.ceil(Math.abs(number)); temp = temp & 1 ? temp : temp + 1; return number > 0 ? temp : -temp; }); regFunc('PI', () => Math.PI); regFunc('POWER', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const power = getNumberOrThrow(args[1]); return number ** power; }); regFunc('PRODUCT', (...args: EvalResult[]) => { const numbers = getNumbers(args); return numbers.reduce((prev, cur) => prev * cur, 1); }); regFunc('QUOTIENT', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const divisor = getNumberOrThrow(args[1]); if (divisor === 0) { throw FormulaError.DIV0; } return Math.trunc(number / divisor); }); regFunc('RADIANS', (arg: EvalResult) => { const degrees = getNumberOrThrow(arg); return (degrees * Math.PI) / 180; }); regFunc('RAND', () => Math.random()); function RANK(number: EvalResult, ref: EvalResult, order: EvalResult) { const num = getNumberOrThrow(number); const array = getNumbers([ref]); const ord = getNumberWithDefault(order, 0); const sorted = array.slice().sort((a, b) => a - b); const index = sorted.indexOf(num); if (index === -1) { throw FormulaError.NA; } return ord === 0 ? array.length - index : index + 1; } regFunc('RANK', RANK); regFunc('RANK.EQ', RANK); regFunc( 'RANK.AVG', (number: EvalResult, ref: EvalResult, order: EvalResult) => { const num = getNumberOrThrow(number); const array = getNumbers([ref]); const ord = getNumberWithDefault(order, 0); const sorted = array.slice().sort((a, b) => a - b); const index = sorted.indexOf(num); if (index === -1) { throw FormulaError.NA; } const count = sorted.filter(v => v === num).length; return ord === 0 ? array.length - index - (count - 1) / 2 : index + 1 + (count - 1) / 2; } ); regFunc('RANDBETWEEN', (...args: EvalResult[]) => { const bottom = getNumberOrThrow(args[0]); const top = getNumberOrThrow(args[1]); if (bottom > top) { throw FormulaError.NUM; } return Math.floor(Math.random() * (top - bottom + 1) + bottom); }); regFunc('ROMAN', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const form = getNumber(args[1], 0); if (form !== 0) { throw Error('ROMAN: only allows form=0 (classic form).'); } // The MIT License // Copyright (c) 2008 Steven Levithan const digits = String(number).split(''); if (digits.length === 0) { throw FormulaError.VALUE; } const 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' ]; let roman = '', i = 3; while (i--) { roman = (key[+digits.pop()! + i * 10] || '') + roman; } return new Array(+digits.join('') + 1).join('M') + roman; }); regFunc('ROUND', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const digits = getNumberOrThrow(args[1]); const multiplier = Math.pow(10, Math.abs(digits)); const sign = number > 0 ? 1 : -1; if (digits > 0) { return (sign * Math.round(Math.abs(number) * multiplier)) / multiplier; } else if (digits === 0) { return sign * Math.round(Math.abs(number)); } else { return sign * Math.round(Math.abs(number) / multiplier) * multiplier; } }); regFunc('ROUNDDOWN', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const digits = getNumberOrThrow(args[1]); const multiplier = Math.pow(10, Math.abs(digits)); const sign = number > 0 ? 1 : -1; if (digits > 0) { const offset = (1 / multiplier) * 0.5; return ( (sign * Math.round((Math.abs(number) - offset) * multiplier)) / multiplier ); } else if (digits === 0) { const offset = 0.5; return sign * Math.round(Math.abs(number) - offset); } else { const offset = multiplier * 0.5; return ( sign * Math.round((Math.abs(number) - offset) / multiplier) * multiplier ); } }); regFunc('ROUNDUP', (...args: EvalResult[]) => { const number = getNumberOrThrow(args[0]); const digits = getNumberOrThrow(args[1]); const multiplier = Math.pow(10, Math.abs(digits)); const sign = number > 0 ? 1 : -1; if (digits > 0) { const offset = (1 / multiplier) * 0.5; return ( (sign * Math.round((Math.abs(number) + offset) * multiplier)) / multiplier ); } else if (digits === 0) { const offset = 0.5; return sign * Math.round(Math.abs(number) + offset); } else { const offset = multiplier * 0.5; return ( sign * Math.round((Math.abs(number) + offset) / multiplier) * multiplier ); } }); regFunc('SERIESSUM', (argX, argN, argM, ...args: EvalResult[]) => { const x = getNumberOrThrow(argX); const n = getNumberOrThrow(argN); const m = getNumberOrThrow(argM); let i = 0; let result = 0; const coefficients = getNumbers(args); for (const coefficient of coefficients) { if (i === 0) { result = coefficient * Math.pow(x, n); } else { result += coefficient * Math.pow(x, n + i * m); } i++; } return result; }); regFunc('SIGN', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return num > 0 ? 1 : num < 0 ? -1 : 0; }); regFunc('SQRT', (arg: EvalResult) => { const num = getNumberOrThrow(arg); if (num < 0) { throw FormulaError.NUM; } return Math.sqrt(num); }); regFunc('SQRTPI', (arg: EvalResult) => { const num = getNumberOrThrow(arg); if (num < 0) { throw FormulaError.NUM; } return Math.sqrt(num * Math.PI); }); regFunc('SUM', (...args: EvalResult[]) => { const sum = getNumbers(args).reduce((prev, cur) => prev + cur, 0); return sum; }); regFunc( 'SUMIF', (range: EvalResult, criteria: EvalResult, sumRange: EvalResult) => { const parsedCriteria = parseCriteria(criteria as string); const numbers = getArray([range]) as number[]; const sumNumbers = sumRange ? getNumbers([sumRange]) : numbers; if (numbers.length !== sumNumbers.length) { throw FormulaError.VALUE; } let sum = 0; for (let i = 0; i < numbers.length; i++) { if (evalCriterial(parsedCriteria, numbers[i])) { sum += sumNumbers[i]; } } return sum; } ); regFunc('SUMIFS', (...args: EvalResult[]) => { const numbers = evalIFS(args) as number[]; return numbers.reduce((prev, cur) => prev + cur, 0); }); regFunc('SUMPRODUCT', (array1Arg, ...args: EvalResult[]) => { const array1 = getNumber2DArray(array1Arg); const arrays = args.map(arg => getNumber2DArray(arg)); if (arrays.length === 0) { throw FormulaError.VALUE; } for (const array of arrays) { if (array1[0].length !== array[0].length || array1.length !== array.length) throw FormulaError.VALUE; for (let i = 0; i < array1.length; i++) { for (let j = 0; j < array1[0].length; j++) { if (typeof array1[i][j] !== 'number') { array1[i][j] = 0; } if (typeof array[i][j] !== 'number') { array[i][j] = 0; } array1[i][j]! *= array[i][j]!; } } } let result = 0; array1.forEach(row => { row.forEach(value => { result += value || 0; }); }); return result; }); regFunc('SUMSQ', (...args: EvalResult[]) => { const numbers = getNumbers(args); return numbers.reduce((prev, cur) => prev + cur ** 2, 0); }); regFunc('SUMX2MY2', (arrayX: EvalResult, arrayY: EvalResult) => { const x = getNumbers([arrayX]); const y = getNumbers([arrayY]); if (x.length !== y.length) { throw FormulaError.VALUE; } return x.reduce((prev, cur, i) => prev + cur ** 2 - y[i] ** 2, 0); }); regFunc('SUMX2PY2', (arrayX: EvalResult, arrayY: EvalResult) => { const x = getNumbers([arrayX]); const y = getNumbers([arrayY]); if (x.length !== y.length) { throw FormulaError.VALUE; } return x.reduce((prev, cur, i) => prev + cur ** 2 + y[i] ** 2, 0); }); regFunc('SUMXMY2', (arrayX: EvalResult, arrayY: EvalResult) => { const x = getNumbers([arrayX]); const y = getNumbers([arrayY]); if (x.length !== y.length) { throw FormulaError.VALUE; } return x.reduce((prev, cur, i) => prev + (cur - y[i]) ** 2, 0); }); regFunc('TRUNC', (arg: EvalResult) => { const num = getNumberOrThrow(arg); return num >= 0 ? Math.floor(num) : Math.ceil(num); });