Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

fix(formula): fix the issue in some formulas where the range parameter is not a reference object (#5872)

wpxp12345603d0ee5b87ea
diff --git a/packages/engine-formula/src/engine/utils/value-object.ts b/packages/engine-formula/src/engine/utils/value-object.ts
index b1f2a62e46..bebc49dc9c 100644
--- a/packages/engine-formula/src/engine/utils/value-object.ts
+++ b/packages/engine-formula/src/engine/utils/value-object.ts
@@ -16,7 +16,6 @@
import type { ICellData, Nullable } from '@univerjs/core';
import type { BaseReferenceObject, FunctionVariantType } from '../reference-object/base-reference-object';
-import type { ArrayValueObject } from '../value-object/array-value-object';
import type { BaseValueObject } from '../value-object/base-value-object';
import { CellValueType } from '@univerjs/core';
import { ErrorType } from '../../basics/error-type';
@@ -24,6 +23,7 @@ import { compareToken } from '../../basics/token';
import { CellReferenceObject } from '../reference-object/cell-reference-object';
import { ColumnReferenceObject } from '../reference-object/column-reference-object';
import { RowReferenceObject } from '../reference-object/row-reference-object';
+import { ArrayValueObject } from '../value-object/array-value-object';
import { ErrorValueObject } from '../value-object/base-value-object';
import { BooleanValueObject, NumberValueObject } from '../value-object/primitive-object';
import { expandArrayValueObject } from './array-object';
@@ -176,23 +176,138 @@ export function calculateMaxDimensions(variants: BaseValueObject[]) {
return { maxRowLength, maxColumnLength };
}
-export function getErrorArray(variants: BaseValueObject[], sumRange: BaseValueObject, maxRowLength: number, maxColumnLength: number) {
- const sumRowLength = (sumRange as ArrayValueObject).getRowCount();
- const sumColumnLength = (sumRange as ArrayValueObject).getColumnCount();
+/**
+ * Parse the paired range and criteria in functions like COUNTIFS, SUMIFS, etc.
+ * @param variants - The range and criteria pairs
+ * @param targetRange - The target range for calculation (e.g., sumRange in SUMIFS)
+ * @returns An object containing parsed information
+ */
+// eslint-disable-next-line max-lines-per-function
+export function parsePairedRangeAndCriteria(
+ variants: FunctionVariantType[],
+ targetRange?: FunctionVariantType
+): {
+ isError: boolean;
+ errorObject: Nullable<ErrorValueObject>;
+ rangeIsDifferentSize: boolean;
+ criteriaMaxRowLength: number;
+ criteriaMaxColumnLength: number;
+ targetRange: Nullable<BaseValueObject>;
+ variants: BaseValueObject[];
+} {
+ /**
+ * The range and criteria must be in pairs.
+ * If not, Excel will prevent the operation. But we can't do it like that, so we just return a #VALUE! error.
+ */
+ if (variants.length === 0 || variants.length % 2 !== 0) {
+ return {
+ isError: true,
+ errorObject: ErrorValueObject.create(ErrorType.VALUE),
+ rangeIsDifferentSize: false,
+ criteriaMaxRowLength: 0,
+ criteriaMaxColumnLength: 0,
+ targetRange: null,
+ variants: [],
+ };
+ }
+
+ let _targetRange: Nullable<BaseValueObject> = null;
+ let targetRangeRowCount = -1;
+ let targetRangeColumnCount = -1;
+
+ if (targetRange) {
+ /**
+ * If the target range is provided, it must be a reference object.
+ * If not, Excel will prevent the operation. But we can't do it like that, so we just return a #VALUE! error.
+ */
+ if (!targetRange.isReferenceObject()) {
+ return {
+ isError: true,
+ errorObject: ErrorValueObject.create(ErrorType.VALUE),
+ rangeIsDifferentSize: false,
+ criteriaMaxRowLength: 0,
+ criteriaMaxColumnLength: 0,
+ targetRange: null,
+ variants: [],
+ };
+ }
+
+ _targetRange = (targetRange as BaseReferenceObject).toArrayValueObject();
+ targetRangeRowCount = (_targetRange as ArrayValueObject).getRowCount();
+ targetRangeColumnCount = (_targetRange as ArrayValueObject).getColumnCount();
+ }
+
+ let criteriaMaxRowLength = 0;
+ let criteriaMaxColumnLength = 0;
+ let rangeIsDifferentSize = false;
+
+ const _variants: BaseValueObject[] = [];
for (let i = 0; i < variants.length; i++) {
- if (i % 2 === 1) continue;
+ if (i % 2 === 1) {
+ const range = variants[i - 1];
+ const criteria = variants[i];
+
+ /**
+ * The range must be a reference object.
+ * If not, Excel will prevent the operation. But we can't do it like that, so we just return a #VALUE! error.
+ */
+ if (!range.isReferenceObject()) {
+ return {
+ isError: true,
+ errorObject: ErrorValueObject.create(ErrorType.VALUE),
+ rangeIsDifferentSize: false,
+ criteriaMaxRowLength: 0,
+ criteriaMaxColumnLength: 0,
+ targetRange: null,
+ variants: [],
+ };
+ }
- const range = variants[i];
+ const _range = (range as BaseReferenceObject).toArrayValueObject();
+ const rangeRowCount = _range.getRowCount();
+ const rangeColumnCount = _range.getColumnCount();
+
+ if (i === 1 && targetRangeRowCount === -1 && targetRangeColumnCount === -1) {
+ // If the target range is not specified, use the first range as the target range. e.g. COUNTIFS(A1:A3, ">1", B1:B3, "<5").
+ targetRangeRowCount = rangeRowCount;
+ targetRangeColumnCount = rangeColumnCount;
+ } else if (!rangeIsDifferentSize && (targetRangeRowCount !== rangeRowCount || targetRangeColumnCount !== rangeColumnCount)) {
+ // The size of each range must be the same as the target range
+ rangeIsDifferentSize = true;
+ }
+
+ let _criteria = criteria;
- const rangeRowLength = (range as ArrayValueObject).getRowCount();
- const rangeColumnLength = (range as ArrayValueObject).getColumnCount();
- if (rangeRowLength !== sumRowLength || rangeColumnLength !== sumColumnLength) {
- return expandArrayValueObject(maxRowLength, maxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
+ if (criteria.isReferenceObject()) {
+ _criteria = (criteria as BaseReferenceObject).toArrayValueObject();
+ }
+
+ criteriaMaxRowLength = Math.max(criteriaMaxRowLength, _criteria.isArray() ? (_criteria as ArrayValueObject).getRowCount() : 1);
+ criteriaMaxColumnLength = Math.max(criteriaMaxColumnLength, _criteria.isArray() ? (_criteria as ArrayValueObject).getColumnCount() : 1);
+
+ _variants.push(_range);
+ _variants.push(_criteria as BaseValueObject);
}
}
- return null;
+ return {
+ isError: false,
+ errorObject: null,
+ rangeIsDifferentSize,
+ criteriaMaxRowLength,
+ criteriaMaxColumnLength,
+ targetRange: _targetRange,
+ variants: _variants,
+ };
+}
+
+export function baseValueObjectToArrayValueObject(valueObject: BaseValueObject): ArrayValueObject {
+ if (valueObject.isArray()) {
+ return valueObject as ArrayValueObject;
+ }
+
+ return ArrayValueObject.createByArray([[valueObject.getValue()]]);
}
export function getBooleanResults(variants: BaseValueObject[], maxRowLength: number, maxColumnLength: number, isNumberSensitive: boolean = false) {
diff --git a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
index 85bf3691d7..a5e925ce02 100644
--- a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
+++ b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
@@ -600,24 +600,16 @@ describe('Test nested functions', () => {
it('Sumifs test, range is number, criteria is number string', () => {
let result = calculate('=SUMIFS(A11:C11,A11:C11,"2")');
- expect(result).toStrictEqual([
- [2],
- ]);
+ expect(result).toBe(2);
result = calculate('=SUMIFS(A11:C11,A11:C11,A12)');
- expect(result).toStrictEqual([
- [2],
- ]);
+ expect(result).toBe(2);
result = calculate('=SUMIFS(A11:C11,A11:C11,"2",A11:C11,3)');
- expect(result).toStrictEqual([
- [0],
- ]);
+ expect(result).toBe(0);
result = calculate('=SUMIFS(A11:C11,A11:C11,"2",A11:C11,2)');
- expect(result).toStrictEqual([
- [2],
- ]);
+ expect(result).toBe(2);
result = calculate('=SUMIF(A11:C11,"1",A11:C11)');
expect(result).toBe(1);
diff --git a/packages/engine-formula/src/functions/lookup/xlookup/index.ts b/packages/engine-formula/src/functions/lookup/xlookup/index.ts
index 7f31363c6c..9bebdb8eab 100644
--- a/packages/engine-formula/src/functions/lookup/xlookup/index.ts
+++ b/packages/engine-formula/src/functions/lookup/xlookup/index.ts
@@ -20,6 +20,7 @@ import type { ArrayValueObject } from '../../../engine/value-object/array-value-
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
import { ArrayOrderSearchType, getMatchModeValue, getSearchModeValue } from '../../../engine/utils/compare';
+import { baseValueObjectToArrayValueObject } from '../../../engine/utils/value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
@@ -32,12 +33,12 @@ export class Xlookup extends BaseFunction {
// eslint-disable-next-line
override calculate(
lookupValue: BaseValueObject,
- lookupArray: ArrayValueObject,
- returnArray: ArrayValueObject,
+ lookupArray: BaseValueObject,
+ returnArray: BaseValueObject,
ifNotFound?: BaseValueObject,
matchMode?: BaseValueObject,
searchMode?: BaseValueObject
- ) {
+ ): BaseValueObject {
let _ifNotFound = ifNotFound ?? ErrorValueObject.create(ErrorType.NA);
if (ifNotFound?.isNull()) {
_ifNotFound = ErrorValueObject.create(ErrorType.NA);
@@ -57,18 +58,10 @@ export class Xlookup extends BaseFunction {
return lookupValue;
}
- if (lookupArray.isError() || returnArray.isError()) {
- return ErrorValueObject.create(ErrorType.REF);
- }
-
- if (!lookupArray.isArray() || !returnArray.isArray()) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
-
- const rowCountLookup = lookupArray.getRowCount();
- const columnCountLookup = lookupArray.getColumnCount();
- const rowCountReturn = returnArray.getRowCount();
- const columnCountReturn = returnArray.getColumnCount();
+ const rowCountLookup = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getRowCount() : 1;
+ const columnCountLookup = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getColumnCount() : 1;
+ const rowCountReturn = returnArray.isArray() ? (returnArray as ArrayValueObject).getRowCount() : 1;
+ const columnCountReturn = returnArray.isArray() ? (returnArray as ArrayValueObject).getColumnCount() : 1;
if (
(rowCountLookup !== 1 && columnCountLookup !== 1) ||
@@ -100,8 +93,8 @@ export class Xlookup extends BaseFunction {
return this._getResult(
lookupValue,
- lookupArray,
- returnArray,
+ baseValueObjectToArrayValueObject(lookupArray),
+ baseValueObjectToArrayValueObject(returnArray),
_ifNotFound,
matchModeValue,
searchModeValue,
diff --git a/packages/engine-formula/src/functions/lookup/xmatch/index.ts b/packages/engine-formula/src/functions/lookup/xmatch/index.ts
index 1e45c84b76..3b2b6742ff 100644
--- a/packages/engine-formula/src/functions/lookup/xmatch/index.ts
+++ b/packages/engine-formula/src/functions/lookup/xmatch/index.ts
@@ -15,101 +15,129 @@
*/
import type { Nullable } from '@univerjs/core';
-
+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
import { compareToken } from '../../../basics/token';
+import { expandArrayValueObject } from '../../../engine/utils/array-object';
import { ArrayOrderSearchType, getMatchModeValue, getSearchModeValue } from '../../../engine/utils/compare';
+import { baseValueObjectToArrayValueObject } from '../../../engine/utils/value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
-import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
-import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
export class Xmatch extends BaseFunction {
override minParams = 2;
override maxParams = 4;
- override calculate(
- lookupValue: BaseValueObject,
- lookupArray: ArrayValueObject,
- matchMode?: BaseValueObject,
- searchMode?: BaseValueObject
- ) {
- if (lookupValue.isError()) {
- return lookupValue;
+ override calculate(lookupValue: BaseValueObject, lookupArray: BaseValueObject, matchMode?: BaseValueObject, searchMode?: BaseValueObject): BaseValueObject {
+ let _matchMode: BaseValueObject = NumberValueObject.create(0);
+ if (matchMode && !matchMode.isNull()) {
+ _matchMode = matchMode;
}
- if (lookupArray.isError()) {
- return ErrorValueObject.create(ErrorType.REF);
+ let _searchMode: BaseValueObject = NumberValueObject.create(1);
+ if (searchMode && !searchMode.isNull()) {
+ _searchMode = searchMode;
}
- if (!lookupArray.isArray()) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ const maxRowLength = Math.max(
+ lookupValue.isArray() ? (lookupValue as ArrayValueObject).getRowCount() : 1,
+ _matchMode.isArray() ? (_matchMode as ArrayValueObject).getRowCount() : 1,
+ _searchMode.isArray() ? (_searchMode as ArrayValueObject).getRowCount() : 1
+ );
+
+ const maxColumnLength = Math.max(
+ lookupValue.isArray() ? (lookupValue as ArrayValueObject).getColumnCount() : 1,
+ _matchMode.isArray() ? (_matchMode as ArrayValueObject).getColumnCount() : 1,
+ _searchMode.isArray() ? (_searchMode as ArrayValueObject).getColumnCount() : 1
+ );
+
+ const lookupValueArray = expandArrayValueObject(maxRowLength, maxColumnLength, lookupValue, ErrorValueObject.create(ErrorType.NA));
+ const matchModeArray = expandArrayValueObject(maxRowLength, maxColumnLength, _matchMode, ErrorValueObject.create(ErrorType.NA));
+ const searchModeArray = expandArrayValueObject(maxRowLength, maxColumnLength, _searchMode, ErrorValueObject.create(ErrorType.NA));
+
+ const resultArray = lookupValueArray.mapValue((lookupValueObject, rowIndex, columnIndex) => {
+ if (lookupValueObject.isError()) {
+ return lookupValueObject;
+ }
+
+ const matchModeObject = matchModeArray.get(rowIndex, columnIndex) as BaseValueObject;
+ const searchModeObject = searchModeArray.get(rowIndex, columnIndex) as BaseValueObject;
+
+ if (matchModeObject.isError()) {
+ return matchModeObject;
+ }
+
+ if (searchModeObject.isError()) {
+ return searchModeObject;
+ }
+
+ return this._handleSingleObject(lookupValueObject, lookupArray, matchModeObject, searchModeObject);
+ });
+
+ if (maxRowLength === 1 && maxColumnLength === 1) {
+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;
}
- const rowCountLookup = lookupArray.getRowCount();
+ return resultArray;
+ }
- const columnCountLookup = lookupArray.getColumnCount();
+ private _handleSingleObject(lookupValue: BaseValueObject, lookupArray: BaseValueObject, matchMode: BaseValueObject, searchMode: BaseValueObject): BaseValueObject {
+ const lookupArrayRowCount = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getRowCount() : 1;
+ const lookupArrayColumnCount = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getColumnCount() : 1;
- if (rowCountLookup !== 1 && columnCountLookup !== 1) {
+ // Single row or single column
+ if (lookupArrayRowCount !== 1 && lookupArrayColumnCount !== 1) {
return ErrorValueObject.create(ErrorType.VALUE);
}
- if (matchMode?.isError()) {
- return ErrorValueObject.create(ErrorType.NA);
+ let _matchMode = matchMode;
+
+ if (matchMode.isString() || matchMode.isBoolean() || matchMode.isNull()) {
+ _matchMode = matchMode.convertToNumberObjectValue();
}
- if (searchMode?.isError()) {
- return ErrorValueObject.create(ErrorType.NA);
+ if (_matchMode.isError()) {
+ return _matchMode;
}
- const matchModeValue = this.getIndexNumValue(matchMode || NumberValueObject.create(0));
+ let _searchMode = searchMode;
- if (matchModeValue instanceof ErrorValueObject) {
- return matchModeValue;
+ if (searchMode.isString() || searchMode.isBoolean() || searchMode.isNull()) {
+ _searchMode = searchMode.convertToNumberObjectValue();
}
- const searchModeValue = this.getIndexNumValue(searchMode || NumberValueObject.create(1));
-
- if (searchModeValue instanceof ErrorValueObject) {
- return searchModeValue;
+ if (_searchMode.isError()) {
+ return _searchMode;
}
- if (lookupValue.isArray()) {
- return lookupValue.map((value) => this._handleSingleObject(
- value,
- lookupArray,
- matchModeValue,
- searchModeValue
- ));
+ const matchModeValue = (_matchMode as NumberValueObject).getValue();
+ const searchModeValue = (_searchMode as NumberValueObject).getValue();
+
+ if (![-1, 0, 1, 2].includes(matchModeValue) || ![-1, 1, 2].includes(searchModeValue)) {
+ return ErrorValueObject.create(ErrorType.VALUE);
}
- return this._handleSingleObject(
- lookupValue,
- lookupArray,
- matchModeValue,
- searchModeValue
- );
+ return this._getResult(lookupValue, lookupArray, matchModeValue, searchModeValue);
}
- private _handleSingleObject(
- value: BaseValueObject,
- searchArray: ArrayValueObject,
- matchModeValue: number,
- searchModeValue: number
- ) {
+ private _getResult(lookupValue: BaseValueObject, lookupArray: BaseValueObject, matchMode: number, searchMode: number) {
+ const _lookupArray = baseValueObjectToArrayValueObject(lookupArray);
+
let rowOrColumn: Nullable<number>;
- if ((searchModeValue === 2 || searchModeValue === -2) && matchModeValue !== 2) {
- const searchType = getSearchModeValue(searchModeValue);
- const matchType = getMatchModeValue(matchModeValue);
- rowOrColumn = searchArray.binarySearch(value, searchType, matchType);
- } else if (matchModeValue === 2) {
- const matchObject = searchArray.compare(value, compareToken.EQUALS) as ArrayValueObject;
+
+ if ((searchMode === 2 || searchMode === -2) && matchMode !== 2) {
+ const searchType = getSearchModeValue(searchMode);
+ const matchType = getMatchModeValue(matchMode);
+ rowOrColumn = _lookupArray.binarySearch(lookupValue, searchType, matchType);
+ } else if (matchMode === 2) {
+ const matchObject = _lookupArray.compare(lookupValue, compareToken.EQUALS) as ArrayValueObject;
let position: Nullable<{ row: number; column: number }>;
- if (searchModeValue !== -1) {
+ if (searchMode !== -1) {
position = matchObject.getFirstTruePosition();
} else {
position = matchObject.getLastTruePosition();
@@ -118,9 +146,9 @@ export class Xmatch extends BaseFunction {
return ErrorValueObject.create(ErrorType.NA);
}
- rowOrColumn = searchArray.getRowCount() === 1 ? position.column : position.row;
- } else if (matchModeValue === -1 || matchModeValue === 1) {
- const position = searchArray.orderSearch(value, matchModeValue === 1 ? ArrayOrderSearchType.MAX : ArrayOrderSearchType.MIN, searchModeValue === -1);
+ rowOrColumn = _lookupArray.getRowCount() === 1 ? position.column : position.row;
+ } else if (matchMode === -1 || matchMode === 1) {
+ const position = _lookupArray.orderSearch(lookupValue, matchMode === 1 ? ArrayOrderSearchType.MAX : ArrayOrderSearchType.MIN, searchMode === -1);
if (position == null) {
return ErrorValueObject.create(ErrorType.NA);
@@ -130,13 +158,13 @@ export class Xmatch extends BaseFunction {
return position;
}
- rowOrColumn = searchArray.getRowCount() === 1 ? position.column : position.row;
+ rowOrColumn = _lookupArray.getRowCount() === 1 ? position.column : position.row;
} else {
- const matchObject = searchArray.isEqual(value) as ArrayValueObject;
+ const matchObject = _lookupArray.isEqual(lookupValue) as ArrayValueObject;
let position: Nullable<{ row: number; column: number }>;
- if (searchModeValue !== -1) {
+ if (searchMode !== -1) {
position = matchObject.getFirstTruePosition();
} else {
position = matchObject.getLastTruePosition();
@@ -146,7 +174,7 @@ export class Xmatch extends BaseFunction {
return ErrorValueObject.create(ErrorType.NA);
}
- rowOrColumn = searchArray.getRowCount() === 1 ? position.column : position.row;
+ rowOrColumn = _lookupArray.getRowCount() === 1 ? position.column : position.row;
}
if (rowOrColumn == null) {
diff --git a/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts
index bd60409f36..4392d0b031 100644
--- a/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts
@@ -16,7 +16,6 @@
import type { Injector, IWorkbookData } from '@univerjs/core';
import type { LexerNode } from '../../../../engine/analysis/lexer-node';
-
import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
import { CellValueType, LocaleType } from '@univerjs/core';
import { beforeEach, describe, expect, it } from 'vitest';
@@ -244,18 +243,13 @@ describe('Test sumif function', () => {
const error = ErrorValueObject.create(ErrorType.NAME);
const result = await calculate(`=SUMIF(${error},A1:A4)`);
- expect(result).toStrictEqual([
- [ErrorType.NAME],
- [ErrorType.NAME],
- [ErrorType.NAME],
- [ErrorType.NAME],
- ]);
+ expect(result).toBe(ErrorType.VALUE);
const result2 = await calculate(`=SUMIF(A1:A4,${error})`);
- expect(result2).toBe(ErrorType.NAME);
+ expect(result2).toBe(0);
const result3 = await calculate(`=SUMIF(A1:A4,">40",${error})`);
- expect(result3).toBe(ErrorType.NAME);
+ expect(result3).toBe(ErrorType.VALUE);
});
it('Range or sumRange is not referenceObject', async () => {
diff --git a/packages/engine-formula/src/functions/math/sumif/index.ts b/packages/engine-formula/src/functions/math/sumif/index.ts
index 7200014259..fb6da9bec0 100644
--- a/packages/engine-formula/src/functions/math/sumif/index.ts
+++ b/packages/engine-formula/src/functions/math/sumif/index.ts
@@ -31,6 +31,10 @@ export class Sumif extends BaseFunction {
override needsReferenceObject = true;
override calculate(range: FunctionVariantType, criteria: FunctionVariantType, sumRange?: FunctionVariantType): BaseValueObject {
+ if (!range.isReferenceObject() || (sumRange && !sumRange.isReferenceObject())) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
let _criteria = criteria;
if (criteria.isReferenceObject()) {
@@ -51,22 +55,6 @@ export class Sumif extends BaseFunction {
}
private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject, sumRange?: FunctionVariantType): BaseValueObject {
- if (range.isError()) {
- return range as ErrorValueObject;
- }
-
- if (criteria.isError()) {
- return criteria;
- }
-
- if (sumRange?.isError()) {
- return sumRange as ErrorValueObject;
- }
-
- if (!range.isReferenceObject() || (sumRange && !sumRange.isReferenceObject())) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
-
const _range = (range as BaseReferenceObject).toArrayValueObject();
let resultArrayObject = valueObjectCompare(_range, criteria);
diff --git a/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts
index 1e3621c187..cb6aad6872 100644
--- a/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts
@@ -14,181 +14,219 @@
* limitations under the License.
*/
-import { describe, expect, it } from 'vitest';
+import type { Injector, IWorkbookData } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { CellValueType, LocaleType } from '@univerjs/core';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';
-import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { Lexer } from '../../../../engine/analysis/lexer';
+import { AstTreeBuilder } from '../../../../engine/analysis/parser';
+import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
+import { IFunctionService } from '../../../../services/function.service';
+import { IFormulaRuntimeService } from '../../../../services/runtime.service';
+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_MATH } from '../../function-names';
import { Sumifs } from '../index';
-describe('Test sumifs function', () => {
- const testFunction = new Sumifs(FUNCTION_NAMES_MATH.SUMIF);
+const getTestWorkbookData = (): IWorkbookData => {
+ return {
+ id: 'test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ cellData: {
+ 0: {
+ 0: {
+ v: 1,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 1: {
+ 0: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 2: {
+ 0: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 3: {
+ 0: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 7,
+ t: CellValueType.NUMBER,
+ },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: [],
+ styles: {},
+ };
+};
- describe('Sumifs', () => {
- it('Range and criteria', async () => {
- const sumRange = ArrayValueObject.create(/*ts*/ `{
- 1;
- 1;
- 1
- }`);
- const range = ArrayValueObject.create(/*ts*/ `{
- 2;
- 3;
- 4
- }`);
-
- const criteria = StringValueObject.create('>2');
-
- const resultObject = testFunction.calculate(sumRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);
+describe('Test sumifs function', () => {
+ let get: Injector['get'];
+ let lexer: Lexer;
+ let astTreeBuilder: AstTreeBuilder;
+ let interpreter: Interpreter;
+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;
+
+ beforeEach(() => {
+ const testBed = createFunctionTestBed(getTestWorkbookData());
+
+ get = testBed.get;
+
+ lexer = get(Lexer);
+ astTreeBuilder = get(AstTreeBuilder);
+ interpreter = get(Interpreter);
+
+ const functionService = get(IFunctionService);
+
+ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);
+
+ const formulaRuntimeService = get(IFormulaRuntimeService);
+
+ formulaCurrentConfigService.load({
+ formulaData: {},
+ arrayFormulaCellData: {},
+ arrayFormulaRange: {},
+ forceCalculate: false,
+ dirtyRanges: [],
+ dirtyNameMap: {},
+ dirtyDefinedNameMap: {},
+ dirtyUnitFeatureMap: {},
+ dirtyUnitOtherFormulaMap: {},
+ excludedCell: {},
+ allUnitData: {
+ [testBed.unitId]: testBed.sheetData,
+ },
});
- it('Range and criteria, compare string', async () => {
- const sumRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
- const range = ArrayValueObject.create(`{
- a;
- b;
- c
- }`);
-
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(sumRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[0]]);
- });
+ const sheetItem = testBed.sheetData[testBed.sheetId];
- it('Range and array criteria', async () => {
- const sumRange = ArrayValueObject.create(/*ts*/ `{
- 1;
- 1;
- 1
- }`);
- const range = ArrayValueObject.create(/*ts*/ `{
- 2;
- 3;
- 4
- }`);
-
- const criteria = ArrayValueObject.create(/*ts*/ `{
- >2;
- >3;
- >4
- }`);
-
- const resultObject = testFunction.calculate(sumRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [1], [0]]);
- });
+ formulaRuntimeService.setCurrent(
+ 0,
+ 0,
+ sheetItem.rowCount,
+ sheetItem.columnCount,
+ testBed.sheetId,
+ testBed.unitId
+ );
- it('2 ranges and criteria', async () => {
- const sumRange = ArrayValueObject.create(/*ts*/ `{
- 1;
- 1;
- 1
- }`);
+ functionService.registerExecutors(
+ new Sumifs(FUNCTION_NAMES_MATH.SUMIFS)
+ );
- const range1 = ArrayValueObject.create(/*ts*/ `{
- 2;
- 3;
- 4
- }`);
+ calculate = (formula: string) => {
+ const lexerNode = lexer.treeBuilder(formula);
- const criteria1 = StringValueObject.create('>2');
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const range2 = ArrayValueObject.create(/*ts*/ `{
- 3;
- 4;
- 5
- }`);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
- const criteria2 = StringValueObject.create('<5');
+ return getObjectValue(result);
+ };
+ });
- const resultObject = testFunction.calculate(sumRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1]]);
+ describe('Sumifs', () => {
+ it('Value is normal', async () => {
+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">3")');
+ expect(result).toBe(7);
+ });
+
+ it('Value is array', async () => {
+ const result = await calculate('=SUMIFS({1;2;3;4},B1:B4,">3")');
+ expect(result).toBe(ErrorType.VALUE);
});
- it('2 ranges and criteria, 1 array criteria', async () => {
- const sumRange = ArrayValueObject.create(/*ts*/ `{
- 1;
- 1;
- 1
- }`);
-
- const range1 = ArrayValueObject.create(/*ts*/ `{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(/*ts*/ `{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(/*ts*/ `{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = NumberValueObject.create(5);
-
- const resultObject = testFunction.calculate(sumRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [1], [0]]);
+ it('Range and criteria is not paired', async () => {
+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">3",C1:C4)');
+ expect(result).toBe(ErrorType.VALUE);
});
- it('2 ranges and criteria, 2 array criteria', async () => {
- const sumRange = ArrayValueObject.create(/*ts*/ `{
- 1;
- 1;
- 1
- }`);
-
- const range1 = ArrayValueObject.create(/*ts*/ `{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(/*ts*/ `{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(/*ts*/ `{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = ArrayValueObject.create(/*ts*/ `{
- 4;
- 4;
- 4;
- 4
- }`);
-
- const resultObject = testFunction.calculate(sumRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [0], [0], [0]]);
+ it('Range is different size', async () => {
+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">3",C1:C3,{"=5","=6"})');
+ expect(result).toStrictEqual([
+ [ErrorType.VALUE, ErrorType.VALUE],
+ ]);
});
- it('Includes REF error', async () => {
- const range = ErrorValueObject.create(ErrorType.REF);
+ it('Range and array criteria', async () => {
+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,{">1";">2"})');
+ expect(result).toStrictEqual([
+ [10],
+ [9],
+ ]);
+ });
- const criteria = ArrayValueObject.create(/*ts*/ `{
- 4;
- 4;
- 44;
- 444
- }`);
+ it('Two ranges and criteria', async () => {
+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">2",C1:C4,"=5")');
+ expect(result).toBe(3);
+ });
- const resultObject = testFunction.calculate(range, criteria);
- expect(resultObject.getValue()).toStrictEqual(ErrorType.REF);
+ it('Two ranges and criteria, criteria is array', async () => {
+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">2",C1:C4,{">4";">5"})');
+ expect(result).toStrictEqual([
+ [7],
+ [4],
+ ]);
});
});
});
diff --git a/packages/engine-formula/src/functions/math/sumifs/index.ts b/packages/engine-formula/src/functions/math/sumifs/index.ts
index fdcf8afaeb..4f7ec8ee5d 100644
--- a/packages/engine-formula/src/functions/math/sumifs/index.ts
+++ b/packages/engine-formula/src/functions/math/sumifs/index.ts
@@ -14,9 +14,11 @@
* limitations under the License.
*/
-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';
+import { expandArrayValueObject } from '../../../engine/utils/array-object';
+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
@@ -26,55 +28,55 @@ export class Sumifs extends BaseFunction {
override maxParams = 255;
- override calculate(sumRange: BaseValueObject, ...variants: BaseValueObject[]) {
- if (sumRange.isError()) {
- return sumRange;
- }
+ override needsReferenceObject = true;
- if (!sumRange.isArray()) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
+ override calculate(sumRange: FunctionVariantType, ...variants: FunctionVariantType[]) {
+ const {
+ isError,
+ errorObject,
+ rangeIsDifferentSize,
+ criteriaMaxRowLength,
+ criteriaMaxColumnLength,
+ targetRange: _sumRange,
+ variants: _variants,
+ } = parsePairedRangeAndCriteria(variants, sumRange);
- // Range and criteria must be paired
- if (variants.length < 2 || variants.length % 2 !== 0) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ if (isError) {
+ return errorObject as ErrorValueObject;
}
- // Every range must be array
- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
-
- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);
-
- const errorArray = getErrorArray(variants, sumRange, maxRowLength, maxColumnLength);
+ if (rangeIsDifferentSize) {
+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
- if (errorArray) {
- return errorArray;
+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);
+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
- return this._aggregateResults(sumRange, booleanResults);
+ return this._aggregateResults(_sumRange as BaseValueObject, booleanResults);
}
- private _aggregateResults(sumRange: BaseValueObject, booleanResults: BaseValueObject[][]): ArrayValueObject {
- const sumResults = booleanResults.map((row) => {
+ private _aggregateResults(sumRange: BaseValueObject, booleanResults: BaseValueObject[][]): BaseValueObject {
+ const results = booleanResults.map((row) => {
return row.map((booleanResult) => {
return (sumRange as ArrayValueObject).pick(booleanResult as ArrayValueObject).sum();
});
});
- const arrayValueObjectData: IArrayValueObject = {
- calculateValueList: sumResults,
- rowCount: sumResults.length,
- columnCount: sumResults[0].length,
+ if (results.length === 1 && results[0].length === 1) {
+ return results[0][0];
+ }
+
+ return ArrayValueObject.create({
+ calculateValueList: results,
+ rowCount: results.length,
+ columnCount: results[0].length,
unitId: this.unitId || '',
sheetId: this.subUnitId || '',
row: this.row,
column: this.column,
- };
-
- return ArrayValueObject.create(arrayValueObjectData);
+ });
}
}
diff --git a/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts
index 5b21676edb..aefa65f9c9 100644
--- a/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts
@@ -16,10 +16,7 @@
import type { Injector, IWorkbookData } from '@univerjs/core';
import type { LexerNode } from '../../../../engine/analysis/lexer-node';
-
import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
-import type { ArrayValueObject } from '../../../../engine/value-object/array-value-object';
-import type { BaseValueObject, ErrorValueObject } from '../../../../engine/value-object/base-value-object';
import { CellValueType, LocaleType } from '@univerjs/core';
import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
@@ -27,10 +24,11 @@ import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
-import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';
+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';
import { Averageif } from '../index';
@@ -48,98 +46,86 @@ const getTestWorkbookData = (): IWorkbookData => {
t: CellValueType.NUMBER,
},
1: {
- v: 2,
- t: CellValueType.NUMBER,
- },
- },
- 1: {
- 0: {
- v: 3,
- t: CellValueType.NUMBER,
- },
- 1: {
- v: 4,
- t: CellValueType.NUMBER,
+ v: true,
+ t: CellValueType.BOOLEAN,
},
2: {
- v: 'B2',
+ v: 'Ada',
t: CellValueType.STRING,
},
3: {
- v: 'R2C2',
- t: CellValueType.STRING,
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 4: {
+ v: 5,
+ t: CellValueType.NUMBER,
},
},
- 2: {
+ 1: {
0: {
- v: 1,
+ v: 4,
t: CellValueType.NUMBER,
},
1: {
- v: ' ',
- t: CellValueType.STRING,
+ v: false,
+ t: CellValueType.BOOLEAN,
},
2: {
- v: 1.23,
- t: CellValueType.NUMBER,
+ v: 'test1',
+ t: CellValueType.STRING,
},
3: {
- v: true,
- t: CellValueType.BOOLEAN,
+ v: 4,
+ t: CellValueType.NUMBER,
},
4: {
- v: false,
- t: CellValueType.BOOLEAN,
+ v: 4,
+ t: CellValueType.NUMBER,
},
},
- 3: {
+ 2: {
0: {
- v: 0,
+ v: 44,
t: CellValueType.NUMBER,
},
1: {
- v: '100',
+ v: null,
+ t: CellValueType.NUMBER,
},
2: {
- v: '2.34',
+ v: 'test12',
+ t: CellValueType.STRING,
},
3: {
- v: 'test',
- t: CellValueType.STRING,
+ v: 44,
+ t: CellValueType.NUMBER,
},
4: {
- v: -3,
+ v: 44,
t: CellValueType.NUMBER,
},
},
- 4: {
- 3: {
- v: 'test1',
- t: CellValueType.STRING,
- },
- },
- 5: {
+ 3: {
0: {
- v: 'Tom',
- t: CellValueType.STRING,
+ v: 444,
+ t: CellValueType.NUMBER,
},
1: {
- v: 'Sarah',
- t: CellValueType.STRING,
+ v: null,
+ t: CellValueType.NUMBER,
},
- 3: {
+ 2: {
v: 'Univer',
t: CellValueType.STRING,
},
- },
- 6: {
- 0: {
- v: 'Alex',
- t: CellValueType.STRING,
+ 3: {
+ v: 444,
+ t: CellValueType.NUMBER,
},
- 1: {
- v: 'Mickey',
- t: CellValueType.STRING,
+ 4: {
+ v: 444,
+ t: CellValueType.NUMBER,
},
},
},
@@ -151,7 +137,8 @@ const getTestWorkbookData = (): IWorkbookData => {
styles: {},
};
};
-describe('Test isref function', () => {
+
+describe('Test averageif function', () => {
let get: Injector['get'];
let lexer: Lexer;
let astTreeBuilder: AstTreeBuilder;
@@ -182,11 +169,11 @@ describe('Test isref function', () => {
dirtyNameMap: {},
dirtyDefinedNameMap: {},
dirtyUnitFeatureMap: {},
+ dirtyUnitOtherFormulaMap: {},
excludedCell: {},
allUnitData: {
[testBed.unitId]: testBed.sheetData,
},
- dirtyUnitOtherFormulaMap: {},
});
const sheetItem = testBed.sheetData[testBed.sheetId];
@@ -211,68 +198,68 @@ describe('Test isref function', () => {
const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
- if ((result as ErrorValueObject).isError()) {
- return (result as ErrorValueObject).getValue();
- } else if ((result as ArrayValueObject).isArray()) {
- return (result as ArrayValueObject).toValue();
- }
- return (result as BaseValueObject).getValue();
+ return getObjectValue(result);
};
});
describe('Averageif', () => {
it('Range and criteria', async () => {
- const result = await calculate('=AVERAGEIF(A1:A4,">0")');
-
- expect(result).toBe(1.6666666666666667);
+ const result = await calculate('=AVERAGEIF(A1:A4,">40")');
+ expect(result).toBe(244);
});
- it('Range and criteria, compare number', async () => {
- const result = await calculate('=AVERAGEIF(A6:A7,">1")');
+ it('Range and criteria, different type', async () => {
+ const result = await calculate('=AVERAGEIF(B1,">4",A1)');
expect(result).toBe(ErrorType.DIV_BY_ZERO);
});
- it('Range number', async () => {
- const result = await calculate('=AVERAGEIF(1,1)');
-
- expect(result).toBe(1);
- });
-
- it('Range string', async () => {
- const result = await calculate('=AVERAGEIF("test",">1")');
-
- expect(result).toBe(ErrorType.DIV_BY_ZERO);
+ it('averageRange with wildcard asterisk', async () => {
+ const result = await calculate('=AVERAGEIF(C1:C4,"test*",A1:A4)');
+ expect(result).toBe(24);
});
- it('Range string, average range number', async () => {
- const result = await calculate('=AVERAGEIF("test",1,1)');
-
- expect(result).toBe(ErrorType.NA);
+ it('ArrayValueObject range and ArrayValueObject criteria', async () => {
+ const result = await calculate('=AVERAGEIF(A1:A4,D1:D4)');
+ expect(result).toStrictEqual([
+ [4],
+ [4],
+ [44],
+ [444],
+ ]);
+
+ const result2 = await calculate('=AVERAGEIF(A1:A4,E1:E4)');
+ expect(result2).toStrictEqual([
+ [ErrorType.DIV_BY_ZERO],
+ [4],
+ [44],
+ [444],
+ ]);
+
+ const result3 = await calculate('=AVERAGEIF(A1:A4,A2)');
+ expect(result3).toBe(4);
});
- it('Range blank cell', async () => {
- const result = await calculate('=AVERAGEIF(A5,">1")');
+ it('Includes error', async () => {
+ const error = ErrorValueObject.create(ErrorType.NAME);
- expect(result).toBe(ErrorType.DIV_BY_ZERO);
- });
+ const result = await calculate(`=AVERAGEIF(${error},A1:A4)`);
+ expect(result).toBe(ErrorType.VALUE);
- it('Average range with wildcard asterisk', async () => {
- const result = await calculate('=AVERAGEIF(D4:D6,"test*",A1)');
+ const result2 = await calculate(`=AVERAGEIF(A1:A4,${error})`);
+ expect(result2).toBe(ErrorType.DIV_BY_ZERO);
- expect(result).toBe(2);
+ const result3 = await calculate(`=AVERAGEIF(A1:A4,">40",${error})`);
+ expect(result3).toBe(ErrorType.VALUE);
});
- it('ArrayValueObject range and ArrayValueObject criteria', async () => {
- const result = await calculate('=AVERAGEIF(A3:F4,A3:F4)');
-
- // [0][1] ErrorType.DIV_BY_ZERO refer to Google Sheets
- expect(result).toStrictEqual([[1, ErrorType.DIV_BY_ZERO, 1.23, ErrorType.DIV_BY_ZERO, ErrorType.DIV_BY_ZERO, 0], [0, 100, 2.34, ErrorType.DIV_BY_ZERO, -3, 0]]);
+ it('Range or averageRange is not referenceObject', async () => {
+ const result = await calculate('=AVERAGEIF(1,"test*",A1:A4)');
+ expect(result).toBe(ErrorType.VALUE);
});
- it('ArrayValueObject range and string criteria', async () => {
- const result = await calculate('=AVERAGEIF(A3:F4," ")');
-
- expect(result).toBe(ErrorType.DIV_BY_ZERO);
+ it('Range length is not equal to averageRange length', async () => {
+ const result = await calculate('=AVERAGEIF(A1:A4,">40",E1:E2)');
+ expect(result).toBe(244);
});
});
});
diff --git a/packages/engine-formula/src/functions/statistical/averageif/index.ts b/packages/engine-formula/src/functions/statistical/averageif/index.ts
index 47a9318d0b..274c63ccd9 100644
--- a/packages/engine-formula/src/functions/statistical/averageif/index.ts
+++ b/packages/engine-formula/src/functions/statistical/averageif/index.ts
@@ -18,7 +18,6 @@ import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/r
import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
-import { createNewArray } from '../../../engine/utils/array-object';
import { valueObjectCompare } from '../../../engine/utils/object-compare';
import { filterSameValueObjectResult } from '../../../engine/utils/value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
@@ -31,105 +30,66 @@ export class Averageif extends BaseFunction {
override needsReferenceObject = true;
- override calculate(range: FunctionVariantType, criteria: FunctionVariantType, averageRange?: FunctionVariantType) {
- if (range.isError()) {
- return range;
+ override calculate(range: FunctionVariantType, criteria: FunctionVariantType, averageRange?: FunctionVariantType): BaseValueObject {
+ if (!range.isReferenceObject() || (averageRange && !averageRange.isReferenceObject())) {
+ return ErrorValueObject.create(ErrorType.VALUE);
}
- if (criteria.isError()) {
- return criteria;
- }
+ let _criteria = criteria;
- if (averageRange?.isError()) {
- return averageRange;
+ if (criteria.isReferenceObject()) {
+ _criteria = (criteria as BaseReferenceObject).toArrayValueObject();
}
- let _range = range;
+ if (_criteria.isArray()) {
+ const resultArray = (_criteria as ArrayValueObject).mapValue((criteriaObject) => this._handleSingleObject(range, criteriaObject, averageRange));
- if (_range.isReferenceObject()) {
- _range = (_range as BaseReferenceObject).toArrayValueObject();
- }
+ if ((resultArray as ArrayValueObject).getRowCount() === 1 && (resultArray as ArrayValueObject).getColumnCount() === 1) {
+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;
+ }
- if (!_range.isArray()) {
- _range = createNewArray([[_range as BaseValueObject]], 1, 1);
+ return resultArray;
}
- let _criteria = criteria;
-
- if (_criteria.isReferenceObject()) {
- _criteria = (_criteria as BaseReferenceObject).toArrayValueObject();
- }
+ return this._handleSingleObject(range, _criteria as BaseValueObject, averageRange);
+ }
- if (averageRange && !averageRange?.isReferenceObject()) {
- return ErrorValueObject.create(ErrorType.NA);
- }
+ private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject, averageRange?: FunctionVariantType): BaseValueObject {
+ const _range = (range as BaseReferenceObject).toArrayValueObject();
- _criteria = _criteria as BaseValueObject;
+ let resultArrayObject = valueObjectCompare(_range, criteria);
- if (_criteria.isArray()) {
- return (_criteria as ArrayValueObject).map((criteriaItem) => this._handleSingleObject(_range as BaseValueObject, criteriaItem, averageRange as BaseReferenceObject));
- }
+ // When comparing non-numbers and numbers, it does not take the result
+ resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, _range, criteria);
- return this._handleSingleObject(_range as BaseValueObject, _criteria, averageRange as BaseReferenceObject);
- }
+ const rangeRowCount = _range.getRowCount();
+ const rangeColumnCount = _range.getColumnCount();
- private _handleSingleObject(range: BaseValueObject, criteria: BaseValueObject, averageRange?: BaseReferenceObject) {
- let resultArrayObject = valueObjectCompare(range, criteria);
+ let _averageRange = _range;
- // When comparing non-numbers and numbers, it does not take the result
- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, range as ArrayValueObject, criteria);
+ if (averageRange) {
+ _averageRange = (averageRange as BaseReferenceObject).toArrayValueObject();
- // averageRange has the same dimensions as range
- let averageRangeArray = averageRange
- ? this._createRangeReferenceObject(averageRange, range)
- : (range as ArrayValueObject);
+ const averageRangeRowCount = _averageRange.getRowCount();
+ const averageRangeColumnCount = _averageRange.getColumnCount();
- if (!averageRangeArray) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
+ // averageRange has different dimensions than range, then adjust averageRange dimensions to match range dimensions
+ // TODO: @DR-Univer The current situation is that the cell value in the extended range changes,
+ // but it is not within the formula parameter range, so it will not trigger the formula to recalculate.
+ if (rangeRowCount !== averageRangeRowCount || rangeColumnCount !== averageRangeColumnCount) {
+ const rangeData = (averageRange as BaseReferenceObject).getRangeData();
+ rangeData.endRow = rangeData.startRow + rangeRowCount - 1;
+ rangeData.endColumn = rangeData.startColumn + rangeColumnCount - 1;
- if (averageRangeArray.isError()) {
- return averageRangeArray as ErrorValueObject;
- }
+ (averageRange as BaseReferenceObject).setRangeData(rangeData);
- if (averageRangeArray.isReferenceObject()) {
- averageRangeArray = (averageRangeArray as BaseReferenceObject).toArrayValueObject();
+ _averageRange = (averageRange as BaseReferenceObject).toArrayValueObject();
+ }
}
- averageRangeArray = averageRangeArray as ArrayValueObject;
-
- const picked = averageRangeArray.pick(resultArrayObject as ArrayValueObject);
+ const picked = _averageRange.pick(resultArrayObject as ArrayValueObject);
const sum = picked.sum();
const count = picked.count();
return sum.divided(count);
}
-
- /**
- * Create reference object, starting from the first cell in the upper left corner, the height is rowCount and the width is columnCount
- * @param averageRange
- * @param rowCount
- * @param columnCount
- * @returns
- */
- private _createRangeReferenceObject(averageRange: BaseReferenceObject, range: BaseValueObject) {
- const averageRangeRow = averageRange.getRowCount();
- const averageRangeColumn = averageRange.getColumnCount();
-
- const rowCount = range.isArray() ? (range as ArrayValueObject).getRowCount() : 1;
- const columnCount = range.isArray() ? (range as ArrayValueObject).getColumnCount() : 1;
-
- if (averageRangeRow === rowCount && averageRangeColumn === columnCount) {
- return averageRange;
- }
-
- const { startRow, startColumn } = averageRange.getRangePosition();
- const rangeData = {
- startRow,
- startColumn,
- endRow: startRow + rowCount - 1,
- endColumn: startColumn + columnCount - 1,
- };
-
- return this.createReferenceObject(averageRange, rangeData);
- }
}
diff --git a/packages/engine-formula/src/functions/statistical/averageifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/averageifs/__tests__/index.spec.ts
index dbc11d43c2..e768f7d526 100644
--- a/packages/engine-formula/src/functions/statistical/averageifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/averageifs/__tests__/index.spec.ts
@@ -14,166 +14,219 @@
* limitations under the License.
*/
-import { describe, expect, it } from 'vitest';
+import type { Injector, IWorkbookData } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { CellValueType, LocaleType } from '@univerjs/core';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ErrorType } from '../../../../basics/error-type';
+import { Lexer } from '../../../../engine/analysis/lexer';
+import { AstTreeBuilder } from '../../../../engine/analysis/parser';
+import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
+import { IFunctionService } from '../../../../services/function.service';
+import { IFormulaRuntimeService } from '../../../../services/runtime.service';
+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';
import { Averageifs } from '../index';
-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
-import { ErrorType } from '../../../../basics/error-type';
-describe('Test averageifs function', () => {
- const testFunction = new Averageifs(FUNCTION_NAMES_STATISTICAL.AVERAGEIFS);
+const getTestWorkbookData = (): IWorkbookData => {
+ return {
+ id: 'test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ cellData: {
+ 0: {
+ 0: {
+ v: 1,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 1: {
+ 0: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 2: {
+ 0: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 3: {
+ 0: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 7,
+ t: CellValueType.NUMBER,
+ },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: [],
+ styles: {},
+ };
+};
- describe('Averageifs', () => {
- it('Range and criteria', async () => {
- const averageRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
- const range = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(averageRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2.5]]);
+describe('Test averageifs function', () => {
+ let get: Injector['get'];
+ let lexer: Lexer;
+ let astTreeBuilder: AstTreeBuilder;
+ let interpreter: Interpreter;
+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;
+
+ beforeEach(() => {
+ const testBed = createFunctionTestBed(getTestWorkbookData());
+
+ get = testBed.get;
+
+ lexer = get(Lexer);
+ astTreeBuilder = get(AstTreeBuilder);
+ interpreter = get(Interpreter);
+
+ const functionService = get(IFunctionService);
+
+ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);
+
+ const formulaRuntimeService = get(IFormulaRuntimeService);
+
+ formulaCurrentConfigService.load({
+ formulaData: {},
+ arrayFormulaCellData: {},
+ arrayFormulaRange: {},
+ forceCalculate: false,
+ dirtyRanges: [],
+ dirtyNameMap: {},
+ dirtyDefinedNameMap: {},
+ dirtyUnitFeatureMap: {},
+ dirtyUnitOtherFormulaMap: {},
+ excludedCell: {},
+ allUnitData: {
+ [testBed.unitId]: testBed.sheetData,
+ },
});
- it('Range and criteria, compare string', async () => {
- const averageRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
- const range = ArrayValueObject.create(`{
- a;
- b;
- c
- }`);
-
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(averageRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[ErrorType.DIV_BY_ZERO]]);
- });
+ const sheetItem = testBed.sheetData[testBed.sheetId];
- it('Range and array criteria', async () => {
- const averageRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const resultObject = testFunction.calculate(averageRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2.5], [3], [ErrorType.DIV_BY_ZERO]]);
- });
+ formulaRuntimeService.setCurrent(
+ 0,
+ 0,
+ sheetItem.rowCount,
+ sheetItem.columnCount,
+ testBed.sheetId,
+ testBed.unitId
+ );
- it('2 ranges and criteria', async () => {
- const averageRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
+ functionService.registerExecutors(
+ new Averageifs(FUNCTION_NAMES_STATISTICAL.AVERAGEIFS)
+ );
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
+ calculate = (formula: string) => {
+ const lexerNode = lexer.treeBuilder(formula);
- const criteria1 = StringValueObject.create('>2');
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
- const criteria2 = StringValueObject.create('<5');
+ return getObjectValue(result);
+ };
+ });
- const resultObject = testFunction.calculate(averageRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);
+ describe('Averageifs', () => {
+ it('Value is normal', async () => {
+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">3")');
+ expect(result).toBe(3.5);
+ });
+
+ it('Value is array', async () => {
+ const result = await calculate('=AVERAGEIFS({1;2;3;4},B1:B4,">3")');
+ expect(result).toBe(ErrorType.VALUE);
+ });
+
+ it('Range and criteria is not paired', async () => {
+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">3",C1:C4)');
+ expect(result).toBe(ErrorType.VALUE);
+ });
+
+ it('Range is different size', async () => {
+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">3",C1:C3,{"=5","=6"})');
+ expect(result).toStrictEqual([
+ [ErrorType.VALUE, ErrorType.VALUE],
+ ]);
+ });
+
+ it('Range and array criteria', async () => {
+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,{">1";">2"})');
+ expect(result).toStrictEqual([
+ [2.5],
+ [3],
+ ]);
});
- it('2 ranges and criteria, 1 array criteria', async () => {
- const averageRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = NumberValueObject.create(5);
-
- const resultObject = testFunction.calculate(averageRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3], [3], [ErrorType.DIV_BY_ZERO]]);
+ it('Two ranges and criteria', async () => {
+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">2",C1:C4,"=5")');
+ expect(result).toBe(3);
});
- it('2 ranges and criteria, 2 array criteria', async () => {
- const averageRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = ArrayValueObject.create(`{
- 4;
- 4;
- 4;
- 4
- }`);
-
- const resultObject = testFunction.calculate(averageRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [ErrorType.DIV_BY_ZERO], [ErrorType.DIV_BY_ZERO], [ErrorType.DIV_BY_ZERO]]);
+ it('Two ranges and criteria, criteria is array', async () => {
+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">2",C1:C4,{">4";">5"})');
+ expect(result).toStrictEqual([
+ [3.5],
+ [4],
+ ]);
});
});
});
diff --git a/packages/engine-formula/src/functions/statistical/averageifs/index.ts b/packages/engine-formula/src/functions/statistical/averageifs/index.ts
index e8ce56b030..e78caed5dc 100644
--- a/packages/engine-formula/src/functions/statistical/averageifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/averageifs/index.ts
@@ -14,10 +14,12 @@
* limitations under the License.
*/
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';
+import { expandArrayValueObject } from '../../../engine/utils/array-object';
+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
@@ -26,40 +28,38 @@ export class Averageifs extends BaseFunction {
override maxParams = 255;
- override calculate(averageRange: BaseValueObject, ...variants: BaseValueObject[]) {
- if (averageRange.isError()) {
- return ErrorValueObject.create(ErrorType.NA);
- }
+ override needsReferenceObject = true;
- if (!averageRange.isArray()) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
+ override calculate(averageRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject {
+ const {
+ isError,
+ errorObject,
+ rangeIsDifferentSize,
+ criteriaMaxRowLength,
+ criteriaMaxColumnLength,
+ targetRange: _averageRange,
+ variants: _variants,
+ } = parsePairedRangeAndCriteria(variants, averageRange);
- // Range and criteria must be paired
- if (variants.length % 2 !== 0) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ if (isError) {
+ return errorObject as ErrorValueObject;
}
- // Every range must be array
- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
-
- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);
-
- const errorArray = getErrorArray(variants, averageRange, maxRowLength, maxColumnLength);
+ if (rangeIsDifferentSize) {
+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
- if (errorArray) {
- return errorArray;
+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);
+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
- return this._aggregateResults(averageRange, booleanResults);
+ return this._aggregateResults(_averageRange as BaseValueObject, booleanResults);
}
- private _aggregateResults(averageRange: BaseValueObject, booleanResults: BaseValueObject[][]): ArrayValueObject {
- const maxResults = booleanResults.map((row) => {
+ private _aggregateResults(averageRange: BaseValueObject, booleanResults: BaseValueObject[][]): BaseValueObject {
+ const results = booleanResults.map((row) => {
return row.map((booleanResult) => {
const picked = (averageRange as ArrayValueObject).pick(booleanResult as ArrayValueObject);
const sum = picked.sum();
@@ -68,16 +68,18 @@ export class Averageifs extends BaseFunction {
});
});
- const arrayValueObjectData: IArrayValueObject = {
- calculateValueList: maxResults,
- rowCount: maxResults.length,
- columnCount: maxResults[0].length,
+ if (results.length === 1 && results[0].length === 1) {
+ return results[0][0];
+ }
+
+ return ArrayValueObject.create({
+ calculateValueList: results,
+ rowCount: results.length,
+ columnCount: results[0].length,
unitId: this.unitId || '',
sheetId: this.subUnitId || '',
row: this.row,
column: this.column,
- };
-
- return ArrayValueObject.create(arrayValueObjectData);
+ });
}
}
diff --git a/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts
index d64a26f81e..ebb508dd69 100644
--- a/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts
@@ -14,140 +14,229 @@
* limitations under the License.
*/
-import { describe, expect, it } from 'vitest';
+import type { Injector, IWorkbookData } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { CellValueType, LocaleType } from '@univerjs/core';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
-import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
-import { StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { Lexer } from '../../../../engine/analysis/lexer';
+import { AstTreeBuilder } from '../../../../engine/analysis/parser';
+import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
+import { IFunctionService } from '../../../../services/function.service';
+import { IFormulaRuntimeService } from '../../../../services/runtime.service';
+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';
import { Countif } from '../index';
-describe('Test countif function', () => {
- const testFunction = new Countif(FUNCTION_NAMES_STATISTICAL.COUNTIF);
+const getTestWorkbookData = (): IWorkbookData => {
+ return {
+ id: 'test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ cellData: {
+ 0: {
+ 0: {
+ v: 1,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: true,
+ t: CellValueType.BOOLEAN,
+ },
+ 2: {
+ v: 'Ada',
+ t: CellValueType.STRING,
+ },
+ 3: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 4: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 1: {
+ 0: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: false,
+ t: CellValueType.BOOLEAN,
+ },
+ 2: {
+ v: 'test1',
+ t: CellValueType.STRING,
+ },
+ 3: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 4: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 2: {
+ 0: {
+ v: 44,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: null,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 'test12',
+ t: CellValueType.STRING,
+ },
+ 3: {
+ v: 44,
+ t: CellValueType.NUMBER,
+ },
+ 4: {
+ v: 44,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 3: {
+ 0: {
+ v: 444,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: null,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 'Univer',
+ t: CellValueType.STRING,
+ },
+ 3: {
+ v: 444,
+ t: CellValueType.NUMBER,
+ },
+ 4: {
+ v: 444,
+ t: CellValueType.NUMBER,
+ },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: [],
+ styles: {},
+ };
+};
- describe('Countif', () => {
- it('Range and criteria', async () => {
- const range = ArrayValueObject.create(/*ts*/ `{
- 1;
- 4;
- 44;
- 444;
- Univer
- }`);
-
- const criteria = StringValueObject.create('>40');
-
- const resultObject = testFunction.calculate(range, criteria);
- expect(resultObject.getValue()).toBe(2);
+describe('Test countif function', () => {
+ let get: Injector['get'];
+ let lexer: Lexer;
+ let astTreeBuilder: AstTreeBuilder;
+ let interpreter: Interpreter;
+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;
+
+ beforeEach(() => {
+ const testBed = createFunctionTestBed(getTestWorkbookData());
+
+ get = testBed.get;
+
+ lexer = get(Lexer);
+ astTreeBuilder = get(AstTreeBuilder);
+ interpreter = get(Interpreter);
+
+ const functionService = get(IFunctionService);
+
+ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);
+
+ const formulaRuntimeService = get(IFormulaRuntimeService);
+
+ formulaCurrentConfigService.load({
+ formulaData: {},
+ arrayFormulaCellData: {},
+ arrayFormulaRange: {},
+ forceCalculate: false,
+ dirtyRanges: [],
+ dirtyNameMap: {},
+ dirtyDefinedNameMap: {},
+ dirtyUnitFeatureMap: {},
+ dirtyUnitOtherFormulaMap: {},
+ excludedCell: {},
+ allUnitData: {
+ [testBed.unitId]: testBed.sheetData,
+ },
});
- it('Average range with wildcard asterisk', async () => {
- const range = ArrayValueObject.create(/*ts*/ `{
- Ada;
- test1;
- test12;
- Univer
- }`);
+ const sheetItem = testBed.sheetData[testBed.sheetId];
- const criteria = StringValueObject.create('test*');
+ formulaRuntimeService.setCurrent(
+ 0,
+ 0,
+ sheetItem.rowCount,
+ sheetItem.columnCount,
+ testBed.sheetId,
+ testBed.unitId
+ );
- const resultObject = testFunction.calculate(range, criteria);
- expect(resultObject.getValue()).toBe(2);
- });
+ functionService.registerExecutors(
+ new Countif(FUNCTION_NAMES_STATISTICAL.COUNTIF)
+ );
- it('Average range with boolean', async () => {
- const range = ArrayValueObject.create(/*ts*/ `{
- TRUE;
- FALSE
- }`);
+ calculate = (formula: string) => {
+ const lexerNode = lexer.treeBuilder(formula);
- const criteria = StringValueObject.create('>FALSE');
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const resultObject = testFunction.calculate(range, criteria);
- expect(resultObject.getValue()).toBe(1);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
+
+ return getObjectValue(result);
+ };
+ });
+
+ describe('Countif', () => {
+ it('Range and criteria', async () => {
+ const result = await calculate('=COUNTIF(A1:A4,">40")');
+ expect(result).toBe(2);
});
it('ArrayValueObject range and ArrayValueObject criteria', async () => {
- const range = ArrayValueObject.create(/*ts*/ `{
- 1;
- 4;
- 44;
- 444
- }`);
-
- const criteria = ArrayValueObject.create(/*ts*/ `{
- 4;
- 4;
- 44;
- 444
- }`);
-
- const resultObject = testFunction.calculate(range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [1], [1], [1]]);
- });
+ const result = await calculate('=COUNTIF(A1:A4,D1:D4)');
+ expect(result).toStrictEqual([
+ [1],
+ [1],
+ [1],
+ [1],
+ ]);
+
+ const result2 = await calculate('=COUNTIF(A1:A4,E1:E4)');
+ expect(result2).toStrictEqual([
+ [0],
+ [1],
+ [1],
+ [1],
+ ]);
- it('ArrayValueObject range and ArrayValueObject criteria multi type cell', async () => {
- const range = ArrayValueObject.create({
- calculateValueList: transformToValueObject([
- [1, ' ', 1.23, true, false, null],
- [0, '100', '2.34', 'test', -3, ErrorType.NAME],
- ]),
- rowCount: 2,
- columnCount: 6,
- unitId: '',
- sheetId: '',
- row: 0,
- column: 0,
- });
-
- const criteria = ArrayValueObject.create({
- calculateValueList: transformToValueObject([
- ['>1', '> ', '>1.23', '>true', '>false', '>'],
- ['>0', '>100', '>2.34', '>test', '>-3', ErrorType.NAME],
- ]),
- rowCount: 2,
- columnCount: 6,
- unitId: '',
- sheetId: '',
- row: 0,
- column: 0,
- });
-
- const resultObject = testFunction.calculate(range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3, 1, 2, 0, 1, 0], [4, 0, 1, 0, 5, 1]]);
+ const result3 = await calculate('=COUNTIF(A1:A4,A2)');
+ expect(result3).toBe(1);
});
- it('ArrayValueObject range equals ArrayValueObject criteria multi types cell', async () => {
- const range = ArrayValueObject.create({
- calculateValueList: transformToValueObject([
- [1, ' ', 1.23, true, false, null],
- [0, '100', '2.34', 'test', -3, ErrorType.NAME],
- ]),
- rowCount: 2,
- columnCount: 6,
- unitId: '',
- sheetId: '',
- row: 0,
- column: 0,
- });
-
- const criteria = ArrayValueObject.create({
- calculateValueList: transformToValueObject([
- ['=1', '= ', '=1.23', '=true', '=false', '=0'],
- ['=0', '=100', '=2.34', '=test', '=-3', ErrorType.NAME],
- ]),
- rowCount: 2,
- columnCount: 6,
- unitId: '',
- sheetId: '',
- row: 0,
- column: 0,
- });
-
- const resultObject = testFunction.calculate(range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([
- [1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1],
- ]);
+ it('Includes error', async () => {
+ const error = ErrorValueObject.create(ErrorType.NAME);
+
+ const result = await calculate(`=COUNTIF(${error},A1:A4)`);
+ expect(result).toBe(ErrorType.VALUE);
+
+ const result2 = await calculate(`=COUNTIF(A1:A4,${error})`);
+ expect(result2).toBe(0);
});
});
});
diff --git a/packages/engine-formula/src/functions/statistical/countif/index.ts b/packages/engine-formula/src/functions/statistical/countif/index.ts
index b9809f478d..ba1a44dfd7 100644
--- a/packages/engine-formula/src/functions/statistical/countif/index.ts
+++ b/packages/engine-formula/src/functions/statistical/countif/index.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
@@ -28,29 +29,41 @@ export class Countif extends BaseFunction {
override maxParams = 2;
- override calculate(range: BaseValueObject, criteria: BaseValueObject) {
- if (range.isError() || criteria.isError()) {
- return ErrorValueObject.create(ErrorType.NA);
- }
+ override needsReferenceObject = true;
- if (!range.isArray()) {
+ override calculate(range: FunctionVariantType, criteria: FunctionVariantType): BaseValueObject {
+ if (!range.isReferenceObject()) {
return ErrorValueObject.create(ErrorType.VALUE);
}
- if (criteria.isArray()) {
- return criteria.mapValue((criteriaItem) => this._handleSingleObject(range, criteriaItem));
+ let _criteria = criteria;
+
+ if (criteria.isReferenceObject()) {
+ _criteria = (criteria as BaseReferenceObject).toArrayValueObject();
+ }
+
+ if (_criteria.isArray()) {
+ const resultArray = (_criteria as ArrayValueObject).mapValue((criteriaObject) => this._handleSingleObject(range, criteriaObject));
+
+ if ((resultArray as ArrayValueObject).getRowCount() === 1 && (resultArray as ArrayValueObject).getColumnCount() === 1) {
+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;
+ }
+
+ return resultArray;
}
- return this._handleSingleObject(range, criteria);
+ return this._handleSingleObject(range, _criteria as BaseValueObject);
}
- private _handleSingleObject(range: BaseValueObject, criteria: BaseValueObject) {
- let resultArrayObject = valueObjectCompare(range, criteria);
+ private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject): BaseValueObject {
+ const _range = (range as BaseReferenceObject).toArrayValueObject();
+
+ let resultArrayObject = valueObjectCompare(_range, criteria);
// If the condition is a numeric comparison, only numbers are counted, otherwise text is counted.
- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, range as ArrayValueObject, criteria);
+ resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, _range, criteria);
- const picked = (range as ArrayValueObject).pick(resultArrayObject as ArrayValueObject);
+ const picked = (_range as ArrayValueObject).pick(resultArrayObject as ArrayValueObject);
return this._countA(picked);
}
diff --git a/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts
index fa6667b6dc..4f2110dc09 100644
--- a/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts
@@ -14,227 +14,219 @@
* limitations under the License.
*/
-import { describe, expect, it } from 'vitest';
+import type { Injector, IWorkbookData } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { CellValueType, LocaleType } from '@univerjs/core';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { Lexer } from '../../../../engine/analysis/lexer';
+import { AstTreeBuilder } from '../../../../engine/analysis/parser';
+import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
+import { IFunctionService } from '../../../../services/function.service';
+import { IFormulaRuntimeService } from '../../../../services/runtime.service';
+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';
import { Countifs } from '../index';
-describe('Test countifs function', () => {
- const testFunction = new Countifs(FUNCTION_NAMES_STATISTICAL.COUNTIFS);
+const getTestWorkbookData = (): IWorkbookData => {
+ return {
+ id: 'test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ cellData: {
+ 0: {
+ 0: {
+ v: 1,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 1: {
+ 0: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 2: {
+ 0: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 3: {
+ 0: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 7,
+ t: CellValueType.NUMBER,
+ },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: [],
+ styles: {},
+ };
+};
- describe('Countifs', () => {
- it('Array criteria with number and string', async () => {
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4;
- test1;
- test12
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4;
- test*
- }`);
-
- const resultObject = testFunction.calculate(range1, criteria1);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [1], [0], [2]]);
+describe('Test countifs function', () => {
+ let get: Injector['get'];
+ let lexer: Lexer;
+ let astTreeBuilder: AstTreeBuilder;
+ let interpreter: Interpreter;
+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;
+
+ beforeEach(() => {
+ const testBed = createFunctionTestBed(getTestWorkbookData());
+
+ get = testBed.get;
+
+ lexer = get(Lexer);
+ astTreeBuilder = get(AstTreeBuilder);
+ interpreter = get(Interpreter);
+
+ const functionService = get(IFunctionService);
+
+ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);
+
+ const formulaRuntimeService = get(IFormulaRuntimeService);
+
+ formulaCurrentConfigService.load({
+ formulaData: {},
+ arrayFormulaCellData: {},
+ arrayFormulaRange: {},
+ forceCalculate: false,
+ dirtyRanges: [],
+ dirtyNameMap: {},
+ dirtyDefinedNameMap: {},
+ dirtyUnitFeatureMap: {},
+ dirtyUnitOtherFormulaMap: {},
+ excludedCell: {},
+ allUnitData: {
+ [testBed.unitId]: testBed.sheetData,
+ },
});
- it('Range and criteria, compare string', async () => {
- const range = ArrayValueObject.create(`{
- a;
- b;
- c
- }`);
+ const sheetItem = testBed.sheetData[testBed.sheetId];
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[0]]);
- });
+ formulaRuntimeService.setCurrent(
+ 0,
+ 0,
+ sheetItem.rowCount,
+ sheetItem.columnCount,
+ testBed.sheetId,
+ testBed.unitId
+ );
- it('Different ranges, error reporting', async () => {
- const range1 = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const criteria1 = StringValueObject.create('>2');
-
- const rang2 = ArrayValueObject.create(`{
- 2;
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = StringValueObject.create('>3');
- const resultObject = testFunction.calculate(range1, criteria1, rang2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[ErrorType.VALUE]]);
- });
+ functionService.registerExecutors(
+ new Countifs(FUNCTION_NAMES_STATISTICAL.COUNTIFS)
+ );
- it('Range and criteria, count number', async () => {
- const range = ArrayValueObject.create(`{
- 2;
- 3;
- 4;
- Univer
- }`);
-
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);
- });
+ calculate = (formula: string) => {
+ const lexerNode = lexer.treeBuilder(formula);
- it('Range and array criteria', async () => {
- const range = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria = ArrayValueObject.create(`{
- >2;
- >3;
- >4;
- >5
- }`);
-
- const resultObject = testFunction.calculate(range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [1], [0], [0]]);
- });
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- it('2 ranges and criteria', async () => {
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
- const criteria1 = StringValueObject.create('>2');
+ return getObjectValue(result);
+ };
+ });
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
+ describe('Countifs', () => {
+ it('Value is normal', async () => {
+ const result = await calculate('=COUNTIFS(A1:A4,">3")');
+ expect(result).toBe(1);
+ });
- const criteria2 = StringValueObject.create('<5');
+ it('Value is array', async () => {
+ const result = await calculate('=COUNTIFS({1;2;3;4},">3")');
+ expect(result).toBe(ErrorType.VALUE);
+ });
- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1]]);
+ it('Range and criteria is not paired', async () => {
+ const result = await calculate('=COUNTIFS(A1:A4,">3",C1:C4)');
+ expect(result).toBe(ErrorType.VALUE);
});
- it('2 ranges and criteria, 1 array criteria with number', async () => {
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = NumberValueObject.create(5);
-
- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [1], [0]]);
+ it('Range is different size', async () => {
+ const result = await calculate('=COUNTIFS(A1:A4,">3",C1:C3,{"=5","=6"})');
+ expect(result).toStrictEqual([
+ [ErrorType.VALUE, ErrorType.VALUE],
+ ]);
});
- it('2 ranges and criteria, 1 array criteria with string', async () => {
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- test1;
- test12;
- Univer123
- }`);
-
- const criteria2 = StringValueObject.create('test*');
-
- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [0], [0]]);
+ it('Range and array criteria', async () => {
+ const result = await calculate('=COUNTIFS(A1:A4,{">1";">2"})');
+ expect(result).toStrictEqual([
+ [3],
+ [2],
+ ]);
});
- it('2 ranges and criteria, 2 array criteria', async () => {
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = ArrayValueObject.create(`{
- 4;
- 4;
- 4;
- 4
- }`);
-
- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [0], [0], [0]]);
+ it('Two ranges and criteria', async () => {
+ const result = await calculate('=COUNTIFS(A1:A4,">2",C1:C4,"=5")');
+ expect(result).toBe(1);
});
- it('2 ranges and criteria, 2 array criteria, compare string', async () => {
- const range1 = ArrayValueObject.create(`{
- 1;
- 2;
- 3;
- 4;
- 5;
- 6
- }`);
-
- const criteria1 = StringValueObject.create('<5');
-
- const range2 = ArrayValueObject.create(`{
- 40664;
- 40665;
- 40666;
- 40667;
- 40668;
- 40669
- }`);
-
- const criteria2 = StringValueObject.create('<5/3/2011');
-
- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);
+ it('Two ranges and criteria, criteria is array', async () => {
+ const result = await calculate('=COUNTIFS(A1:A4,">2",C1:C4,{">4";">5"})');
+ expect(result).toStrictEqual([
+ [2],
+ [1],
+ ]);
});
});
});
diff --git a/packages/engine-formula/src/functions/statistical/countifs/index.ts b/packages/engine-formula/src/functions/statistical/countifs/index.ts
index a9981e35e5..0fbe9bc955 100644
--- a/packages/engine-formula/src/functions/statistical/countifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/countifs/index.ts
@@ -14,10 +14,12 @@
* limitations under the License.
*/
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';
+import { expandArrayValueObject } from '../../../engine/utils/array-object';
+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
@@ -27,48 +29,55 @@ export class Countifs extends BaseFunction {
override maxParams = 255;
- override calculate(...variants: BaseValueObject[]) {
- // Range and criteria must be paired
- if (variants.length % 2 !== 0) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
+ override needsReferenceObject = true;
- // Every range must be array
- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
+ override calculate(...variants: FunctionVariantType[]): BaseValueObject {
+ const {
+ isError,
+ errorObject,
+ rangeIsDifferentSize,
+ criteriaMaxRowLength,
+ criteriaMaxColumnLength,
+ variants: _variants,
+ } = parsePairedRangeAndCriteria(variants);
- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
- const errorArray = getErrorArray(variants, variants[0], maxRowLength, maxColumnLength);
+ if (rangeIsDifferentSize) {
+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
- if (errorArray) {
- return errorArray;
+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);
+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
return this._aggregateResults(booleanResults);
}
- private _aggregateResults(booleanResults: BaseValueObject[][]): ArrayValueObject {
- const maxResults = booleanResults.map((row) => {
+ private _aggregateResults(booleanResults: BaseValueObject[][]): BaseValueObject {
+ const results = booleanResults.map((row) => {
return row.map((booleanResult) => {
return countTrueValue(booleanResult as ArrayValueObject);
});
});
- const arrayValueObjectData: IArrayValueObject = {
- calculateValueList: maxResults,
- rowCount: maxResults.length,
- columnCount: maxResults[0].length,
+ if (results.length === 1 && results[0].length === 1) {
+ return results[0][0];
+ }
+
+ return ArrayValueObject.create({
+ calculateValueList: results,
+ rowCount: results.length,
+ columnCount: results[0].length,
unitId: this.unitId || '',
sheetId: this.subUnitId || '',
row: this.row,
column: this.column,
- };
-
- return ArrayValueObject.create(arrayValueObjectData);
+ });
}
}
diff --git a/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts
index 940d277ab7..209b91fe84 100644
--- a/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts
@@ -14,165 +14,219 @@
* limitations under the License.
*/
-import { describe, expect, it } from 'vitest';
+import type { Injector, IWorkbookData } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { CellValueType, LocaleType } from '@univerjs/core';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ErrorType } from '../../../../basics/error-type';
+import { Lexer } from '../../../../engine/analysis/lexer';
+import { AstTreeBuilder } from '../../../../engine/analysis/parser';
+import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
+import { IFunctionService } from '../../../../services/function.service';
+import { IFormulaRuntimeService } from '../../../../services/runtime.service';
+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';
import { Maxifs } from '../index';
-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
-describe('Test maxifs function', () => {
- const testFunction = new Maxifs(FUNCTION_NAMES_STATISTICAL.MAXIFS);
+const getTestWorkbookData = (): IWorkbookData => {
+ return {
+ id: 'test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ cellData: {
+ 0: {
+ 0: {
+ v: 1,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 1: {
+ 0: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 2: {
+ 0: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 3: {
+ 0: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 7,
+ t: CellValueType.NUMBER,
+ },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: [],
+ styles: {},
+ };
+};
- describe('Maxifs', () => {
- it('Range and criteria', async () => {
- const maxRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
- const range = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(maxRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3]]);
+describe('Test maxifs function', () => {
+ let get: Injector['get'];
+ let lexer: Lexer;
+ let astTreeBuilder: AstTreeBuilder;
+ let interpreter: Interpreter;
+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;
+
+ beforeEach(() => {
+ const testBed = createFunctionTestBed(getTestWorkbookData());
+
+ get = testBed.get;
+
+ lexer = get(Lexer);
+ astTreeBuilder = get(AstTreeBuilder);
+ interpreter = get(Interpreter);
+
+ const functionService = get(IFunctionService);
+
+ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);
+
+ const formulaRuntimeService = get(IFormulaRuntimeService);
+
+ formulaCurrentConfigService.load({
+ formulaData: {},
+ arrayFormulaCellData: {},
+ arrayFormulaRange: {},
+ forceCalculate: false,
+ dirtyRanges: [],
+ dirtyNameMap: {},
+ dirtyDefinedNameMap: {},
+ dirtyUnitFeatureMap: {},
+ dirtyUnitOtherFormulaMap: {},
+ excludedCell: {},
+ allUnitData: {
+ [testBed.unitId]: testBed.sheetData,
+ },
});
- it('Range and criteria, compare string', async () => {
- const maxRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
- const range = ArrayValueObject.create(`{
- a;
- b;
- c
- }`);
-
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(maxRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[0]]);
- });
+ const sheetItem = testBed.sheetData[testBed.sheetId];
- it('Range and array criteria', async () => {
- const maxRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const resultObject = testFunction.calculate(maxRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3], [3], [0]]);
- });
+ formulaRuntimeService.setCurrent(
+ 0,
+ 0,
+ sheetItem.rowCount,
+ sheetItem.columnCount,
+ testBed.sheetId,
+ testBed.unitId
+ );
- it('2 ranges and criteria', async () => {
- const maxRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
+ functionService.registerExecutors(
+ new Maxifs(FUNCTION_NAMES_STATISTICAL.MAXIFS)
+ );
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
+ calculate = (formula: string) => {
+ const lexerNode = lexer.treeBuilder(formula);
- const criteria1 = StringValueObject.create('>2');
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
- const criteria2 = StringValueObject.create('<5');
+ return getObjectValue(result);
+ };
+ });
- const resultObject = testFunction.calculate(maxRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);
+ describe('Maxifs', () => {
+ it('Value is normal', async () => {
+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">3")');
+ expect(result).toBe(4);
+ });
+
+ it('Value is array', async () => {
+ const result = await calculate('=MAXIFS({1;2;3;4},B1:B4,">3")');
+ expect(result).toBe(ErrorType.VALUE);
+ });
+
+ it('Range and criteria is not paired', async () => {
+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">3",C1:C4)');
+ expect(result).toBe(ErrorType.VALUE);
+ });
+
+ it('Range is different size', async () => {
+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">3",C1:C3,{"=5","=6"})');
+ expect(result).toStrictEqual([
+ [ErrorType.VALUE, ErrorType.VALUE],
+ ]);
+ });
+
+ it('Range and array criteria', async () => {
+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,{">1";">2"})');
+ expect(result).toStrictEqual([
+ [4],
+ [4],
+ ]);
});
- it('2 ranges and criteria, 1 array criteria', async () => {
- const maxRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = NumberValueObject.create(5);
-
- const resultObject = testFunction.calculate(maxRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3], [3], [0]]);
+ it('Two ranges and criteria', async () => {
+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">2",C1:C4,"=5")');
+ expect(result).toBe(3);
});
- it('2 ranges and criteria, 2 array criteria', async () => {
- const maxRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = ArrayValueObject.create(`{
- 4;
- 4;
- 4;
- 4
- }`);
-
- const resultObject = testFunction.calculate(maxRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [0], [0], [0]]);
+ it('Two ranges and criteria, criteria is array', async () => {
+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">2",C1:C4,{">4";">5"})');
+ expect(result).toStrictEqual([
+ [4],
+ [4],
+ ]);
});
});
});
diff --git a/packages/engine-formula/src/functions/statistical/maxifs/index.ts b/packages/engine-formula/src/functions/statistical/maxifs/index.ts
index c8b7dbf301..0cb9565193 100644
--- a/packages/engine-formula/src/functions/statistical/maxifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/maxifs/index.ts
@@ -14,9 +14,11 @@
* limitations under the License.
*/
-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';
+import { expandArrayValueObject } from '../../../engine/utils/array-object';
+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
@@ -26,40 +28,38 @@ export class Maxifs extends BaseFunction {
override maxParams = 255;
- override calculate(maxRange: BaseValueObject, ...variants: BaseValueObject[]) {
- if (maxRange.isError()) {
- return ErrorValueObject.create(ErrorType.NA);
+ override needsReferenceObject = true;
+
+ override calculate(maxRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject {
+ const {
+ isError,
+ errorObject,
+ rangeIsDifferentSize,
+ criteriaMaxRowLength,
+ criteriaMaxColumnLength,
+ targetRange: _maxRange,
+ variants: _variants,
+ } = parsePairedRangeAndCriteria(variants, maxRange);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
}
- if (!maxRange.isArray()) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
-
- // Range and criteria must be paired
- if (variants.length % 2 !== 0) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
+ if (rangeIsDifferentSize) {
+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
- // Every range must be array
- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);
-
- const errorArray = getErrorArray(variants, maxRange, maxRowLength, maxColumnLength);
-
- if (errorArray) {
- return errorArray;
- }
+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);
-
- return this._aggregateResults(maxRange, booleanResults);
+ return this._aggregateResults(_maxRange as BaseValueObject, booleanResults);
}
- private _aggregateResults(maxRange: BaseValueObject, booleanResults: BaseValueObject[][]): ArrayValueObject {
- const maxResults = booleanResults.map((row) => {
+ private _aggregateResults(maxRange: BaseValueObject, booleanResults: BaseValueObject[][]): BaseValueObject {
+ const results = booleanResults.map((row) => {
return row.map((booleanResult) => {
const picked = (maxRange as ArrayValueObject).pick(booleanResult as ArrayValueObject);
if (picked.getColumnCount() === 0) {
@@ -70,16 +70,18 @@ export class Maxifs extends BaseFunction {
});
});
- const arrayValueObjectData: IArrayValueObject = {
- calculateValueList: maxResults,
- rowCount: maxResults.length,
- columnCount: maxResults[0].length,
+ if (results.length === 1 && results[0].length === 1) {
+ return results[0][0];
+ }
+
+ return ArrayValueObject.create({
+ calculateValueList: results,
+ rowCount: results.length,
+ columnCount: results[0].length,
unitId: this.unitId || '',
sheetId: this.subUnitId || '',
row: this.row,
column: this.column,
- };
-
- return ArrayValueObject.create(arrayValueObjectData);
+ });
}
}
diff --git a/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts
index b836187d6d..4d28bbca9c 100644
--- a/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts
@@ -14,165 +14,219 @@
* limitations under the License.
*/
-import { describe, expect, it } from 'vitest';
+import type { Injector, IWorkbookData } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { CellValueType, LocaleType } from '@univerjs/core';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ErrorType } from '../../../../basics/error-type';
+import { Lexer } from '../../../../engine/analysis/lexer';
+import { AstTreeBuilder } from '../../../../engine/analysis/parser';
+import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
+import { IFunctionService } from '../../../../services/function.service';
+import { IFormulaRuntimeService } from '../../../../services/runtime.service';
+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';
import { Minifs } from '../index';
-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
-describe('Test minifs function', () => {
- const testFunction = new Minifs(FUNCTION_NAMES_STATISTICAL.MINIFS);
+const getTestWorkbookData = (): IWorkbookData => {
+ return {
+ id: 'test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ cellData: {
+ 0: {
+ 0: {
+ v: 1,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 1: {
+ 0: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 2: {
+ 0: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 3: {
+ 0: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 1: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 2: {
+ v: 6,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 7,
+ t: CellValueType.NUMBER,
+ },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: [],
+ styles: {},
+ };
+};
- describe('Minifs', () => {
- it('Range and criteria', async () => {
- const minRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
- const range = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(minRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);
+describe('Test minifs function', () => {
+ let get: Injector['get'];
+ let lexer: Lexer;
+ let astTreeBuilder: AstTreeBuilder;
+ let interpreter: Interpreter;
+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;
+
+ beforeEach(() => {
+ const testBed = createFunctionTestBed(getTestWorkbookData());
+
+ get = testBed.get;
+
+ lexer = get(Lexer);
+ astTreeBuilder = get(AstTreeBuilder);
+ interpreter = get(Interpreter);
+
+ const functionService = get(IFunctionService);
+
+ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);
+
+ const formulaRuntimeService = get(IFormulaRuntimeService);
+
+ formulaCurrentConfigService.load({
+ formulaData: {},
+ arrayFormulaCellData: {},
+ arrayFormulaRange: {},
+ forceCalculate: false,
+ dirtyRanges: [],
+ dirtyNameMap: {},
+ dirtyDefinedNameMap: {},
+ dirtyUnitFeatureMap: {},
+ dirtyUnitOtherFormulaMap: {},
+ excludedCell: {},
+ allUnitData: {
+ [testBed.unitId]: testBed.sheetData,
+ },
});
- it('Range and criteria, compare string', async () => {
- const minRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
- const range = ArrayValueObject.create(`{
- a;
- b;
- c
- }`);
-
- const criteria = StringValueObject.create('>2');
- const resultObject = testFunction.calculate(minRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[0]]);
- });
+ const sheetItem = testBed.sheetData[testBed.sheetId];
- it('Range and array criteria', async () => {
- const minRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const resultObject = testFunction.calculate(minRange, range, criteria);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [3], [0]]);
- });
+ formulaRuntimeService.setCurrent(
+ 0,
+ 0,
+ sheetItem.rowCount,
+ sheetItem.columnCount,
+ testBed.sheetId,
+ testBed.unitId
+ );
- it('2 ranges and criteria', async () => {
- const minRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
+ functionService.registerExecutors(
+ new Minifs(FUNCTION_NAMES_STATISTICAL.MINIFS)
+ );
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
+ calculate = (formula: string) => {
+ const lexerNode = lexer.treeBuilder(formula);
- const criteria1 = StringValueObject.create('>2');
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
- const criteria2 = StringValueObject.create('<5');
+ return getObjectValue(result);
+ };
+ });
- const resultObject = testFunction.calculate(minRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);
+ describe('Minifs', () => {
+ it('Value is normal', async () => {
+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">3")');
+ expect(result).toBe(3);
+ });
+
+ it('Value is array', async () => {
+ const result = await calculate('=MINIFS({1;2;3;4},B1:B4,">3")');
+ expect(result).toBe(ErrorType.VALUE);
+ });
+
+ it('Range and criteria is not paired', async () => {
+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">3",C1:C4)');
+ expect(result).toBe(ErrorType.VALUE);
+ });
+
+ it('Range is different size', async () => {
+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">3",C1:C3,{"=5","=6"})');
+ expect(result).toStrictEqual([
+ [ErrorType.VALUE, ErrorType.VALUE],
+ ]);
+ });
+
+ it('Range and array criteria', async () => {
+ const result = await calculate('=MINIFS(A1:A4,B1:B4,{">1";">2"})');
+ expect(result).toStrictEqual([
+ [1],
+ [2],
+ ]);
});
- it('2 ranges and criteria, 1 array criteria', async () => {
- const minRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = NumberValueObject.create(5);
-
- const resultObject = testFunction.calculate(minRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3], [3], [0]]);
+ it('Two ranges and criteria', async () => {
+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">2",C1:C4,"=5")');
+ expect(result).toBe(3);
});
- it('2 ranges and criteria, 2 array criteria', async () => {
- const minRange = ArrayValueObject.create(`{
- 1;
- 2;
- 3
- }`);
-
- const range1 = ArrayValueObject.create(`{
- 2;
- 3;
- 4
- }`);
-
- const criteria1 = ArrayValueObject.create(`{
- >2;
- >3;
- >4
- }`);
-
- const range2 = ArrayValueObject.create(`{
- 3;
- 4;
- 5
- }`);
-
- const criteria2 = ArrayValueObject.create(`{
- 4;
- 4;
- 4;
- 4
- }`);
-
- const resultObject = testFunction.calculate(minRange, range1, criteria1, range2, criteria2);
- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [0], [0], [0]]);
+ it('Two ranges and criteria, criteria is array', async () => {
+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">2",C1:C4,{">4";">5"})');
+ expect(result).toStrictEqual([
+ [3],
+ [4],
+ ]);
});
});
});
diff --git a/packages/engine-formula/src/functions/statistical/minifs/index.ts b/packages/engine-formula/src/functions/statistical/minifs/index.ts
index 218e08cc03..15206554d0 100644
--- a/packages/engine-formula/src/functions/statistical/minifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/minifs/index.ts
@@ -14,10 +14,12 @@
* limitations under the License.
*/
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';
+import { expandArrayValueObject } from '../../../engine/utils/array-object';
+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
@@ -26,40 +28,38 @@ export class Minifs extends BaseFunction {
override maxParams = 255;
- override calculate(minRange: BaseValueObject, ...variants: BaseValueObject[]) {
- if (minRange.isError()) {
- return ErrorValueObject.create(ErrorType.NA);
+ override needsReferenceObject = true;
+
+ override calculate(minRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject {
+ const {
+ isError,
+ errorObject,
+ rangeIsDifferentSize,
+ criteriaMaxRowLength,
+ criteriaMaxColumnLength,
+ targetRange: _minRange,
+ variants: _variants,
+ } = parsePairedRangeAndCriteria(variants, minRange);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
}
- if (!minRange.isArray()) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
-
- // Range and criteria must be paired
- if (variants.length % 2 !== 0) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
+ if (rangeIsDifferentSize) {
+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
- // Every range must be array
- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);
-
- const errorArray = getErrorArray(variants, minRange, maxRowLength, maxColumnLength);
-
- if (errorArray) {
- return errorArray;
- }
+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);
-
- return this._aggregateResults(minRange, booleanResults);
+ return this._aggregateResults(_minRange as BaseValueObject, booleanResults);
}
- private _aggregateResults(minRange: BaseValueObject, booleanResults: BaseValueObject[][]): ArrayValueObject {
- const maxResults = booleanResults.map((row) => {
+ private _aggregateResults(minRange: BaseValueObject, booleanResults: BaseValueObject[][]): BaseValueObject {
+ const results = booleanResults.map((row) => {
return row.map((booleanResult) => {
const picked = (minRange as ArrayValueObject).pick(booleanResult as ArrayValueObject);
if (picked.getColumnCount() === 0) {
@@ -70,16 +70,18 @@ export class Minifs extends BaseFunction {
});
});
- const arrayValueObjectData: IArrayValueObject = {
- calculateValueList: maxResults,
- rowCount: maxResults.length,
- columnCount: maxResults[0].length,
+ if (results.length === 1 && results[0].length === 1) {
+ return results[0][0];
+ }
+
+ return ArrayValueObject.create({
+ calculateValueList: results,
+ rowCount: results.length,
+ columnCount: results[0].length,
unitId: this.unitId || '',
sheetId: this.subUnitId || '',
row: this.row,
column: this.column,
- };
-
- return ArrayValueObject.create(arrayValueObjectData);
+ });
}
}