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 where formulas like COUNTIFS would cause memory overflow when the range and condition values ​​were very large (#6647)

wpxp1234569ca7e2e92986
diff --git a/packages/engine-formula/src/engine/utils/object-compare.ts b/packages/engine-formula/src/engine/utils/object-compare.ts
index f936e6763d..fdee3ba4a8 100644
--- a/packages/engine-formula/src/engine/utils/object-compare.ts
+++ b/packages/engine-formula/src/engine/utils/object-compare.ts
@@ -14,10 +14,10 @@
* limitations under the License.
*/
-import { compareToken } from '../../basics/token';
import type { ArrayValueObject } from '../value-object/array-value-object';
-import { ValueObjectFactory } from '../value-object/array-value-object';
import type { BaseValueObject } from '../value-object/base-value-object';
+import { compareToken } from '../../basics/token';
+import { ValueObjectFactory } from '../value-object/array-value-object';
import { BooleanValueObject, createBooleanValueObjectByRawValue } from '../value-object/primitive-object';
import { expandArrayValueObject } from './array-object';
@@ -66,15 +66,23 @@ export function valueObjectCompare(range: BaseValueObject, criteria: BaseValueOb
/**
* Find the Boolean intersection of two ArrayValueObjects
- * @param valueObject1
- * @param valueObject2
*/
-export function booleanObjectIntersection(valueObject1: BaseValueObject, valueObject2: BaseValueObject) {
- const maxRowLength = Math.max(valueObject1.isArray() ? (valueObject1 as ArrayValueObject).getRowCount() : 1, valueObject2.isArray() ? (valueObject2 as ArrayValueObject).getRowCount() : 1);
- const maxColumnLength = Math.max(valueObject1.isArray() ? (valueObject1 as ArrayValueObject).getColumnCount() : 1, valueObject2.isArray() ? (valueObject2 as ArrayValueObject).getColumnCount() : 1);
+export function booleanObjectIntersection(valueObject1: ArrayValueObject, valueObject2: ArrayValueObject): ArrayValueObject {
+ const valueObject1RowCount = valueObject1.getRowCount();
+ const valueObject1ColumnCount = valueObject1.getColumnCount();
+ const valueObject2RowCount = valueObject2.getRowCount();
+ const valueObject2ColumnCount = valueObject2.getColumnCount();
- const valueObject1Array = expandArrayValueObject(maxRowLength, maxColumnLength, valueObject1);
- const valueObject2Array = expandArrayValueObject(maxRowLength, maxColumnLength, valueObject2);
+ let valueObject1Array = valueObject1;
+ let valueObject2Array = valueObject2;
+
+ if (valueObject1RowCount !== valueObject2RowCount || valueObject1ColumnCount !== valueObject2ColumnCount) {
+ const maxRowLength = Math.max(valueObject1RowCount, valueObject2RowCount);
+ const maxColumnLength = Math.max(valueObject1ColumnCount, valueObject2ColumnCount);
+
+ valueObject1Array = expandArrayValueObject(maxRowLength, maxColumnLength, valueObject1);
+ valueObject2Array = expandArrayValueObject(maxRowLength, maxColumnLength, valueObject2);
+ }
return valueObject1Array.mapValue((valueObject1, rowIndex, columnIndex) => {
const valueObject2 = valueObject2Array.get(rowIndex, columnIndex);
diff --git a/packages/engine-formula/src/engine/utils/value-object.ts b/packages/engine-formula/src/engine/utils/value-object.ts
index 144c898c5e..1582393c6d 100644
--- a/packages/engine-formula/src/engine/utils/value-object.ts
+++ b/packages/engine-formula/src/engine/utils/value-object.ts
@@ -188,11 +188,11 @@ export function parsePairedRangeAndCriteria(
targetRange?: FunctionVariantType
): {
isError: boolean;
- errorObject: Nullable<ErrorValueObject>;
+ errorObject: ErrorValueObject | null;
rangeIsDifferentSize: boolean;
criteriaMaxRowLength: number;
criteriaMaxColumnLength: number;
- targetRange: Nullable<BaseValueObject>;
+ targetRange: ArrayValueObject | null;
variants: BaseValueObject[];
} {
/**
@@ -211,7 +211,7 @@ export function parsePairedRangeAndCriteria(
};
}
- let _targetRange: Nullable<BaseValueObject> = null;
+ let _targetRange: ArrayValueObject | null = null;
let targetRangeRowCount = -1;
let targetRangeColumnCount = -1;
@@ -310,53 +310,125 @@ export function baseValueObjectToArrayValueObject(valueObject: BaseValueObject):
return ArrayValueObject.createByArray([[valueObject.getValue()]]);
}
-export function getBooleanResults(variants: BaseValueObject[], maxRowLength: number, maxColumnLength: number, isNumberSensitive: boolean = false) {
- const booleanResults: BaseValueObject[][] = [];
+/**
+ * Get the paired range and criteria result for COUNTIFS, SUMIFS, etc.
+ */
+// eslint-disable-next-line max-lines-per-function
+export function getPairedRangeAndCriteriaResult(
+ variants: BaseValueObject[],
+ params: {
+ formulaName: string;
+ maxRowLength: number;
+ maxColumnLength: number;
+ isNumberSensitive?: boolean;
+ targetRange?: ArrayValueObject;
+ }
+) {
+ const { formulaName, maxRowLength, maxColumnLength, isNumberSensitive = false, targetRange } = params;
+
+ // Align all criteria values to the same dimension as the maximum criteria range.
+ const rangeAndCriteriaArrays: Array<{
+ range: ArrayValueObject;
+ criteriaArray: ArrayValueObject;
+ }> = [];
for (let i = 0; i < variants.length; i++) {
if (i % 2 === 1) continue;
- const range = variants[i];
+ const range = variants[i] as ArrayValueObject;
const criteria = variants[i + 1];
const criteriaArray = expandArrayValueObject(maxRowLength, maxColumnLength, criteria, ErrorValueObject.create(ErrorType.NA));
- criteriaArray.iterator((criteriaValueObject, rowIndex, columnIndex) => {
+ rangeAndCriteriaArrays.push({
+ range,
+ criteriaArray,
+ });
+ }
+
+ if (rangeAndCriteriaArrays.length === 0) return [];
+
+ const results: BaseValueObject[][] = [];
+
+ /**
+ * Iterate through all criteria values for each dimension, calculate the comparison result with the corresponding range, and then calculate the Boolean intersection of all comparison results as the final result for that dimension criteria value.
+ * Then calculate this dimension criteria value's result.
+ * This avoiding store the all dimension comparison result in memory and then calculating all dimension criteria value's result, which may cause memory overflow when the range is large and there are multiple dimension criteria.
+ * For example, `=COUNTIFS(Q$3:Q$10002,C$3:C$5002,R$3:R$10002,L6)`.
+ */
+ rangeAndCriteriaArrays[0].criteriaArray.iterator((_, rowIndex, columnIndex) => {
+ let finalCompareResult: ArrayValueObject | undefined;
+
+ for (let i = 0; i < rangeAndCriteriaArrays.length; i++) {
+ const { range, criteriaArray } = rangeAndCriteriaArrays[i];
+ const criteriaValueObject = criteriaArray.get(rowIndex, columnIndex);
+
if (!criteriaValueObject) {
- return;
+ continue;
}
// range must be an ArrayValueObject, criteria must be a BaseValueObject
- let resultArrayObject = valueObjectCompare(range, criteriaValueObject);
+ let compareResult = valueObjectCompare(range, criteriaValueObject) as ArrayValueObject;
// When comparing non-numbers and numbers, countifs does not take the result
if (isNumberSensitive) {
- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, range as ArrayValueObject, criteriaValueObject);
+ compareResult = filterSameValueObjectResult(compareResult, range, criteriaValueObject);
}
- if (booleanResults[rowIndex] === undefined) {
- booleanResults[rowIndex] = [];
+ if (finalCompareResult === undefined) {
+ finalCompareResult = compareResult;
+ continue;
}
- if (booleanResults[rowIndex][columnIndex] === undefined) {
- booleanResults[rowIndex][columnIndex] = resultArrayObject;
- return;
+ finalCompareResult = booleanObjectIntersection(finalCompareResult, compareResult);
+ }
+
+ let result: BaseValueObject | undefined;
+
+ if (formulaName === 'COUNTIFS') {
+ let count = 0;
+ (finalCompareResult as ArrayValueObject).iterator((value) => {
+ if (value?.isBoolean() && value.getValue() === true) {
+ count++;
+ }
+ });
+ result = NumberValueObject.create(count);
+ } else if (formulaName === 'SUMIFS') {
+ result = targetRange!.pick(finalCompareResult as ArrayValueObject).sum();
+ } else if (formulaName === 'AVERAGEIFS') {
+ const picked = targetRange!.pick(finalCompareResult as ArrayValueObject);
+ const sum = picked.sum();
+ const count = picked.count();
+ result = sum.divided(count);
+ } else if (formulaName === 'MAXIFS') {
+ const picked = targetRange!.pick(finalCompareResult as ArrayValueObject);
+ if (picked.getColumnCount() === 0) {
+ result = ArrayValueObject.create('0');
+ } else {
+ result = picked.max();
+ }
+ } else if (formulaName === 'MINIFS') {
+ const picked = targetRange!.pick(finalCompareResult as ArrayValueObject);
+ if (picked.getColumnCount() === 0) {
+ result = ArrayValueObject.create('0');
+ } else {
+ result = picked.min();
}
+ }
- booleanResults[rowIndex][columnIndex] = booleanObjectIntersection(booleanResults[rowIndex][columnIndex], resultArrayObject);
- });
- }
+ if (!results[rowIndex]) {
+ results[rowIndex] = [];
+ }
- return booleanResults;
+ results[rowIndex][columnIndex] = result as BaseValueObject;
+ });
+
+ return results;
}
/**
- * Two valueObjects of the same type can be compared
- * @param array
- * @param range
- * @param criteria
- * @returns
+ * Two ArrayValueObject of the same type can be compared
*/
-export function filterSameValueObjectResult(array: ArrayValueObject, range: ArrayValueObject, criteria: BaseValueObject) {
+export function filterSameValueObjectResult(array: ArrayValueObject, range: ArrayValueObject, criteria: BaseValueObject): ArrayValueObject {
const [operator, criteriaObject] = findCompareToken(`${criteria.getValue()}`);
return array.mapValue((valueObject, r, c) => {
diff --git a/packages/engine-formula/src/engine/value-object/array-value-object.ts b/packages/engine-formula/src/engine/value-object/array-value-object.ts
index a66454d41b..381b945deb 100644
--- a/packages/engine-formula/src/engine/value-object/array-value-object.ts
+++ b/packages/engine-formula/src/engine/value-object/array-value-object.ts
@@ -950,23 +950,23 @@ export class ArrayValueObject extends BaseValueObject {
// return NumberValueObject.create(1).divided(this);
}
- override plus(valueObject: BaseValueObject): BaseValueObject {
+ override plus(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.PLUS);
}
- override minus(valueObject: BaseValueObject): BaseValueObject {
+ override minus(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.MINUS);
}
- override multiply(valueObject: BaseValueObject): BaseValueObject {
+ override multiply(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.MULTIPLY);
}
- override divided(valueObject: BaseValueObject): BaseValueObject {
+ override divided(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.DIVIDED);
}
- override mod(valueObject: BaseValueObject): BaseValueObject {
+ override mod(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.MOD);
}
@@ -979,15 +979,15 @@ export class ArrayValueObject extends BaseValueObject {
});
}
- override compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): BaseValueObject {
+ override compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.COMPARE, operator, isCaseSensitive);
}
- override concatenateFront(valueObject: BaseValueObject): BaseValueObject {
+ override concatenateFront(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.CONCATENATE_FRONT);
}
- override concatenateBack(valueObject: BaseValueObject): BaseValueObject {
+ override concatenateBack(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.CONCATENATE_BACK);
}
@@ -1006,7 +1006,7 @@ export class ArrayValueObject extends BaseValueObject {
return this.mapValue(wrappedCallbackFn);
}
- override mapValue(callbackFn: callbackMapFnType): BaseValueObject {
+ override mapValue(callbackFn: callbackMapFnType): ArrayValueObject {
const rowCount = this._rowCount;
const columnCount = this._columnCount;
@@ -1035,7 +1035,7 @@ export class ArrayValueObject extends BaseValueObject {
return this._createNewArray(result, rowCount, columnCount);
}
- override pow(valueObject: BaseValueObject): BaseValueObject {
+ override pow(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.POW);
}
@@ -1179,7 +1179,7 @@ export class ArrayValueObject extends BaseValueObject {
});
}
- override atan2(valueObject: BaseValueObject): BaseValueObject {
+ override atan2(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.ATAN2);
}
@@ -1336,7 +1336,7 @@ export class ArrayValueObject extends BaseValueObject {
});
}
- override round(valueObject: BaseValueObject): BaseValueObject {
+ override round(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.ROUND);
}
@@ -1349,7 +1349,7 @@ export class ArrayValueObject extends BaseValueObject {
});
}
- override floor(valueObject: BaseValueObject): BaseValueObject {
+ override floor(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.FLOOR);
}
@@ -1362,7 +1362,7 @@ export class ArrayValueObject extends BaseValueObject {
});
}
- override ceil(valueObject: BaseValueObject): BaseValueObject {
+ override ceil(valueObject: BaseValueObject): ArrayValueObject {
return this._batchOperator(valueObject, BatchOperatorType.CEIL);
}
@@ -1440,7 +1440,7 @@ export class ArrayValueObject extends BaseValueObject {
batchOperatorType: BatchOperatorType,
operator?: compareToken,
isCaseSensitive?: boolean
- ): BaseValueObject {
+ ): ArrayValueObject {
const valueList: BaseValueObject[] = [];
let rowCount = this._rowCount;
@@ -1755,7 +1755,7 @@ export class ArrayValueObject extends BaseValueObject {
batchOperatorType: BatchOperatorType,
operator?: compareToken,
isCaseSensitive?: boolean
- ) {
+ ): ArrayValueObject {
let rowCount = (valueObject as ArrayValueObject).getRowCount();
let columnCount = (valueObject as ArrayValueObject).getColumnCount();
@@ -1970,7 +1970,9 @@ export class ValueObjectFactory {
if (rawValueUpper === BooleanValue.TRUE || rawValueUpper === BooleanValue.FALSE) {
return createBooleanValueObjectByRawValue(rawValue);
}
- if (isRealNum(rawValue)) {
+
+ // "000123456" should be treated as string, not number, but "123456" should be treated as number
+ if (isRealNum(rawValue) && Number(rawValue).toString() === rawValue.trim()) {
return NumberValueObject.create(Number(rawValue));
}
diff --git a/packages/engine-formula/src/functions/math/sumif/index.ts b/packages/engine-formula/src/functions/math/sumif/index.ts
index fb6da9bec0..dcb085334d 100644
--- a/packages/engine-formula/src/functions/math/sumif/index.ts
+++ b/packages/engine-formula/src/functions/math/sumif/index.ts
@@ -57,10 +57,10 @@ export class Sumif extends BaseFunction {
private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject, sumRange?: FunctionVariantType): BaseValueObject {
const _range = (range as BaseReferenceObject).toArrayValueObject();
- let resultArrayObject = valueObjectCompare(_range, criteria);
+ let resultArrayObject = valueObjectCompare(_range, criteria) as ArrayValueObject;
// When comparing non-numbers and numbers, it does not take the result
- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, _range, criteria);
+ resultArrayObject = filterSameValueObjectResult(resultArrayObject, _range, criteria);
const rangeRowCount = _range.getRowCount();
const rangeColumnCount = _range.getColumnCount();
@@ -87,6 +87,6 @@ export class Sumif extends BaseFunction {
}
}
- return _sumRange.pick(resultArrayObject as ArrayValueObject).sum();
+ return _sumRange.pick(resultArrayObject).sum();
}
}
diff --git a/packages/engine-formula/src/functions/math/sumifs/index.ts b/packages/engine-formula/src/functions/math/sumifs/index.ts
index 4f7ec8ee5d..3f9fb00439 100644
--- a/packages/engine-formula/src/functions/math/sumifs/index.ts
+++ b/packages/engine-formula/src/functions/math/sumifs/index.ts
@@ -15,10 +15,9 @@
*/
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 { expandArrayValueObject } from '../../../engine/utils/array-object';
-import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
+import { getPairedRangeAndCriteriaResult, 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';
@@ -53,16 +52,12 @@ export class Sumifs extends BaseFunction {
return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
-
- return this._aggregateResults(_sumRange as BaseValueObject, booleanResults);
- }
-
- 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 results = getPairedRangeAndCriteriaResult(_variants, {
+ formulaName: 'SUMIFS',
+ maxRowLength: criteriaMaxRowLength,
+ maxColumnLength: criteriaMaxColumnLength,
+ isNumberSensitive: true,
+ targetRange: _sumRange as ArrayValueObject,
});
if (results.length === 1 && results[0].length === 1) {
diff --git a/packages/engine-formula/src/functions/statistical/averageif/index.ts b/packages/engine-formula/src/functions/statistical/averageif/index.ts
index 274c63ccd9..59ffa2d9b3 100644
--- a/packages/engine-formula/src/functions/statistical/averageif/index.ts
+++ b/packages/engine-formula/src/functions/statistical/averageif/index.ts
@@ -57,10 +57,10 @@ export class Averageif extends BaseFunction {
private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject, averageRange?: FunctionVariantType): BaseValueObject {
const _range = (range as BaseReferenceObject).toArrayValueObject();
- let resultArrayObject = valueObjectCompare(_range, criteria);
+ let resultArrayObject = valueObjectCompare(_range, criteria) as ArrayValueObject;
// When comparing non-numbers and numbers, it does not take the result
- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, _range, criteria);
+ resultArrayObject = filterSameValueObjectResult(resultArrayObject, _range, criteria);
const rangeRowCount = _range.getRowCount();
const rangeColumnCount = _range.getColumnCount();
@@ -87,7 +87,7 @@ export class Averageif extends BaseFunction {
}
}
- const picked = _averageRange.pick(resultArrayObject as ArrayValueObject);
+ const picked = _averageRange.pick(resultArrayObject);
const sum = picked.sum();
const count = picked.count();
return sum.divided(count);
diff --git a/packages/engine-formula/src/functions/statistical/averageifs/index.ts b/packages/engine-formula/src/functions/statistical/averageifs/index.ts
index e78caed5dc..a7419643c6 100644
--- a/packages/engine-formula/src/functions/statistical/averageifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/averageifs/index.ts
@@ -18,7 +18,7 @@ import type { FunctionVariantType } from '../../../engine/reference-object/base-
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
import { expandArrayValueObject } from '../../../engine/utils/array-object';
-import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
+import { getPairedRangeAndCriteriaResult, 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';
@@ -53,19 +53,12 @@ export class Averageifs extends BaseFunction {
return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
-
- return this._aggregateResults(_averageRange as BaseValueObject, booleanResults);
- }
-
- 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();
- const count = picked.count();
- return sum.divided(count);
- });
+ const results = getPairedRangeAndCriteriaResult(_variants, {
+ formulaName: 'AVERAGEIFS',
+ maxRowLength: criteriaMaxRowLength,
+ maxColumnLength: criteriaMaxColumnLength,
+ isNumberSensitive: true,
+ targetRange: _averageRange as ArrayValueObject,
});
if (results.length === 1 && results[0].length === 1) {
diff --git a/packages/engine-formula/src/functions/statistical/countif/index.ts b/packages/engine-formula/src/functions/statistical/countif/index.ts
index ba1a44dfd7..b6d44e05f0 100644
--- a/packages/engine-formula/src/functions/statistical/countif/index.ts
+++ b/packages/engine-formula/src/functions/statistical/countif/index.ts
@@ -58,12 +58,12 @@ export class Countif extends BaseFunction {
private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject): BaseValueObject {
const _range = (range as BaseReferenceObject).toArrayValueObject();
- let resultArrayObject = valueObjectCompare(_range, criteria);
+ let resultArrayObject = valueObjectCompare(_range, criteria) as ArrayValueObject;
// If the condition is a numeric comparison, only numbers are counted, otherwise text is counted.
- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, _range, criteria);
+ resultArrayObject = filterSameValueObjectResult(resultArrayObject, _range, criteria);
- const picked = (_range as ArrayValueObject).pick(resultArrayObject as ArrayValueObject);
+ const picked = _range.pick(resultArrayObject);
return this._countA(picked);
}
diff --git a/packages/engine-formula/src/functions/statistical/countifs/index.ts b/packages/engine-formula/src/functions/statistical/countifs/index.ts
index 0fbe9bc955..4a55f8160a 100644
--- a/packages/engine-formula/src/functions/statistical/countifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/countifs/index.ts
@@ -18,10 +18,9 @@ import type { FunctionVariantType } from '../../../engine/reference-object/base-
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
import { expandArrayValueObject } from '../../../engine/utils/array-object';
-import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
+import { getPairedRangeAndCriteriaResult, 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 { NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
export class Countifs extends BaseFunction {
@@ -53,16 +52,11 @@ export class Countifs extends BaseFunction {
return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
-
- return this._aggregateResults(booleanResults);
- }
-
- private _aggregateResults(booleanResults: BaseValueObject[][]): BaseValueObject {
- const results = booleanResults.map((row) => {
- return row.map((booleanResult) => {
- return countTrueValue(booleanResult as ArrayValueObject);
- });
+ const results = getPairedRangeAndCriteriaResult(_variants, {
+ formulaName: 'COUNTIFS',
+ maxRowLength: criteriaMaxRowLength,
+ maxColumnLength: criteriaMaxColumnLength,
+ isNumberSensitive: true,
});
if (results.length === 1 && results[0].length === 1) {
@@ -80,13 +74,3 @@ export class Countifs extends BaseFunction {
});
}
}
-
-export function countTrueValue(array: ArrayValueObject) {
- let count = 0;
- array.iterator((value) => {
- if (value?.isBoolean() && value.getValue() === true) {
- count++;
- }
- });
- return NumberValueObject.create(count);
-}
diff --git a/packages/engine-formula/src/functions/statistical/maxifs/index.ts b/packages/engine-formula/src/functions/statistical/maxifs/index.ts
index 0cb9565193..30248d02af 100644
--- a/packages/engine-formula/src/functions/statistical/maxifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/maxifs/index.ts
@@ -18,7 +18,7 @@ import type { FunctionVariantType } from '../../../engine/reference-object/base-
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
import { expandArrayValueObject } from '../../../engine/utils/array-object';
-import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
+import { getPairedRangeAndCriteriaResult, 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';
@@ -53,21 +53,12 @@ export class Maxifs extends BaseFunction {
return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
-
- return this._aggregateResults(_maxRange as BaseValueObject, booleanResults);
- }
-
- 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) {
- return ArrayValueObject.create('0');
- }
-
- return picked.max();
- });
+ const results = getPairedRangeAndCriteriaResult(_variants, {
+ formulaName: 'MAXIFS',
+ maxRowLength: criteriaMaxRowLength,
+ maxColumnLength: criteriaMaxColumnLength,
+ isNumberSensitive: true,
+ targetRange: _maxRange as ArrayValueObject,
});
if (results.length === 1 && results[0].length === 1) {
diff --git a/packages/engine-formula/src/functions/statistical/minifs/index.ts b/packages/engine-formula/src/functions/statistical/minifs/index.ts
index 15206554d0..1ad2ba0722 100644
--- a/packages/engine-formula/src/functions/statistical/minifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/minifs/index.ts
@@ -18,7 +18,7 @@ import type { FunctionVariantType } from '../../../engine/reference-object/base-
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
import { expandArrayValueObject } from '../../../engine/utils/array-object';
-import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';
+import { getPairedRangeAndCriteriaResult, 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';
@@ -53,21 +53,12 @@ export class Minifs extends BaseFunction {
return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));
}
- const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);
-
- return this._aggregateResults(_minRange as BaseValueObject, booleanResults);
- }
-
- 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) {
- return ArrayValueObject.create('0');
- }
-
- return picked.min();
- });
+ const results = getPairedRangeAndCriteriaResult(_variants, {
+ formulaName: 'MINIFS',
+ maxRowLength: criteriaMaxRowLength,
+ maxColumnLength: criteriaMaxColumnLength,
+ isNumberSensitive: true,
+ targetRange: _minRange as ArrayValueObject,
});
if (results.length === 1 && results[0].length === 1) {