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.

feat(formula): add asin function (#2620)

Dushusir88bde3052614
diff --git a/packages/engine-formula/src/engine/value-object/primitive-object.ts b/packages/engine-formula/src/engine/value-object/primitive-object.ts
index 5251e659b0..1cf19429c3 100644
--- a/packages/engine-formula/src/engine/value-object/primitive-object.ts
+++ b/packages/engine-formula/src/engine/value-object/primitive-object.ts
@@ -1022,6 +1022,11 @@ export class NumberValueObject extends BaseValueObject {
return ErrorValueObject.create(ErrorType.NUM);
}
+ // ATAN2(y, x) calculates the angle of the point (x, y) relative to the positive x-axis. When x and y are both 0, the point is actually the origin itself, and there is no concept of the angle "starting from" the origin to the origin.
+ if (currentValue === 0 && value === 0) {
+ return ErrorValueObject.create(ErrorType.DIV_BY_ZERO);
+ }
+
const result = Math.atan2(currentValue, value);
if (!Number.isFinite(result)) {
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
index 5c5226f6fd..b99fbc2cdb 100644
--- 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,42 +18,64 @@ import { describe, expect, it } from 'vitest';
import { FUNCTION_NAMES_MATH } from '../../function-names';
import { Abs } from '../index';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
describe('Test abs function', () => {
const testFunction = new Abs(FUNCTION_NAMES_MATH.ABS);
describe('Abs', () => {
- it('Value is normal', () => {
- const value = NumberValueObject.create(1);
+ it('Value is normal number', () => {
+ const value = NumberValueObject.create(-1);
const result = testFunction.calculate(value);
expect(result.getValue()).toBe(1);
});
- it('Value is string number', () => {
- const value = new StringValueObject('1');
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('-0.5');
const result = testFunction.calculate(value);
- expect(result.getValue()).toBe(1);
+ expect(result.getValue()).toBe(0.5);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
});
it('Value is array', () => {
const valueArray = ArrayValueObject.create({
calculateValueList: transformToValueObject([
- [1, 2],
- [2, 3],
- [3, 4],
+ [1, ' ', 1.23, true, false, null],
+ [0, '100', '2.34', 'test', -3, ErrorType.NAME],
]),
- rowCount: 3,
- columnCount: 2,
+ rowCount: 2,
+ columnCount: 6,
unitId: '',
sheetId: '',
row: 0,
column: 0,
});
const result = testFunction.calculate(valueArray);
- expect(transformToValue(result.getArrayValue())).toStrictEqual([[1, 2],
- [2, 3],
- [3, 4]]);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[1, ErrorType.VALUE, 1.23, 1, 0, 0], [0, 100, 2.34, ErrorType.VALUE, 3, ErrorType.NAME]]);
});
});
});
diff --git a/packages/engine-formula/src/functions/math/abs/index.ts b/packages/engine-formula/src/functions/math/abs/index.ts
index 9740097dfe..1b1ec90407 100644
--- a/packages/engine-formula/src/functions/math/abs/index.ts
+++ b/packages/engine-formula/src/functions/math/abs/index.ts
@@ -14,9 +14,7 @@
* limitations under the License.
*/
-import { ErrorType } from '../../../basics/error-type';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
-import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
export class Abs extends BaseFunction {
@@ -30,7 +28,7 @@ export class Abs extends BaseFunction {
}
if (variant.isError()) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ return variant;
}
return variant.abs();
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
index e76d485e27..f0504e6e6c 100644
--- 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,41 +18,70 @@ import { describe, expect, it } from 'vitest';
import { FUNCTION_NAMES_MATH } from '../../function-names';
import { Acos } from '../index';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
describe('Test acos function', () => {
const testFunction = new Acos(FUNCTION_NAMES_MATH.ACOS);
describe('Acos', () => {
- it('Value is normal', () => {
+ it('Value is normal number', () => {
const value = NumberValueObject.create(1);
const result = testFunction.calculate(value);
expect(result.getValue()).toBe(0);
});
- it('Value is string number', () => {
- const value = new StringValueObject('1');
+ it('Value is number valid', () => {
+ const value = NumberValueObject.create(-2);
const result = testFunction.calculate(value);
- expect(result.getValue()).toBe(0);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('0.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1.0471975511965979);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1.5707963267948966);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1.5707963267948966);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
});
it('Value is array', () => {
const valueArray = ArrayValueObject.create({
calculateValueList: transformToValueObject([
- [1, ' ', 1.23, true, false],
- [0, '100', '2.34', 'test', -3],
+ [1, ' ', 1.23, true, false, null],
+ [0, '100', '2.34', 'test', -3, ErrorType.NAME],
]),
rowCount: 2,
- columnCount: 5,
+ columnCount: 6,
unitId: '',
sheetId: '',
row: 0,
column: 0,
});
const result = testFunction.calculate(valueArray);
- expect(transformToValue(result.getArrayValue())).toStrictEqual([[0, '#VALUE!', '#NUM!', 0, 1.5707963267948966],
- [1.5707963267948966, '#NUM!', '#NUM!', '#VALUE!', '#NUM!']]);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0, ErrorType.VALUE, ErrorType.NUM, 0, 1.5707963267948966, 1.5707963267948966], [1.5707963267948966, ErrorType.NUM, ErrorType.NUM, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME]]);
});
});
});
diff --git a/packages/engine-formula/src/functions/math/acos/index.ts b/packages/engine-formula/src/functions/math/acos/index.ts
index 2c3ebbcbb7..eebee7b36b 100644
--- a/packages/engine-formula/src/functions/math/acos/index.ts
+++ b/packages/engine-formula/src/functions/math/acos/index.ts
@@ -14,9 +14,7 @@
* limitations under the License.
*/
-import { ErrorType } from '../../../basics/error-type';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
-import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
export class Acos extends BaseFunction {
@@ -30,7 +28,7 @@ export class Acos extends BaseFunction {
}
if (variant.isError()) {
- return new ErrorValueObject(ErrorType.VALUE);
+ return variant;
}
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
index 7506b2e400..159de1e19f 100644
--- 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,41 +18,70 @@ import { describe, expect, it } from 'vitest';
import { FUNCTION_NAMES_MATH } from '../../function-names';
import { Acosh } from '../index';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
describe('Test acosh function', () => {
const testFunction = new Acosh(FUNCTION_NAMES_MATH.ACOSH);
describe('Acosh', () => {
- it('Value is normal', () => {
+ it('Value is normal number', () => {
const value = NumberValueObject.create(1);
const result = testFunction.calculate(value);
expect(result.getValue()).toBe(0);
});
- it('Value is string number', () => {
- const value = new StringValueObject('1');
+ it('Value is number valid', () => {
+ const value = NumberValueObject.create(-2);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('1.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.9624236501192069);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(true);
const result = testFunction.calculate(value);
expect(result.getValue()).toBe(0);
});
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
it('Value is array', () => {
const valueArray = ArrayValueObject.create({
calculateValueList: transformToValueObject([
- [1, ' ', 1.23, true, false],
- [0, '100', '2.34', 'test', -3],
+ [1, ' ', 1.23, true, false, null],
+ [0, '100', '2.34', 'test', -3, ErrorType.NAME],
]),
rowCount: 2,
- columnCount: 5,
+ columnCount: 6,
unitId: '',
sheetId: '',
row: 0,
column: 0,
});
const result = testFunction.calculate(valueArray);
- expect(transformToValue(result.getArrayValue())).toStrictEqual([[0, '#VALUE!', 0.6658635291565548, 0, '#NUM!'],
- ['#NUM!', 5.298292365610484, 1.494153066724473, '#VALUE!', '#NUM!']]);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0, ErrorType.VALUE, 0.6658635291565548, 0, ErrorType.NUM, ErrorType.NUM], [ErrorType.NUM, 5.298292365610484, 1.494153066724473, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME]]);
});
});
});
diff --git a/packages/engine-formula/src/functions/math/acosh/index.ts b/packages/engine-formula/src/functions/math/acosh/index.ts
index 363941ad57..2bb3c01a8f 100644
--- a/packages/engine-formula/src/functions/math/acosh/index.ts
+++ b/packages/engine-formula/src/functions/math/acosh/index.ts
@@ -14,9 +14,7 @@
* limitations under the License.
*/
-import { ErrorType } from '../../../basics/error-type';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
-import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
export class Acosh extends BaseFunction {
@@ -30,7 +28,7 @@ export class Acosh extends BaseFunction {
}
if (variant.isError()) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ return variant;
}
return variant.acosh();
}
diff --git a/packages/engine-formula/src/functions/math/acot/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/acot/__tests__/index.spec.ts
index cbac2fdbc8..93d1f3dce8 100644
--- a/packages/engine-formula/src/functions/math/acot/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/math/acot/__tests__/index.spec.ts
@@ -18,41 +18,70 @@ import { describe, expect, it } from 'vitest';
import { FUNCTION_NAMES_MATH } from '../../function-names';
import { Acot } from '../index';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
describe('Test acot function', () => {
const testFunction = new Acot(FUNCTION_NAMES_MATH.ACOT);
describe('Acot', () => {
- it('Value is normal', () => {
+ it('Value is normal number', () => {
const value = NumberValueObject.create(1);
const result = testFunction.calculate(value);
expect(result.getValue()).toBe(0.7853981633974483);
});
- it('Value is string number', () => {
- const value = new StringValueObject('1');
+ it('Value is number negative', () => {
+ const value = NumberValueObject.create(-2);
const result = testFunction.calculate(value);
- expect(result.getValue()).toBe(0.7853981633974483);
+ expect(result.getValue()).toBe(2.677945044588987);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('1.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.5880026035475675);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1.5707963267948966);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1.5707963267948966);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
});
it('Value is array', () => {
const valueArray = ArrayValueObject.create({
calculateValueList: transformToValueObject([
- [1, ' ', 1.23, true, false],
- [0, '100', '2.34', 'test', -3],
+ [1, ' ', 1.23, true, false, null],
+ [0, '100', '2.34', 'test', -3, ErrorType.NAME],
]),
rowCount: 2,
- columnCount: 5,
+ columnCount: 6,
unitId: '',
sheetId: '',
row: 0,
column: 0,
});
const result = testFunction.calculate(valueArray);
- expect(transformToValue(result.getArrayValue())).toStrictEqual([[0.7853981633974483, '#VALUE!', 0.682622552417217, 0.7853981633974483, 1.5707963267948966],
- [1.5707963267948966, 0.009999666686665238, 0.40385979490737667, '#VALUE!', 2.819842099193151]]);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0.7853981633974483, ErrorType.VALUE, 0.682622552417217, 0.7853981633974483, 1.5707963267948966, 1.5707963267948966], [1.5707963267948966, 0.009999666686665238, 0.40385979490737667, ErrorType.VALUE, 2.819842099193151, ErrorType.NAME]]);
});
});
});
diff --git a/packages/engine-formula/src/functions/math/asin/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/asin/__tests__/index.spec.ts
new file mode 100644
index 0000000000..f9b1827acd
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/asin/__tests__/index.spec.ts
@@ -0,0 +1,87 @@
+/**
+ * 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 { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Asin } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+
+describe('Test asin function', () => {
+ const testFunction = new Asin(FUNCTION_NAMES_MATH.ASIN);
+
+ describe('Asin', () => {
+ it('Value is normal number', () => {
+ const value = NumberValueObject.create(1);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1.5707963267948966);
+ });
+
+ it('Value is number valid', () => {
+ const value = NumberValueObject.create(-2);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('0.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.5235987755982989);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const valueArray = 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 result = testFunction.calculate(valueArray);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[1.5707963267948966, '#VALUE!', ErrorType.NUM, 1.5707963267948966, 0, 0], [0, ErrorType.NUM, ErrorType.NUM, '#VALUE!', ErrorType.NUM, '#NAME?']]);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/math/asin/index.ts b/packages/engine-formula/src/functions/math/asin/index.ts
new file mode 100644
index 0000000000..6263f43ba8
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/asin/index.ts
@@ -0,0 +1,36 @@
+/**
+ * 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 type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Asin extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(variant: BaseValueObject) {
+ if (variant.isString()) {
+ variant = variant.convertToNumberObjectValue();
+ }
+
+ if (variant.isError()) {
+ return variant;
+ }
+
+ return variant.asin();
+ }
+}
diff --git a/packages/engine-formula/src/functions/math/asinh/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/asinh/__tests__/index.spec.ts
new file mode 100644
index 0000000000..8447a50da9
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/asinh/__tests__/index.spec.ts
@@ -0,0 +1,87 @@
+/**
+ * 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 { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Asinh } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+
+describe('Test asinh function', () => {
+ const testFunction = new Asinh(FUNCTION_NAMES_MATH.ASINH);
+
+ describe('Asinh', () => {
+ it('Value is normal number', () => {
+ const value = NumberValueObject.create(1);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.881373587019543);
+ });
+
+ it('Value is number negative', () => {
+ const value = NumberValueObject.create(-2);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(-1.4436354751788103);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('0.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.48121182505960347);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const valueArray = 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 result = testFunction.calculate(valueArray);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0.881373587019543, ErrorType.VALUE, 1.0350378961923077, 0.881373587019543, 0, 0], [0, 5.298342365610589, 1.5861119704218916, ErrorType.VALUE, -1.8184464592320668, ErrorType.NAME]]);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/math/asinh/index.ts b/packages/engine-formula/src/functions/math/asinh/index.ts
new file mode 100644
index 0000000000..eb277fa2a1
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/asinh/index.ts
@@ -0,0 +1,36 @@
+/**
+ * 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 type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Asinh extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(variant: BaseValueObject) {
+ if (variant.isString()) {
+ variant = variant.convertToNumberObjectValue();
+ }
+
+ if (variant.isError()) {
+ return variant;
+ }
+
+ return variant.asinh();
+ }
+}
diff --git a/packages/engine-formula/src/functions/math/atan/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/atan/__tests__/index.spec.ts
new file mode 100644
index 0000000000..217dc78b7d
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/atan/__tests__/index.spec.ts
@@ -0,0 +1,87 @@
+/**
+ * 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 { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Atan } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+
+describe('Test atan function', () => {
+ const testFunction = new Atan(FUNCTION_NAMES_MATH.ATAN);
+
+ describe('Atan', () => {
+ it('Value is normal number', () => {
+ const value = NumberValueObject.create(1);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.7853981633974483);
+ });
+
+ it('Value is number negative', () => {
+ const value = NumberValueObject.create(-2);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(-1.1071487177940904);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('0.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.4636476090008061);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const valueArray = 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 result = testFunction.calculate(valueArray);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0.7853981633974483, ErrorType.VALUE, 0.8881737743776796, 0.7853981633974483, 0, 0], [0, 1.5607966601082315, 1.16693653188752, ErrorType.VALUE, -1.2490457723982544, ErrorType.NAME]]);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/math/atan/index.ts b/packages/engine-formula/src/functions/math/atan/index.ts
new file mode 100644
index 0000000000..3d5bfda69e
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/atan/index.ts
@@ -0,0 +1,36 @@
+/**
+ * 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 type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Atan extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(variant: BaseValueObject) {
+ if (variant.isString()) {
+ variant = variant.convertToNumberObjectValue();
+ }
+
+ if (variant.isError()) {
+ return variant;
+ }
+
+ return variant.atan();
+ }
+}
diff --git a/packages/engine-formula/src/functions/math/atan2/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/atan2/__tests__/index.spec.ts
new file mode 100644
index 0000000000..0037d38616
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/atan2/__tests__/index.spec.ts
@@ -0,0 +1,136 @@
+/**
+ * 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 { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Atan2 } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+
+describe('Test atan2 function', () => {
+ const testFunction = new Atan2(FUNCTION_NAMES_MATH.ATAN2);
+
+ describe('Atan2', () => {
+ it('Value is normal number', () => {
+ const xNum = NumberValueObject.create(1);
+ const yNum = NumberValueObject.create(2);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(1.1071487177940904);
+ });
+ it('Value is normal number 2', () => {
+ const xNum = NumberValueObject.create(8);
+ const yNum = NumberValueObject.create(9);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(0.844153986113171);
+ });
+
+ it('Value is number valid', () => {
+ const xNum = NumberValueObject.create(-2);
+ const yNum = NumberValueObject.create(-3);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(-2.1587989303424644);
+ });
+
+ it('Value is number string', () => {
+ const xNum = StringValueObject.create('0.5');
+ const yNum = NumberValueObject.create(2);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(1.3258176636680326);
+ });
+
+ it('Value is normal string', () => {
+ const xNum = StringValueObject.create('test');
+ const yNum = NumberValueObject.create(1);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const xNum = BooleanValueObject.create(false);
+ const yNum = NumberValueObject.create(1);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(1.5707963267948966);
+ });
+ it('Value is blank cell', () => {
+ const xNum = NullValueObject.create();
+ const yNum = NumberValueObject.create(1);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(1.5707963267948966);
+ });
+ it('Value is error', () => {
+ const xNum = ErrorValueObject.create(ErrorType.NAME);
+ const yNum = NumberValueObject.create(1);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+ it('Result is error', () => {
+ const xNum = NumberValueObject.create(0);
+ const yNum = NumberValueObject.create(0);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(result.getValue()).toBe(ErrorType.DIV_BY_ZERO);
+ });
+
+ it('Value is array and number', () => {
+ const xNum = 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 yNum = NumberValueObject.create(1);
+ const result = testFunction.calculate(xNum, yNum);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0.7853981633974483, ErrorType.VALUE, 0.682622552417217, 0.7853981633974483, 1.5707963267948966, 1.5707963267948966], [1.5707963267948966, 0.009999666686665238, 0.40385979490737667, ErrorType.VALUE, 2.819842099193151, ErrorType.NAME]]);
+ });
+ it('Value is array and array', () => {
+ const xNum = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [1],
+ [2],
+ [3],
+ ]),
+ rowCount: 3,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const yNum = 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 result = testFunction.calculate(xNum, yNum);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0.7853981633974483, ErrorType.VALUE, 0.8881737743776796, 0.7853981633974483, 0, 0], [0, 1.550798992821746, 0.8635794970038352, ErrorType.VALUE, -0.982793723247329, ErrorType.NAME], [ErrorType.NA, ErrorType.NA, ErrorType.NA, ErrorType.NA, ErrorType.NA, ErrorType.NA]]);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/math/atan2/index.ts b/packages/engine-formula/src/functions/math/atan2/index.ts
new file mode 100644
index 0000000000..6cafa4d766
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/atan2/index.ts
@@ -0,0 +1,45 @@
+/**
+ * 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 type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Atan2 extends BaseFunction {
+ override minParams = 2;
+
+ override maxParams = 2;
+
+ override calculate(xNum: BaseValueObject, yNum: BaseValueObject) {
+ if (xNum.isString()) {
+ xNum = xNum.convertToNumberObjectValue();
+ }
+
+ if (xNum.isError()) {
+ return xNum;
+ }
+
+ if (yNum.isString()) {
+ yNum = yNum.convertToNumberObjectValue();
+ }
+
+ if (yNum.isError()) {
+ return yNum;
+ }
+
+ // Note that the order of parameters is different from JavaScript
+ return yNum.atan2(xNum);
+ }
+}
diff --git a/packages/engine-formula/src/functions/math/atanh/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/atanh/__tests__/index.spec.ts
new file mode 100644
index 0000000000..91c11519bc
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/atanh/__tests__/index.spec.ts
@@ -0,0 +1,87 @@
+/**
+ * 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 { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Atanh } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+
+describe('Test atanh function', () => {
+ const testFunction = new Atanh(FUNCTION_NAMES_MATH.ATANH);
+
+ describe('Atanh', () => {
+ it('Value is normal number', () => {
+ const value = NumberValueObject.create(0.1);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.10033534773107558);
+ });
+
+ it('Value is number negative', () => {
+ const value = NumberValueObject.create(-2);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('0.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.5493061443340548);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const valueArray = 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 result = testFunction.calculate(valueArray);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[ErrorType.NUM, ErrorType.VALUE, ErrorType.NUM, ErrorType.NUM, 0, 0], [0, ErrorType.NUM, ErrorType.NUM, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME]]);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/math/atanh/index.ts b/packages/engine-formula/src/functions/math/atanh/index.ts
new file mode 100644
index 0000000000..c36d07116d
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/atanh/index.ts
@@ -0,0 +1,36 @@
+/**
+ * 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 type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Atanh extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(variant: BaseValueObject) {
+ if (variant.isString()) {
+ variant = variant.convertToNumberObjectValue();
+ }
+
+ if (variant.isError()) {
+ return variant;
+ }
+
+ return variant.atanh();
+ }
+}
diff --git a/packages/engine-formula/src/functions/math/cos/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/cos/__tests__/index.spec.ts
new file mode 100644
index 0000000000..81fd1455fd
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/cos/__tests__/index.spec.ts
@@ -0,0 +1,87 @@
+/**
+ * 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 { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Cos } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+
+describe('Test cos function', () => {
+ const testFunction = new Cos(FUNCTION_NAMES_MATH.COS);
+
+ describe('Cos', () => {
+ it('Value is normal number', () => {
+ const value = NumberValueObject.create(1);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.5403023058681398);
+ });
+
+ it('Value is number negative', () => {
+ const value = NumberValueObject.create(-2);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(-0.4161468365471424);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('0.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.8775825618903728);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const valueArray = 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 result = testFunction.calculate(valueArray);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0.5403023058681398, ErrorType.VALUE, 0.3342377271245026, 0.5403023058681398, 1, 1], [1, 0.8623188722876839, -0.695563326462902, ErrorType.VALUE, -0.9899924966004454, ErrorType.NAME]]);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/math/cos/index.ts b/packages/engine-formula/src/functions/math/cos/index.ts
new file mode 100644
index 0000000000..df13bad3b1
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/cos/index.ts
@@ -0,0 +1,36 @@
+/**
+ * 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 type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Cos extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(variant: BaseValueObject) {
+ if (variant.isString()) {
+ variant = variant.convertToNumberObjectValue();
+ }
+
+ if (variant.isError()) {
+ return variant;
+ }
+
+ return variant.cos();
+ }
+}
diff --git a/packages/engine-formula/src/functions/math/function-map.ts b/packages/engine-formula/src/functions/math/function-map.ts
index 837d4e1f7a..dfa986deb4 100644
--- a/packages/engine-formula/src/functions/math/function-map.ts
+++ b/packages/engine-formula/src/functions/math/function-map.ts
@@ -18,6 +18,12 @@ import { Abs } from './abs';
import { Acos } from './acos';
import { Acosh } from './acosh';
import { Acot } from './acot';
+import { Asin } from './asin';
+import { Asinh } from './asinh';
+import { Atan } from './atan';
+import { Atan2 } from './atan2';
+import { Atanh } from './atanh';
+import { Cos } from './cos';
import { FUNCTION_NAMES_MATH } from './function-names';
import { Mod } from './mod';
import { Power } from './power';
@@ -26,17 +32,27 @@ import { Subtotal } from './subtotal';
import { Sum } from './sum';
import { Sumif } from './sumif';
import { Sumifs } from './sumifs';
+import { Tan } from './tan';
+import { Tanh } from './tanh';
export const functionMath = [
[Abs, FUNCTION_NAMES_MATH.ABS],
[Acos, FUNCTION_NAMES_MATH.ACOS],
[Acosh, FUNCTION_NAMES_MATH.ACOSH],
[Acot, FUNCTION_NAMES_MATH.ACOT],
+ [Asin, FUNCTION_NAMES_MATH.ASIN],
+ [Asinh, FUNCTION_NAMES_MATH.ASINH],
+ [Atan, FUNCTION_NAMES_MATH.ATAN],
+ [Atan2, FUNCTION_NAMES_MATH.ATAN2],
+ [Atanh, FUNCTION_NAMES_MATH.ATANH],
+ [Cos, FUNCTION_NAMES_MATH.COS],
[Mod, FUNCTION_NAMES_MATH.MOD],
+ [Power, FUNCTION_NAMES_MATH.POWER],
+ [Product, FUNCTION_NAMES_MATH.PRODUCT],
[Subtotal, FUNCTION_NAMES_MATH.SUBTOTAL],
[Sum, FUNCTION_NAMES_MATH.SUM],
[Sumif, FUNCTION_NAMES_MATH.SUMIF],
[Sumifs, FUNCTION_NAMES_MATH.SUMIFS],
- [Power, FUNCTION_NAMES_MATH.POWER],
- [Product, FUNCTION_NAMES_MATH.PRODUCT],
+ [Tan, FUNCTION_NAMES_MATH.TAN],
+ [Tanh, FUNCTION_NAMES_MATH.TANH],
];
diff --git a/packages/engine-formula/src/functions/math/tan/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/tan/__tests__/index.spec.ts
new file mode 100644
index 0000000000..7faf8b6ddb
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/tan/__tests__/index.spec.ts
@@ -0,0 +1,87 @@
+/**
+ * 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 { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Tan } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+
+describe('Test tan function', () => {
+ const testFunction = new Tan(FUNCTION_NAMES_MATH.TAN);
+
+ describe('Tan', () => {
+ it('Value is normal number', () => {
+ const value = NumberValueObject.create(1);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(1.5574077246549023);
+ });
+
+ it('Value is number negative', () => {
+ const value = NumberValueObject.create(-2);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(2.185039863261519);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('0.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.5463024898437905);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const valueArray = 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 result = testFunction.calculate(valueArray);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[1.5574077246549023, ErrorType.VALUE, 2.819815734268152, 1.5574077246549023, 0, 0], [0, -0.5872139151569291, -1.032925063376592, ErrorType.VALUE, 0.1425465430742778, ErrorType.NAME]]);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/math/tan/index.ts b/packages/engine-formula/src/functions/math/tan/index.ts
new file mode 100644
index 0000000000..210ec2f113
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/tan/index.ts
@@ -0,0 +1,36 @@
+/**
+ * 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 type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Tan extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(variant: BaseValueObject) {
+ if (variant.isString()) {
+ variant = variant.convertToNumberObjectValue();
+ }
+
+ if (variant.isError()) {
+ return variant;
+ }
+
+ return variant.tan();
+ }
+}
diff --git a/packages/engine-formula/src/functions/math/tanh/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/tanh/__tests__/index.spec.ts
new file mode 100644
index 0000000000..2d6c8aa7a3
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/tanh/__tests__/index.spec.ts
@@ -0,0 +1,87 @@
+/**
+ * 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 { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Tanh } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
+import { ErrorType } from '../../../../basics/error-type';
+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
+
+describe('Test tanh function', () => {
+ const testFunction = new Tanh(FUNCTION_NAMES_MATH.TANH);
+
+ describe('Tanh', () => {
+ it('Value is normal number', () => {
+ const value = NumberValueObject.create(1);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.7615941559557649);
+ });
+
+ it('Value is number negative', () => {
+ const value = NumberValueObject.create(-2);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(-0.9640275800758169);
+ });
+
+ it('Value is number string', () => {
+ const value = StringValueObject.create('0.5');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0.46211715726000974);
+ });
+
+ it('Value is normal string', () => {
+ const value = StringValueObject.create('test');
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const value = BooleanValueObject.create(false);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is blank cell', () => {
+ const value = NullValueObject.create();
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(0);
+ });
+ it('Value is error', () => {
+ const value = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(value);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const valueArray = 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 result = testFunction.calculate(valueArray);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[0.7615941559557649, ErrorType.VALUE, 0.8425793256589296, 0.7615941559557649, 0, 0], [0, 1, 0.9816125892654238, ErrorType.VALUE, -0.9950547536867305, ErrorType.NAME]]);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/math/tanh/index.ts b/packages/engine-formula/src/functions/math/tanh/index.ts
new file mode 100644
index 0000000000..468fc85681
--- /dev/null
+++ b/packages/engine-formula/src/functions/math/tanh/index.ts
@@ -0,0 +1,36 @@
+/**
+ * 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 type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Tanh extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(variant: BaseValueObject) {
+ if (variant.isString()) {
+ variant = variant.convertToNumberObjectValue();
+ }
+
+ if (variant.isError()) {
+ return variant;
+ }
+
+ return variant.tanh();
+ }
+}
diff --git a/packages/sheets-formula/src/controllers/formula-render.controller.ts b/packages/sheets-formula/src/controllers/formula-render.controller.ts
index 2c81bcc3b3..e673f0a62a 100644
--- a/packages/sheets-formula/src/controllers/formula-render.controller.ts
+++ b/packages/sheets-formula/src/controllers/formula-render.controller.ts
@@ -17,7 +17,7 @@
import { LifecycleStages, OnLifecycle, RxDisposable } from '@univerjs/core';
import { Inject } from '@wendellhu/redi';
import { INTERCEPTOR_POINT, SheetInterceptorService } from '@univerjs/sheets';
-import { extractFormulaError, extractFormulaNumber } from './utils/utils';
+import { extractFormulaError } from './utils/utils';
const FORMULA_ERROR_MARK = {
tl: {
@@ -41,15 +41,6 @@ export class FormulaRenderManagerController extends RxDisposable {
INTERCEPTOR_POINT.CELL_CONTENT,
{
handler: (cell, pos, next) => {
- // Dealing with precision issues
- const formulaNumber = extractFormulaNumber(cell);
- if (formulaNumber !== null) {
- return next({
- ...cell,
- v: formulaNumber,
- });
- }
-
const errorType = extractFormulaError(cell);
if (!errorType) {
return next(cell);
diff --git a/packages/sheets-formula/src/locale/function-list/math/en-US.ts b/packages/sheets-formula/src/locale/function-list/math/en-US.ts
index 94b47bff9c..118669dd5b 100644
--- a/packages/sheets-formula/src/locale/function-list/math/en-US.ts
+++ b/packages/sheets-formula/src/locale/function-list/math/en-US.ts
@@ -113,7 +113,7 @@ export default {
},
},
ASIN: {
- description: 'Returns the arcsine of a number',
+ description: 'Returns the arcsine of a number.',
abstract: 'Returns the arcsine of a number',
links: [
{
@@ -122,12 +122,11 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: 'number', detail: 'The sine of the angle you want and must be from -1 to 1.' },
},
},
ASINH: {
- description: 'Returns the inverse hyperbolic sine of a number',
+ description: 'Returns the inverse hyperbolic sine of a number.',
abstract: 'Returns the inverse hyperbolic sine of a number',
links: [
{
@@ -136,12 +135,11 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: 'number', detail: 'Any real number.' },
},
},
ATAN: {
- description: 'Returns the arctangent of a number',
+ description: 'Returns the arctangent of a number.',
abstract: 'Returns the arctangent of a number',
links: [
{
@@ -150,12 +148,11 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: 'number', detail: 'The tangent of the angle you want.' },
},
},
ATAN2: {
- description: 'Returns the arctangent from x- and y-coordinates',
+ description: 'Returns the arctangent from x- and y-coordinates.',
abstract: 'Returns the arctangent from x- and y-coordinates',
links: [
{
@@ -164,12 +161,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ xNum: { name: 'x_num', detail: 'The x-coordinate of the point.' },
+ yNum: { name: 'y_num', detail: 'The y-coordinate of the point.' },
},
},
ATANH: {
- description: 'Returns the inverse hyperbolic tangent of a number',
+ description: 'Returns the inverse hyperbolic tangent of a number.',
abstract: 'Returns the inverse hyperbolic tangent of a number',
links: [
{
@@ -178,8 +175,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: 'number', detail: 'Any real number between 1 and -1.' },
},
},
BASE: {
@@ -267,7 +263,7 @@ export default {
},
},
COS: {
- description: 'Returns the cosine of a number',
+ description: 'Returns the cosine of a number.',
abstract: 'Returns the cosine of a number',
links: [
{
@@ -276,8 +272,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: 'number', detail: 'The angle in radians for which you want the cosine.' },
},
},
COSH: {
@@ -1141,7 +1136,7 @@ export default {
},
},
TAN: {
- description: 'Returns the tangent of a number',
+ description: 'Returns the tangent of a number.',
abstract: 'Returns the tangent of a number',
links: [
{
@@ -1150,12 +1145,11 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: 'number', detail: 'The angle in radians for which you want the tangent.' },
},
},
TANH: {
- description: 'Returns the hyperbolic tangent of a number',
+ description: 'Returns the hyperbolic tangent of a number.',
abstract: 'Returns the hyperbolic tangent of a number',
links: [
{
@@ -1164,8 +1158,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: 'number', detail: 'Any real number.' },
},
},
TRUNC: {
diff --git a/packages/sheets-formula/src/locale/function-list/math/ja-JP.ts b/packages/sheets-formula/src/locale/function-list/math/ja-JP.ts
index e57e33731e..b3ee6a4ac0 100644
--- a/packages/sheets-formula/src/locale/function-list/math/ja-JP.ts
+++ b/packages/sheets-formula/src/locale/function-list/math/ja-JP.ts
@@ -114,7 +114,7 @@ export default {
},
ASIN: {
description: '数値のアークサインを返します。',
- abstract: '数値のアークサインを返します。',
+ abstract: '数値のアークサインを返します',
links: [
{
title: '指導',
@@ -122,13 +122,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数値', detail: '求める角度のサインの値を -1 ~ 1 の範囲で指定します。' },
},
},
ASINH: {
description: '数値の双曲線逆正弦 (ハイパーボリック サインの逆関数) を返します。',
- abstract: '数値の双曲線逆正弦 (ハイパーボリック サインの逆関数) を返します。',
+ abstract: '数値の双曲線逆正弦 (ハイパーボリック サインの逆関数) を返します',
links: [
{
title: '指導',
@@ -136,13 +135,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数値', detail: '実数を指定します。' },
},
},
ATAN: {
description: '数値のアークタンジェントを返します。',
- abstract: '数値のアークタンジェントを返します。',
+ abstract: '数値のアークタンジェントを返します',
links: [
{
title: '指導',
@@ -150,13 +148,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数値', detail: '求める角度のタンジェントの値を指定します。' },
},
},
ATAN2: {
description: '指定された x-y 座標のアークタンジェントを返します。',
- abstract: '指定された x-y 座標のアークタンジェントを返します。',
+ abstract: '指定された x-y 座標のアークタンジェントを返します',
links: [
{
title: '指導',
@@ -164,13 +161,13 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ xNum: { name: 'x 座標', detail: '点の x 座標を指定します。' },
+ yNum: { name: 'y 座標', detail: '点の y 座標を指定します。' },
},
},
ATANH: {
description: '数値の双曲線逆正接 (ハイパーボリック タンジェントの逆関数) を返します。',
- abstract: '数値の双曲線逆正接 (ハイパーボリック タンジェントの逆関数) を返します。',
+ abstract: '数値の双曲線逆正接 (ハイパーボリック タンジェントの逆関数) を返します',
links: [
{
title: '指導',
@@ -178,8 +175,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数値', detail: '-1 より大きく 1 より小さい実数を指定します。' },
},
},
BASE: {
@@ -268,7 +264,7 @@ export default {
},
COS: {
description: '指定された角度のコサインを返します。',
- abstract: '指定された角度のコサインを返します。',
+ abstract: '指定された角度のコサインを返します',
links: [
{
title: '指導',
@@ -276,8 +272,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数値', detail: 'コサインを求める角度をラジアンで指定します。' },
},
},
COSH: {
@@ -1133,7 +1128,7 @@ export default {
},
TAN: {
description: '指定された角度のタンジェントを返します。',
- abstract: '指定された角度のタンジェントを返します。',
+ abstract: '指定された角度のタンジェントを返します',
links: [
{
title: '指導',
@@ -1141,13 +1136,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数値', detail: 'タンジェントを求める角度をラジアンを単位として指定します。' },
},
},
TANH: {
description: '数値の双曲線正接 (ハイパーボリック タンジェント) を返します。',
- abstract: '数値の双曲線正接 (ハイパーボリック タンジェント) を返します。',
+ abstract: '数値の双曲線正接 (ハイパーボリック タンジェント) を返します',
links: [
{
title: '指導',
@@ -1155,8 +1149,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数値', detail: '実数を指定します。' },
},
},
TRUNC: {
diff --git a/packages/sheets-formula/src/locale/function-list/math/zh-CN.ts b/packages/sheets-formula/src/locale/function-list/math/zh-CN.ts
index 6d1de0091d..62d8504224 100644
--- a/packages/sheets-formula/src/locale/function-list/math/zh-CN.ts
+++ b/packages/sheets-formula/src/locale/function-list/math/zh-CN.ts
@@ -112,7 +112,7 @@ export default {
},
},
ASIN: {
- description: '返回数字的反正弦值',
+ description: '返回数字的反正弦值。',
abstract: '返回数字的反正弦值',
links: [
{
@@ -121,12 +121,11 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数值', detail: ' 所求角度的正弦值,必须介于 -1 到 1 之间。' },
},
},
ASINH: {
- description: '返回数字的反双曲正弦值',
+ description: '返回数字的反双曲正弦值。',
abstract: '返回数字的反双曲正弦值',
links: [
{
@@ -135,12 +134,11 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数值', detail: '任意实数。' },
},
},
ATAN: {
- description: '返回数字的反正切值',
+ description: '返回数字的反正切值。',
abstract: '返回数字的反正切值',
links: [
{
@@ -149,12 +147,11 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数值', detail: '所求角度的正切值。' },
},
},
ATAN2: {
- description: '返回 X 和 Y 坐标的反正切值',
+ description: '返回 X 和 Y 坐标的反正切值。',
abstract: '返回 X 和 Y 坐标的反正切值',
links: [
{
@@ -163,12 +160,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ xNum: { name: 'x 坐标', detail: '点的 x 坐标。' },
+ yNum: { name: 'y 坐标', detail: '点的 y 坐标。' },
},
},
ATANH: {
- description: '返回数字的反双曲正切值',
+ description: '返回数字的反双曲正切值。',
abstract: '返回数字的反双曲正切值',
links: [
{
@@ -177,8 +174,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数值', detail: '-1 到 1 之间的任意实数。' },
},
},
BASE: {
@@ -266,7 +262,7 @@ export default {
},
},
COS: {
- description: '返回数字的余弦值',
+ description: '返回数字的余弦值。',
abstract: '返回数字的余弦值',
links: [
{
@@ -275,8 +271,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数值', detail: '想要求余弦的角度,以弧度表示。' },
},
},
COSH: {
@@ -1142,7 +1137,7 @@ export default {
},
},
TAN: {
- description: '返回数字的正切值',
+ description: '返回数字的正切值。',
abstract: '返回数字的正切值',
links: [
{
@@ -1151,12 +1146,11 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数值', detail: '要求正切的角度,以弧度表示。' },
},
},
TANH: {
- description: '返回数字的双曲正切值',
+ description: '返回数字的双曲正切值。',
abstract: '返回数字的双曲正切值',
links: [
{
@@ -1165,8 +1159,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数值', detail: '任意实数。' },
},
},
TRUNC: {
diff --git a/packages/sheets-formula/src/services/function-list/math.ts b/packages/sheets-formula/src/services/function-list/math.ts
index 5a768acd3b..a0611d37f8 100644
--- a/packages/sheets-formula/src/services/function-list/math.ts
+++ b/packages/sheets-formula/src/services/function-list/math.ts
@@ -151,16 +151,9 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [
abstract: 'formula.functionList.ASIN.abstract',
functionParameter: [
{
- name: 'formula.functionList.ASIN.functionParameter.number1.name',
- detail: 'formula.functionList.ASIN.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.ASIN.functionParameter.number2.name',
- detail: 'formula.functionList.ASIN.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.ASIN.functionParameter.number.name',
+ detail: 'formula.functionList.ASIN.functionParameter.number.detail',
+ example: '0',
require: 1,
repeat: 0,
},
@@ -173,16 +166,9 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [
abstract: 'formula.functionList.ASINH.abstract',
functionParameter: [
{
- name: 'formula.functionList.ASINH.functionParameter.number1.name',
- detail: 'formula.functionList.ASINH.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.ASINH.functionParameter.number2.name',
- detail: 'formula.functionList.ASINH.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.ASINH.functionParameter.number.name',
+ detail: 'formula.functionList.ASINH.functionParameter.number.detail',
+ example: '10',
require: 1,
repeat: 0,
},
@@ -195,16 +181,9 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [
abstract: 'formula.functionList.ATAN.abstract',
functionParameter: [
{
- name: 'formula.functionList.ATAN.functionParameter.number1.name',
- detail: 'formula.functionList.ATAN.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.ATAN.functionParameter.number2.name',
- detail: 'formula.functionList.ATAN.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.ATAN.functionParameter.number.name',
+ detail: 'formula.functionList.ATAN.functionParameter.number.detail',
+ example: '1',
require: 1,
repeat: 0,
},
@@ -217,16 +196,16 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [
abstract: 'formula.functionList.ATAN2.abstract',
functionParameter: [
{
- name: 'formula.functionList.ATAN2.functionParameter.number1.name',
- detail: 'formula.functionList.ATAN2.functionParameter.number1.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.ATAN2.functionParameter.xNum.name',
+ detail: 'formula.functionList.ATAN2.functionParameter.xNum.detail',
+ example: '4',
require: 1,
repeat: 0,
},
{
- name: 'formula.functionList.ATAN2.functionParameter.number2.name',
- detail: 'formula.functionList.ATAN2.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.ATAN2.functionParameter.yNum.name',
+ detail: 'formula.functionList.ATAN2.functionParameter.yNum.detail',
+ example: '3',
require: 1,
repeat: 0,
},
@@ -239,16 +218,9 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [
abstract: 'formula.functionList.ATANH.abstract',
functionParameter: [
{
- name: 'formula.functionList.ATANH.functionParameter.number1.name',
- detail: 'formula.functionList.ATANH.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.ATANH.functionParameter.number2.name',
- detail: 'formula.functionList.ATANH.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.ATANH.functionParameter.number.name',
+ detail: 'formula.functionList.ATANH.functionParameter.number.detail',
+ example: '0.1',
require: 1,
repeat: 0,
},
@@ -393,16 +365,9 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [
abstract: 'formula.functionList.COS.abstract',
functionParameter: [
{
- name: 'formula.functionList.COS.functionParameter.number1.name',
- detail: 'formula.functionList.COS.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.COS.functionParameter.number2.name',
- detail: 'formula.functionList.COS.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.COS.functionParameter.number.name',
+ detail: 'formula.functionList.COS.functionParameter.number.detail',
+ example: '1',
require: 1,
repeat: 0,
},
@@ -1772,16 +1737,9 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [
abstract: 'formula.functionList.TAN.abstract',
functionParameter: [
{
- name: 'formula.functionList.TAN.functionParameter.number1.name',
- detail: 'formula.functionList.TAN.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.TAN.functionParameter.number2.name',
- detail: 'formula.functionList.TAN.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.TAN.functionParameter.number.name',
+ detail: 'formula.functionList.TAN.functionParameter.number.detail',
+ example: '1',
require: 1,
repeat: 0,
},
@@ -1794,16 +1752,9 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [
abstract: 'formula.functionList.TANH.abstract',
functionParameter: [
{
- name: 'formula.functionList.TANH.functionParameter.number1.name',
- detail: 'formula.functionList.TANH.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.TANH.functionParameter.number2.name',
- detail: 'formula.functionList.TANH.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.TANH.functionParameter.number.name',
+ detail: 'formula.functionList.TANH.functionParameter.number.detail',
+ example: '1',
require: 1,
repeat: 0,
},
diff --git a/packages/sheets/src/controllers/number-cell.controller.ts b/packages/sheets/src/controllers/number-cell.controller.ts
new file mode 100644
index 0000000000..09f69e23df
--- /dev/null
+++ b/packages/sheets/src/controllers/number-cell.controller.ts
@@ -0,0 +1,60 @@
+/**
+ * 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 { CellValueType, Disposable, LifecycleStages, OnLifecycle } from '@univerjs/core';
+import { stripErrorMargin } from '@univerjs/engine-formula';
+import { Inject } from '@wendellhu/redi';
+import { SheetInterceptorService } from '../services/sheet-interceptor/sheet-interceptor.service';
+import { INTERCEPTOR_POINT } from '../services/sheet-interceptor/interceptor-const';
+
+@OnLifecycle(LifecycleStages.Ready, NumberCellDisplayController)
+export class NumberCellDisplayController extends Disposable {
+ constructor(
+ @Inject(SheetInterceptorService) private _sheetInterceptorService: SheetInterceptorService) {
+ super();
+
+ this._initialize();
+ }
+
+ private _initialize(): void {
+ this._initInterceptorCellContent();
+ }
+
+ private _initInterceptorCellContent() {
+ this.disposeWithMe(
+ this._sheetInterceptorService.intercept(INTERCEPTOR_POINT.CELL_CONTENT, {
+ priority: 11,
+ handler: (cell, location, next) => {
+ // Skip if the cell contains a numfmt pattern
+ const style = location.workbook.getStyles().getStyleByCell(cell);
+ if (style?.n?.pattern) {
+ return next({ ...cell });
+ }
+
+ // Dealing with precision issues
+ if (cell?.t === CellValueType.NUMBER && typeof cell?.v === 'number') {
+ return next({
+ ...cell,
+ v: stripErrorMargin(cell.v),
+ });
+ }
+
+ return next({ ...cell });
+ },
+ })
+ );
+ }
+}
diff --git a/packages/sheets/src/sheets-plugin.ts b/packages/sheets/src/sheets-plugin.ts
index 9570b063c7..6d0fadc19b 100644
--- a/packages/sheets/src/sheets-plugin.ts
+++ b/packages/sheets/src/sheets-plugin.ts
@@ -39,6 +39,7 @@ import { RangeProtectionRuleModel } from './model/range-protection-rule.model';
import { RangeProtectionRefRangeService } from './services/permission/range-permission/range-protection.ref-range';
import { RangeProtectionService } from './services/permission/range-permission/range-protection.service';
import { ONLY_REGISTER_FORMULA_RELATED_MUTATIONS_KEY } from './controllers/config';
+import { NumberCellDisplayController } from './controllers/number-cell.controller';
const PLUGIN_NAME = 'SHEET_PLUGIN';
@@ -96,6 +97,7 @@ export class UniverSheetsPlugin extends Plugin {
// controllers
[BasicWorksheetController],
[MergeCellController],
+ [NumberCellDisplayController],
[DefinedNameDataController],
// permission