fix(formula): math functions support string number calculation (#1581)

* fix(formula): math functions support string number calculation * fix(formula): plus,minus,multiply,divided functions return value error * fix(formula): use string to create StringValueObject * fix(formula): use convertToNumberObjectValue
dream-num · Mar 19, 2024 · fd87daf · fd87daf
1 parent e116e4f
commit fd87daf
Show file tree

Hide file tree

Showing 22 changed files with 287 additions and 34 deletions.
diff --git a/packages/engine-formula/src/engine/value-object/__tests__/array-value-divided.spec.ts b/packages/engine-formula/src/engine/value-object/__tests__/array-value-divided.spec.ts
@@ -0,0 +1,47 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { ArrayValueObject, transformToValueObject } from '../array-value-object';
+import { NumberValueObject } from '../primitive-object';
+import { ErrorType } from '../../..';
+
+describe('ArrayValueObject divided method test', () => {
+    describe('Divided', () => {
+        it('Origin nm, param 1', () => {
+            const arrayValueObject = new ArrayValueObject({
+                calculateValueList: transformToValueObject([
+                    [1, ' ', 1.23, true, false, null],
+                    [0, '100', '2.34', 'test', -3, ErrorType.VALUE],
+                ]),
+                rowCount: 2,
+                columnCount: 6,
+                unitId: '',
+                sheetId: '',
+                row: 0,
+                column: 0,
+            });
+
+            const valueObject = new NumberValueObject(1);
+
+            expect((arrayValueObject.divided(valueObject) as ArrayValueObject).toValue()).toStrictEqual([
+                [1, ErrorType.VALUE, 1.23, 1, 0, 0],
+                [0, 100, 2.34, ErrorType.VALUE, -3, ErrorType.VALUE],
+            ]);
+        });
+    });
+});
diff --git a/packages/engine-formula/src/engine/value-object/__tests__/array-value-minus.spec.ts b/packages/engine-formula/src/engine/value-object/__tests__/array-value-minus.spec.ts
@@ -0,0 +1,47 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { ArrayValueObject, transformToValueObject } from '../array-value-object';
+import { NumberValueObject } from '../primitive-object';
+import { ErrorType } from '../../..';
+
+describe('ArrayValueObject minus method test', () => {
+    describe('Minus', () => {
+        it('Origin nm, param 1', () => {
+            const arrayValueObject = new ArrayValueObject({
+                calculateValueList: transformToValueObject([
+                    [1, ' ', 1.23, true, false, null],
+                    [0, '100', '2.34', 'test', -3, ErrorType.VALUE],
+                ]),
+                rowCount: 2,
+                columnCount: 6,
+                unitId: '',
+                sheetId: '',
+                row: 0,
+                column: 0,
+            });
+
+            const valueObject = new NumberValueObject(1);
+
+            expect((arrayValueObject.minus(valueObject) as ArrayValueObject).toValue()).toStrictEqual([
+                [0, ErrorType.VALUE, 0.23, 0, -1, -1],
+                [-1, 99, 1.34, ErrorType.VALUE, -4, ErrorType.VALUE],
+            ]);
+        });
+    });
+});
diff --git a/packages/engine-formula/src/engine/value-object/__tests__/array-value-multiply.spec.ts b/packages/engine-formula/src/engine/value-object/__tests__/array-value-multiply.spec.ts
@@ -0,0 +1,47 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { ArrayValueObject, transformToValueObject } from '../array-value-object';
+import { NumberValueObject } from '../primitive-object';
+import { ErrorType } from '../../..';
+
+describe('ArrayValueObject multiply method test', () => {
+    describe('Multiply', () => {
+        it('Origin nm, param 1', () => {
+            const arrayValueObject = new ArrayValueObject({
+                calculateValueList: transformToValueObject([
+                    [1, ' ', 1.23, true, false, null],
+                    [0, '100', '2.34', 'test', -3, ErrorType.VALUE],
+                ]),
+                rowCount: 2,
+                columnCount: 6,
+                unitId: '',
+                sheetId: '',
+                row: 0,
+                column: 0,
+            });
+
+            const valueObject = new NumberValueObject(1);
+
+            expect((arrayValueObject.multiply(valueObject) as ArrayValueObject).toValue()).toStrictEqual([
+                [1, ErrorType.VALUE, 1.23, 1, 0, 0],
+                [0, 100, 2.34, ErrorType.VALUE, -3, ErrorType.VALUE],
+            ]);
+        });
+    });
+});
diff --git a/packages/engine-formula/src/engine/value-object/__tests__/array-value-plus.spec.ts b/packages/engine-formula/src/engine/value-object/__tests__/array-value-plus.spec.ts
@@ -0,0 +1,47 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { ArrayValueObject, transformToValueObject } from '../array-value-object';
+import { NumberValueObject } from '../primitive-object';
+import { ErrorType } from '../../..';
+
+describe('ArrayValueObject plus method test', () => {
+    describe('Plus', () => {
+        it('Origin nm, param 1', () => {
+            const arrayValueObject = new ArrayValueObject({
+                calculateValueList: transformToValueObject([
+                    [1, ' ', 1.23, true, false, null],
+                    [0, '100', '2.34', 'test', -3, ErrorType.VALUE],
+                ]),
+                rowCount: 2,
+                columnCount: 6,
+                unitId: '',
+                sheetId: '',
+                row: 0,
+                column: 0,
+            });
+
+            const valueObject = new NumberValueObject(1);
+
+            expect((arrayValueObject.plus(valueObject) as ArrayValueObject).toValue()).toStrictEqual([
+                [2, ErrorType.VALUE, 2.23, 2, 1, 1],
+                [1, 101, 3.34, ErrorType.VALUE, -2, ErrorType.VALUE],
+            ]);
+        });
+    });
+});
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
@@ -499,6 +499,8 @@ export class ArrayValueObject extends BaseValueObject {
                 result[result_row_index] = [];
             }
             for (let c = columnStart; c < columnStop; c += columnStep) {
+                if (!array[r] || !array[r][c]) return;
+
                 result[result_row_index][result_column_index] = array[r][c];
                 result_column_index++;
             }

diff --git a/packages/engine-formula/src/engine/value-object/base-value-object.ts b/packages/engine-formula/src/engine/value-object/base-value-object.ts
@@ -129,31 +129,31 @@ export class BaseValueObject extends ObjectClassType {
     }
 
     getNegative(): BaseValueObject {
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     getReciprocal(): BaseValueObject {
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     plus(valueObject: BaseValueObject): BaseValueObject {
         /** abstract */
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     minus(valueObject: BaseValueObject): BaseValueObject {
         /** abstract */
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     multiply(valueObject: BaseValueObject): BaseValueObject {
         /** abstract */
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     divided(valueObject: BaseValueObject): BaseValueObject {
         /** abstract */
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     mod(valueObject: BaseValueObject): BaseValueObject {
@@ -226,22 +226,22 @@ export class BaseValueObject extends ObjectClassType {
 
     plusBy(value: string | number | boolean): BaseValueObject {
         /** abstract */
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     minusBy(value: string | number | boolean): BaseValueObject {
         /** abstract */
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     multiplyBy(value: string | number | boolean): BaseValueObject {
         /** abstract */
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     dividedBy(value: string | number | boolean): BaseValueObject {
         /** abstract */
-        return ErrorValueObject.create(ErrorType.NAME);
+        return ErrorValueObject.create(ErrorType.VALUE);
     }
 
     modInverse(valueObject: BaseValueObject): BaseValueObject {

diff --git a/packages/engine-formula/src/functions/base-function.ts b/packages/engine-formula/src/functions/base-function.ts
@@ -393,18 +393,10 @@ export class BaseFunction extends Disposable {
         for (let i = 0; i < variants.length; i++) {
             let variant = variants[i];
 
-            if (variant.isString()) {
+            if (variant.isString() || variant.isBoolean() || variant.isNull()) {
                 variant = variant.convertToNumberObjectValue();
             }
 
-            if (variant.isBoolean()) {
-                variant = convertTonNumber(variant);
-            }
-
-            if (variant.isNull()) {
-                variant = NumberValueObject.create(0);
-            }
-
             if (variant.isError()) {
                 return variant;
             }

diff --git a/packages/engine-formula/src/functions/math/abs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/abs/__tests__/index.spec.ts
@@ -18,7 +18,7 @@ import { describe, expect, it } from 'vitest';
 
 import { FUNCTION_NAMES_MATH } from '../../function-names';
 import { Abs } from '..';
-import { NumberValueObject } from '../../../../engine/value-object/primitive-object';
+import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
 import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
 
 describe('Test abs function', () => {
@@ -30,6 +30,11 @@ describe('Test abs function', () => {
             const result = textFunction.calculate(value);
             expect(result.getValue()).toBe(1);
         });
+        it('Value is string number', () => {
+            const value = new StringValueObject('1');
+            const result = textFunction.calculate(value);
+            expect(result.getValue()).toBe(1);
+        });
 
         it('Value is array', () => {
             const valueArray = ArrayValueObject.create({

diff --git a/packages/engine-formula/src/functions/math/abs/index.ts b/packages/engine-formula/src/functions/math/abs/index.ts
@@ -25,6 +25,10 @@ export class Abs extends BaseFunction {
             return ErrorValueObject.create(ErrorType.NA);
         }
 
+        if (variant.isString()) {
+            variant = variant.convertToNumberObjectValue();
+        }
+
         if (variant.isError()) {
             return ErrorValueObject.create(ErrorType.VALUE);
         }

diff --git a/packages/engine-formula/src/functions/math/acos/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/acos/__tests__/index.spec.ts
@@ -18,7 +18,7 @@ import { describe, expect, it } from 'vitest';
 
 import { FUNCTION_NAMES_MATH } from '../../function-names';
 import { Acos } from '..';
-import { NumberValueObject } from '../../../../engine/value-object/primitive-object';
+import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
 import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
 
 describe('Test acos function', () => {
@@ -31,6 +31,12 @@ describe('Test acos function', () => {
             expect(result.getValue()).toBe(0);
         });
 
+        it('Value is string number', () => {
+            const value = new StringValueObject('1');
+            const result = textFunction.calculate(value);
+            expect(result.getValue()).toBe(0);
+        });
+
         it('Value is array', () => {
             const valueArray = ArrayValueObject.create({
                 calculateValueList: transformToValueObject([

diff --git a/packages/engine-formula/src/functions/math/acos/index.ts b/packages/engine-formula/src/functions/math/acos/index.ts
@@ -25,8 +25,12 @@ export class Acos extends BaseFunction {
             return ErrorValueObject.create(ErrorType.NA);
         }
 
+        if (variant.isString()) {
+            variant = variant.convertToNumberObjectValue();
+        }
+
         if (variant.isError()) {
-            return variant;
+            return new ErrorValueObject(ErrorType.VALUE);
         }
 
         return variant.acos();

diff --git a/packages/engine-formula/src/functions/math/acosh/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/acosh/__tests__/index.spec.ts
@@ -18,7 +18,7 @@ import { describe, expect, it } from 'vitest';
 
 import { FUNCTION_NAMES_MATH } from '../../function-names';
 import { Acosh } from '..';
-import { NumberValueObject } from '../../../../engine/value-object/primitive-object';
+import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
 import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
 
 describe('Test acosh function', () => {
@@ -31,6 +31,12 @@ describe('Test acosh function', () => {
             expect(result.getValue()).toBe(0);
         });
 
+        it('Value is string number', () => {
+            const value = new StringValueObject('1');
+            const result = textFunction.calculate(value);
+            expect(result.getValue()).toBe(0);
+        });
+
         it('Value is array', () => {
             const valueArray = ArrayValueObject.create({
                 calculateValueList: transformToValueObject([

diff --git a/packages/engine-formula/src/functions/math/acosh/index.ts b/packages/engine-formula/src/functions/math/acosh/index.ts
@@ -25,6 +25,10 @@ export class Acosh extends BaseFunction {
             return ErrorValueObject.create(ErrorType.NA);
         }
 
+        if (variant.isString()) {
+            variant = variant.convertToNumberObjectValue();
+        }
+
         if (variant.isError()) {
             return ErrorValueObject.create(ErrorType.VALUE);
         }