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 some engineering functions (#3070)

wpxp123456dbe1dab799fb
diff --git a/packages/engine-formula/package.json b/packages/engine-formula/package.json
index 438cee1d88..f6bacf0f91 100644
--- a/packages/engine-formula/package.json
+++ b/packages/engine-formula/package.json
@@ -65,6 +65,7 @@
"rxjs": ">=7.0.0"
},
"dependencies": {
+ "decimal.js": "^10.4.3",
"numfmt": "^2.5.2"
},
"devDependencies": {
diff --git a/packages/engine-formula/src/basics/__tests__/engineering.spec.ts b/packages/engine-formula/src/basics/__tests__/engineering.spec.ts
new file mode 100644
index 0000000000..2fcb1dfeef
--- /dev/null
+++ b/packages/engine-formula/src/basics/__tests__/engineering.spec.ts
@@ -0,0 +1,90 @@
+/**
+ * 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 { BESSEL } from '../engineering';
+import { Complex } from '../complex';
+
+describe('Test ref regex', () => {
+ it('BESSEL.besselj test', () => {
+ expect(BESSEL.besselj(3, 0)).toStrictEqual(-0.2600519577199309);
+ expect(BESSEL.besselj(9, 0)).toStrictEqual(-0.09033361101567323);
+ expect(BESSEL.besselj(9, 1)).toStrictEqual(0.2453117865662281);
+ expect(BESSEL.besselj(0, 1)).toStrictEqual(0);
+ expect(BESSEL.besselj(0, 2)).toStrictEqual(0);
+ expect(BESSEL.besselj(-1, 1)).toStrictEqual(-0.4400505856771301);
+ expect(BESSEL.besselj(3, 2)).toStrictEqual(0.4860912632349548);
+ expect(BESSEL.besselj(2, 3)).toStrictEqual(0.12894324997562717);
+ expect(BESSEL.besselj(2, 300)).toStrictEqual(Number.NaN);
+ });
+
+ it('BESSEL.bessely test', () => {
+ expect(BESSEL.bessely(3, 0)).toStrictEqual(0.3768500150996341);
+ expect(BESSEL.bessely(9, 0)).toStrictEqual(0.24993669828517454);
+ expect(BESSEL.bessely(9, 1)).toStrictEqual(0.10431457495919716);
+ });
+
+ it('BESSEL.besseli test', () => {
+ expect(BESSEL.besseli(4, 4)).toStrictEqual(1.4162757349797126);
+ expect(BESSEL.besseli(4, 0)).toStrictEqual(11.301922170199603);
+ expect(BESSEL.besseli(4, 1)).toStrictEqual(9.759465157394443);
+ expect(BESSEL.besseli(1, 0)).toStrictEqual(1.2660658480342601);
+ expect(BESSEL.besseli(0, 1)).toStrictEqual(0);
+ expect(BESSEL.besseli(0, 2)).toStrictEqual(0);
+ expect(BESSEL.besseli(2, 300)).toStrictEqual(Number.NaN);
+ });
+
+ it('BESSEL.besselk test', () => {
+ expect(BESSEL.besselk(3, 3)).toStrictEqual(0.12217037599313321);
+ expect(BESSEL.besselk(3, 0)).toStrictEqual(0.03473950439930018);
+ expect(BESSEL.besselk(1, 0)).toStrictEqual(0.421024421083418);
+ });
+
+ it('Complex test createByComplexStr', () => {
+ const complex = Complex.createByComplexStr(0, 1, 'i');
+ const realNum = complex.getRealNum();
+ const iNum = complex.getINum();
+ const suffix = complex.getSuffix();
+ const result = Complex.getComplex(realNum, iNum, suffix);
+ expect(result).toStrictEqual('i');
+ });
+
+ it('Complex test isError', () => {
+ let complex = new Complex('1+1');
+ expect(complex.isError()).toStrictEqual(true);
+
+ complex = new Complex('1+ti');
+ expect(complex.isError()).toStrictEqual(true);
+
+ complex = new Complex('1-ti');
+ expect(complex.isError()).toStrictEqual(true);
+
+ complex = new Complex('1+ttt');
+ expect(complex.isError()).toStrictEqual(true);
+
+ complex = new Complex('ti');
+ expect(complex.isError()).toStrictEqual(true);
+
+ complex = new Complex('+ti');
+ expect(complex.isError()).toStrictEqual(true);
+
+ complex = new Complex('12i');
+ expect(complex.isError()).toStrictEqual(false);
+
+ complex = new Complex('1-i');
+ expect(complex.isError()).toStrictEqual(false);
+ });
+});
diff --git a/packages/engine-formula/src/basics/complex.ts b/packages/engine-formula/src/basics/complex.ts
new file mode 100644
index 0000000000..827d277e09
--- /dev/null
+++ b/packages/engine-formula/src/basics/complex.ts
@@ -0,0 +1,583 @@
+/**
+ * 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 Decimal from 'decimal.js';
+
+// Decimal.cos has a bug when calculating PI/2
+Decimal.prototype.cos = function (): Decimal {
+ const num = this.toNumber();
+ return new Decimal(Math.cos(num));
+};
+
+export class Complex {
+ static getComplex(realNum: number, iNum: number, suffix: string): number | string {
+ const _realNum = new Decimal(realNum).toSignificantDigits(15).toNumber();
+ const _iNum = new Decimal(iNum).toSignificantDigits(15).toNumber();
+ const _suffix = suffix === '' ? 'i' : suffix;
+
+ let result: number | string;
+
+ if (_realNum === 0 && _iNum === 0) {
+ result = 0;
+ } else if (_realNum === 0) {
+ result = _iNum === 1 ? _suffix : `${_iNum}${_suffix}`;
+ } else if (_iNum === 0) {
+ result = _realNum;
+ } else {
+ const sign = _iNum > 0 ? '+' : '';
+ const suffixStr = _iNum === 1 ? _suffix : `${_iNum}${_suffix}`;
+ result = `${_realNum}${sign}${suffixStr}`;
+ }
+
+ return result;
+ }
+
+ static createByComplexStr(realNum: number, iNum: number, suffix: string): Complex {
+ const complexStr = Complex.getComplex(realNum, iNum, suffix);
+
+ return new Complex(complexStr);
+ }
+
+ private _inumber: string | number = '';
+
+ private _realNum: number = 0;
+
+ private _iNum: number = 0;
+
+ private _suffix: string = '';
+
+ private _isError: boolean = false;
+
+ constructor(inumber: number | string) {
+ if (`${inumber}`.trim() === '') {
+ this._isError = true;
+ return;
+ }
+
+ this._inumber = inumber;
+ this._getImReal();
+ this._getImAginary();
+ this._getImSuffix();
+ }
+
+ private _getImReal(): void {
+ if (this._inumber === 0 || this._inumber === '0') {
+ this._realNum = 0;
+ return;
+ }
+
+ const inumberStr = `${this._inumber}`;
+
+ if (['i', '+i', '1i', '+1i', '-i', '-1i', 'j', '+j', '1j', '+1j', '-j', '-1j'].indexOf(inumberStr) >= 0) {
+ this._realNum = 0;
+ return;
+ }
+
+ let plus = inumberStr.indexOf('+');
+ let minus = inumberStr.indexOf('-');
+
+ if (plus === 0) {
+ plus = inumberStr.indexOf('+', 1);
+ }
+
+ if (minus === 0) {
+ minus = inumberStr.indexOf('-', 1);
+ }
+
+ const last = inumberStr.substring(inumberStr.length - 1, inumberStr.length);
+ const unit = last === 'i' || last === 'j';
+
+ if (plus >= 0 || minus >= 0) {
+ if (!unit) {
+ this._isError = true;
+ return;
+ }
+
+ if (plus >= 0) {
+ if (Number.isNaN(+inumberStr.substring(0, plus)) || Number.isNaN(+inumberStr.substring(plus + 1, inumberStr.length - 1))) {
+ this._isError = true;
+ } else {
+ this._realNum = +inumberStr.substring(0, plus);
+ }
+ } else {
+ if (Number.isNaN(+inumberStr.substring(0, minus)) || Number.isNaN(+inumberStr.substring(minus + 1, inumberStr.length - 1))) {
+ this._isError = true;
+ } else {
+ this._realNum = +inumberStr.substring(0, minus);
+ }
+ }
+ } else {
+ if (unit) {
+ if (Number.isNaN(+inumberStr.substring(0, inumberStr.length - 1))) {
+ this._isError = true;
+ } else {
+ this._realNum = 0;
+ }
+ } else {
+ if (Number.isNaN(+inumberStr)) {
+ this._isError = true;
+ } else {
+ this._realNum = +inumberStr;
+ }
+ }
+ }
+ }
+
+ private _getImAginary(): void {
+ if (this._isError) {
+ return;
+ }
+
+ if (this._inumber === 0 || this._inumber === '0') {
+ this._iNum = 0;
+ return;
+ }
+
+ let inumberStr = `${this._inumber}`;
+
+ if (['i', 'j'].indexOf(inumberStr) >= 0) {
+ this._iNum = 1;
+ return;
+ }
+
+ inumberStr = inumberStr.replace('+i', '+1i').replace('-i', '-1i').replace('+j', '+1j').replace('-j', '-1j');
+
+ let plus = inumberStr.indexOf('+');
+ let minus = inumberStr.indexOf('-');
+
+ if (plus === 0) {
+ plus = inumberStr.indexOf('+', 1);
+ }
+
+ if (minus === 0) {
+ minus = inumberStr.indexOf('-', 1);
+ }
+
+ const last = inumberStr.substring(inumberStr.length - 1, inumberStr.length);
+ const unit = last === 'i' || last === 'j';
+
+ if (plus >= 0 || minus >= 0) {
+ if (!unit) {
+ this._isError = true;
+ return;
+ }
+
+ if (plus >= 0) {
+ if (Number.isNaN(+inumberStr.substring(0, plus)) || Number.isNaN(+inumberStr.substring(plus + 1, inumberStr.length - 1))) {
+ this._isError = true;
+ } else {
+ this._iNum = +inumberStr.substring(plus + 1, inumberStr.length - 1);
+ }
+ } else {
+ if (Number.isNaN(+inumberStr.substring(0, minus)) || Number.isNaN(+inumberStr.substring(minus + 1, inumberStr.length - 1))) {
+ this._isError = true;
+ } else {
+ this._iNum = -(+inumberStr.substring(minus + 1, inumberStr.length - 1));
+ }
+ }
+ } else {
+ if (unit) {
+ if (Number.isNaN(+inumberStr.substring(0, inumberStr.length - 1))) {
+ this._isError = true;
+ } else {
+ this._iNum = +inumberStr.substring(0, inumberStr.length - 1);
+ }
+ } else {
+ if (Number.isNaN(+inumberStr)) {
+ this._isError = true;
+ } else {
+ this._iNum = 0;
+ }
+ }
+ }
+ }
+
+ private _getImSuffix(): void {
+ const inumberStr = `${this._inumber}`;
+
+ const suffix = inumberStr.substring(inumberStr.length - 1);
+
+ this._suffix = suffix === 'i' || suffix === 'j' ? suffix : '';
+ }
+
+ getRealNum(): number {
+ return this._realNum;
+ }
+
+ getINum(): number {
+ return this._iNum;
+ }
+
+ getSuffix(): string {
+ return this._suffix;
+ }
+
+ isError(): boolean {
+ return this._isError;
+ }
+
+ toString(): number | string {
+ return Complex.getComplex(this._realNum, this._iNum, this._suffix);
+ }
+
+ isDifferentSuffixes(complex2: Complex): boolean {
+ const suffix2 = complex2.getSuffix();
+
+ if (this._suffix === '' || suffix2 === '') {
+ return false;
+ }
+
+ return this._suffix !== suffix2;
+ }
+
+ Abs(): number {
+ const result = Decimal.sqrt(Decimal.pow(this._realNum, 2).add(Decimal.pow(this._iNum, 2))).toSignificantDigits(16).toNumber();
+
+ return result;
+ }
+
+ Argument(): number {
+ const abs = Decimal.sqrt(Decimal.pow(this._realNum, 2).add(Decimal.pow(this._iNum, 2)));
+
+ let result = Decimal.acos(new Decimal(this._realNum).div(abs)).toSignificantDigits(16).toNumber();
+
+ if (this._iNum < 0) {
+ result = -result;
+ }
+
+ return result;
+ }
+
+ Conjugate(): number | string {
+ return Complex.getComplex(this._realNum, -this._iNum, this._suffix);
+ }
+
+ Cos(): number | string {
+ if (this._iNum) {
+ const realNum = Decimal.cos(this._realNum).mul(Decimal.cosh(this._iNum)).toNumber();
+ const iNum = Decimal.sin(this._realNum).mul(Decimal.sinh(this._iNum)).negated().toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = Decimal.cos(this._realNum).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Cosh(): number | string {
+ if (!Number.isFinite(Math.sinh(this._realNum)) || !Number.isFinite(Math.cosh(this._realNum))) {
+ this._isError = true;
+ return '';
+ }
+
+ if (this._iNum) {
+ const realNum = Decimal.cosh(this._realNum).mul(Decimal.cos(this._iNum)).toNumber();
+ const iNum = Decimal.sinh(this._realNum).mul(Decimal.sin(this._iNum)).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = Decimal.cosh(this._realNum).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Cot(): number | string {
+ if (this._iNum) {
+ const den = Decimal.cosh(this._iNum * 2).sub(Decimal.cos(this._realNum * 2));
+ const realNum = Decimal.sin(this._realNum * 2).div(den).toNumber();
+ const iNum = Decimal.sinh(this._iNum * 2).div(den).negated().toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = new Decimal(1).div(Decimal.tan(this._realNum)).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Csc(): number | string {
+ if (this._iNum) {
+ const den = Decimal.cosh(this._iNum * 2).sub(Decimal.cos(this._realNum * 2));
+ const realNum = Decimal.sin(this._realNum).mul(Decimal.cosh(this._iNum)).mul(2).div(den).toNumber();
+ const iNum = Decimal.cos(this._realNum).mul(Decimal.sinh(this._iNum)).mul(-2).div(den).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = new Decimal(1).div(Decimal.sin(this._realNum)).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Csch(): number | string {
+ if (!Number.isFinite(Math.sinh(this._realNum)) || !Number.isFinite(Math.cosh(this._realNum))) {
+ return Complex.getComplex(0, 0, this._suffix);
+ }
+
+ if (this._iNum) {
+ const den = Decimal.cosh(this._realNum * 2).sub(Decimal.cos(this._iNum * 2));
+ const realNum = Decimal.sinh(this._realNum).mul(Decimal.cos(this._iNum)).mul(2).div(den).toNumber();
+ const iNum = Decimal.cosh(this._realNum).mul(Decimal.sin(this._iNum)).mul(-2).div(den).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = new Decimal(1).div(Decimal.sinh(this._realNum)).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Div(complex2: Complex): number | string {
+ const Decimal_realNum1 = new Decimal(this._realNum);
+ const Decimal_iNum1 = new Decimal(this._iNum);
+ const Decimal_realNum2 = new Decimal(complex2.getRealNum());
+ const Decimal_iNum2 = new Decimal(complex2.getINum());
+
+ const den = Decimal_realNum2.mul(Decimal_realNum2).add(Decimal_iNum2.mul(Decimal_iNum2));
+ const realNum = Decimal_realNum1.mul(Decimal_realNum2).add(Decimal_iNum1.mul(Decimal_iNum2)).div(den).toNumber();
+ const iNum = Decimal_iNum1.mul(Decimal_realNum2).sub(Decimal_realNum1.mul(Decimal_iNum2)).div(den).toNumber();
+
+ const suffix = this._suffix === '' ? complex2.getSuffix() : this._suffix;
+
+ return Complex.getComplex(realNum, iNum, suffix);
+ }
+
+ Exp(): number | string {
+ if (!Number.isFinite(Math.exp(this._realNum))) {
+ this._isError = true;
+ return '';
+ }
+
+ const realNum = Decimal.exp(this._realNum).mul(Decimal.cos(this._iNum)).toNumber();
+ const iNum = Decimal.exp(this._realNum).mul(Decimal.sin(this._iNum)).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ }
+
+ Ln(): number | string {
+ const abs = Decimal.sqrt(Decimal.pow(this._realNum, 2).add(Decimal.pow(this._iNum, 2)));
+ const realNum = Decimal.ln(abs).toNumber();
+ const iNum = Decimal.acos(new Decimal(this._realNum).div(abs)).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ }
+
+ Log10(): number | string {
+ const abs = Decimal.sqrt(Decimal.pow(this._realNum, 2).add(Decimal.pow(this._iNum, 2)));
+ const Decimal_realNum1 = Decimal.ln(abs);
+ let Decimal_iNum1 = Decimal.acos(new Decimal(this._realNum).div(abs));
+
+ if (this._iNum < 0) {
+ Decimal_iNum1 = Decimal_iNum1.negated();
+ }
+
+ const Decimal_realNum2 = Decimal.ln(10);
+ const Decimal_iNum2 = new Decimal(0);
+
+ const den = Decimal_realNum2.mul(Decimal_realNum2).add(Decimal_iNum2.mul(Decimal_iNum2));
+ const realNum = Decimal_realNum1.mul(Decimal_realNum2).add(Decimal_iNum1.mul(Decimal_iNum2)).div(den).toNumber();
+ const iNum = Decimal_iNum1.mul(Decimal_realNum2).sub(Decimal_realNum1.mul(Decimal_iNum2)).div(den).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ }
+
+ Log2(): number | string {
+ const abs = Decimal.sqrt(Decimal.pow(this._realNum, 2).add(Decimal.pow(this._iNum, 2)));
+ const Decimal_realNum1 = Decimal.ln(abs);
+ let Decimal_iNum1 = Decimal.acos(new Decimal(this._realNum).div(abs));
+
+ if (this._iNum < 0) {
+ Decimal_iNum1 = Decimal_iNum1.negated();
+ }
+
+ const Decimal_realNum2 = Decimal.ln(2);
+ const Decimal_iNum2 = new Decimal(0);
+
+ const den = Decimal_realNum2.mul(Decimal_realNum2).add(Decimal_iNum2.mul(Decimal_iNum2));
+ const realNum = Decimal_realNum1.mul(Decimal_realNum2).add(Decimal_iNum1.mul(Decimal_iNum2)).div(den).toNumber();
+ const iNum = Decimal_iNum1.mul(Decimal_realNum2).sub(Decimal_realNum1.mul(Decimal_iNum2)).div(den).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ }
+
+ Power(number: number): number | string {
+ if (this._realNum === 0 && this._iNum === 0) {
+ if (number > 0) {
+ return Complex.getComplex(this._realNum, this._iNum, this._suffix);
+ } else {
+ this._isError = true;
+ return '';
+ }
+ }
+
+ let power = Decimal.sqrt(Decimal.pow(this._realNum, 2).add(Decimal.pow(this._iNum, 2)));
+ let phi = Decimal.acos(new Decimal(this._realNum).div(power));
+
+ if (this._iNum < 0) {
+ phi = phi.negated();
+ }
+
+ power = Decimal.pow(power, number);
+ phi = phi.mul(number);
+
+ const realNum = Decimal.cos(phi).mul(power).toNumber();
+ const iNum = Decimal.sin(phi).mul(power).toNumber();
+
+ if (!Number.isFinite(realNum) || !Number.isFinite(iNum)) {
+ this._isError = true;
+ return '';
+ }
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ }
+
+ Product(complex2: Complex): number | string {
+ const Decimal_realNum1 = new Decimal(this._realNum);
+ const Decimal_iNum1 = new Decimal(this._iNum);
+ const Decimal_realNum2 = new Decimal(complex2.getRealNum());
+ const Decimal_iNum2 = new Decimal(complex2.getINum());
+
+ const realNum = Decimal_realNum1.mul(Decimal_realNum2).sub(Decimal_iNum1.mul(Decimal_iNum2)).toNumber();
+ const iNum = Decimal_realNum1.mul(Decimal_iNum2).add(Decimal_iNum1.mul(Decimal_realNum2)).toNumber();
+
+ const suffix = this._suffix === '' ? complex2.getSuffix() : this._suffix;
+
+ return Complex.getComplex(realNum, iNum, suffix);
+ }
+
+ Sec(): number | string {
+ if (this._iNum) {
+ const den = Decimal.cosh(this._iNum * 2).add(Decimal.cos(this._realNum * 2));
+ const realNum = Decimal.cos(this._realNum).mul(Decimal.cosh(this._iNum)).mul(2).div(den).toNumber();
+ const iNum = Decimal.sin(this._realNum).mul(Decimal.sinh(this._iNum)).mul(2).div(den).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = new Decimal(1).div(Decimal.cos(this._realNum)).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Sech(): number | string {
+ if (!Number.isFinite(Math.sinh(this._realNum * 2)) || !Number.isFinite(Math.cosh(this._realNum * 2))) {
+ return Complex.getComplex(0, 0, this._suffix);
+ }
+
+ if (this._iNum) {
+ const den = Decimal.cosh(this._realNum * 2).add(Decimal.cos(this._iNum * 2));
+ const realNum = Decimal.cosh(this._realNum).mul(Decimal.cos(this._iNum)).mul(2).div(den).toNumber();
+ const iNum = Decimal.sinh(this._realNum).mul(Decimal.sin(this._iNum)).mul(-2).div(den).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = new Decimal(1).div(Decimal.cosh(this._realNum)).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Sin(): number | string {
+ if (this._iNum) {
+ const realNum = Decimal.sin(this._realNum).mul(Decimal.cosh(this._iNum)).toNumber();
+ const iNum = Decimal.cos(this._realNum).mul(Decimal.sinh(this._iNum)).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = Decimal.sin(this._realNum).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Sinh(): number | string {
+ if (!Number.isFinite(Math.sinh(this._realNum)) || !Number.isFinite(Math.cosh(this._realNum))) {
+ this._isError = true;
+ return '';
+ }
+
+ if (this._iNum) {
+ const realNum = Decimal.sinh(this._realNum).mul(Decimal.cos(this._iNum)).toNumber();
+ const iNum = Decimal.cosh(this._realNum).mul(Decimal.sin(this._iNum)).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = Decimal.sinh(this._realNum).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+
+ Sqrt(): number | string {
+ const abs = Decimal.sqrt(Decimal.pow(this._realNum, 2).add(Decimal.pow(this._iNum, 2)));
+ const abs_sqrt = Decimal.sqrt(abs);
+
+ let arg = Decimal.acos(new Decimal(this._realNum).div(abs));
+
+ if (this._iNum < 0) {
+ arg = arg.negated();
+ }
+
+ const realNum = abs_sqrt.mul(Decimal.cos(arg.div(2).toNumber())).toNumber();
+ const iNum = abs_sqrt.mul(Decimal.sin(arg.div(2))).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ }
+
+ Sub(complex2: Complex): number | string {
+ const Decimal_realNum1 = new Decimal(this._realNum);
+ const Decimal_iNum1 = new Decimal(this._iNum);
+ const Decimal_realNum2 = new Decimal(complex2.getRealNum());
+ const Decimal_iNum2 = new Decimal(complex2.getINum());
+
+ const realNum = Decimal_realNum1.sub(Decimal_realNum2).toNumber();
+ const iNum = Decimal_iNum1.sub(Decimal_iNum2).toNumber();
+
+ const suffix = this._suffix === '' ? complex2.getSuffix() : this._suffix;
+
+ return Complex.getComplex(realNum, iNum, suffix);
+ }
+
+ Sum(complex2: Complex): number | string {
+ const Decimal_realNum1 = new Decimal(this._realNum);
+ const Decimal_iNum1 = new Decimal(this._iNum);
+ const Decimal_realNum2 = new Decimal(complex2.getRealNum());
+ const Decimal_iNum2 = new Decimal(complex2.getINum());
+
+ const realNum = Decimal_realNum1.add(Decimal_realNum2).toNumber();
+ const iNum = Decimal_iNum1.add(Decimal_iNum2).toNumber();
+
+ const suffix = this._suffix === '' ? complex2.getSuffix() : this._suffix;
+
+ return Complex.getComplex(realNum, iNum, suffix);
+ }
+
+ Tan(): number | string {
+ if (this._iNum) {
+ const den = Decimal.cos(this._realNum * 2).add(Decimal.cosh(this._iNum * 2));
+ const realNum = Decimal.sin(this._realNum * 2).div(den).toNumber();
+ const iNum = Decimal.sinh(this._iNum * 2).div(den).toNumber();
+
+ return Complex.getComplex(realNum, iNum, this._suffix);
+ } else {
+ const realNum = Decimal.tan(this._realNum).toNumber();
+
+ return Complex.getComplex(realNum, this._iNum, this._suffix);
+ }
+ }
+}
diff --git a/packages/engine-formula/src/basics/engineering.ts b/packages/engine-formula/src/basics/engineering.ts
index 11fc73cab2..20c6ef836e 100644
--- a/packages/engine-formula/src/basics/engineering.ts
+++ b/packages/engine-formula/src/basics/engineering.ts
@@ -16,6 +16,10 @@
// eslint-disable-next-line ts/no-namespace
export namespace BESSEL {
+ interface IFunctionType {
+ (x: number): number;
+ }
+
const W = 0.636619772;
function _horner(arr: number[], v: number): number {
@@ -51,8 +55,8 @@ export namespace BESSEL {
return f2;
}
- function _bessel_wrap(bessel0: Function, bessel1: Function, nonzero: number, sign: number) {
- return function bessel(x: number, n: number) {
+ function _bessel_wrap(bessel0: IFunctionType, bessel1: IFunctionType, nonzero: number, sign: number) {
+ return function bessel(x: number, n: number): number {
if (nonzero) {
if (x === 0) {
return nonzero === 1 ? -Infinity : Infinity;
@@ -200,6 +204,11 @@ export namespace BESSEL {
if (j === _n) {
ret = bjp;
}
+
+ // After more than 100 iterations, the result is 0
+ if ((m - j) > 100 && ret === 0) {
+ return Number.NaN;
+ }
}
sum = 2.0 * sum - bj;
@@ -333,6 +342,11 @@ export namespace BESSEL {
}
if (j === _n) ret = bip;
+
+ // After more than 100 iterations, the result is 0
+ if ((m - j) > 100 && ret === 0) {
+ return Number.NaN;
+ }
}
ret *= besseli(x, 0) / bi;
@@ -398,11 +412,11 @@ export function erf(x: number): number {
-2.8e-17];
let _x = x;
- let isneg = false;
+ let isNeg = false;
if (_x < 0) {
_x = -_x;
- isneg = true;
+ isNeg = true;
}
const t = 2 / (2 + _x);
@@ -420,5 +434,5 @@ export function erf(x: number): number {
const res = t * Math.exp(-_x * _x + 0.5 * (cof[0] + ty * d) - dd);
- return isneg ? res - 1 : 1 - res;
+ return isNeg ? res - 1 : 1 - res;
};
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 b06b484013..54ec44620b 100644
--- a/packages/engine-formula/src/engine/value-object/primitive-object.ts
+++ b/packages/engine-formula/src/engine/value-object/primitive-object.ts
@@ -17,7 +17,7 @@
import { isRealNum } from '@univerjs/core';
import { reverseCompareOperator } from '../../basics/calculate';
import { BooleanValue, ConcatenateType } from '../../basics/common';
-import { ERROR_TYPE_SET, ErrorType } from '../../basics/error-type';
+import { ErrorType } from '../../basics/error-type';
import { compareToken, operatorToken } from '../../basics/token';
import { compareWithWildcard, isWildcard } from '../utils/compare';
import { ceil, divide, equals, floor, greaterThan, greaterThanOrEquals, lessThan, lessThanOrEquals, minus, mod, multiply, plus, pow, round, sqrt } from '../utils/math-kit';
@@ -639,114 +639,91 @@ export class NumberValueObject extends BaseValueObject {
}
override plusBy(value: string | number | boolean): BaseValueObject {
- const currentValue = this.getValue();
- if (typeof value === 'string') {
- // = 1 + #NAME? gets #NAME?, = 1 + #VALUE! gets #VALUE!
- if (ERROR_TYPE_SET.has(value as ErrorType)) {
- return ErrorValueObject.create(value as ErrorType);
- }
+ const currentValue = +this.getValue();
+ const _value = +value;
+
+ if (Number.isNaN(currentValue) || Number.isNaN(_value)) {
return ErrorValueObject.create(ErrorType.VALUE);
}
- if (typeof value === 'number') {
- if (!Number.isFinite(currentValue) || !Number.isFinite(value)) {
- return ErrorValueObject.create(ErrorType.NUM);
- }
- const result = plus(currentValue, value);
+ if (!Number.isFinite(currentValue) || !Number.isFinite(_value)) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
- if (!Number.isFinite(result)) {
- return ErrorValueObject.create(ErrorType.NUM);
- }
+ const result = plus(currentValue, _value);
- return NumberValueObject.create(result);
- }
- if (typeof value === 'boolean') {
- return NumberValueObject.create(
- plus(currentValue, value ? 1 : 0)
- );
+ if (!Number.isFinite(result)) {
+ return ErrorValueObject.create(ErrorType.NUM);
}
- return this;
+
+ return NumberValueObject.create(result);
}
override minusBy(value: string | number | boolean): BaseValueObject {
- const currentValue = this.getValue();
- if (typeof value === 'string') {
+ const currentValue = +this.getValue();
+ const _value = +value;
+
+ if (Number.isNaN(currentValue) || Number.isNaN(_value)) {
return ErrorValueObject.create(ErrorType.VALUE);
}
- if (typeof value === 'number') {
- if (!Number.isFinite(currentValue) || !Number.isFinite(value)) {
- return ErrorValueObject.create(ErrorType.NUM);
- }
- const result = minus(currentValue, value);
+ if (!Number.isFinite(currentValue) || !Number.isFinite(_value)) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
- if (!Number.isFinite(result)) {
- return ErrorValueObject.create(ErrorType.NUM);
- }
+ const result = minus(currentValue, _value);
- return NumberValueObject.create(result);
- }
- if (typeof value === 'boolean') {
- return NumberValueObject.create(
- minus(currentValue, value ? 1 : 0)
- );
+ if (!Number.isFinite(result)) {
+ return ErrorValueObject.create(ErrorType.NUM);
}
- return this;
+
+ return NumberValueObject.create(result);
}
override multiplyBy(value: string | number | boolean): BaseValueObject {
- const currentValue = this.getValue();
- if (typeof value === 'string') {
+ const currentValue = +this.getValue();
+ const _value = +value;
+
+ if (Number.isNaN(currentValue) || Number.isNaN(_value)) {
return ErrorValueObject.create(ErrorType.VALUE);
}
- if (typeof value === 'number') {
- if (!Number.isFinite(currentValue) || !Number.isFinite(value)) {
- return ErrorValueObject.create(ErrorType.NUM);
- }
- const result = multiply(currentValue, value);
-
- if (!Number.isFinite(result)) {
- return ErrorValueObject.create(ErrorType.NUM);
- }
- return NumberValueObject.create(result);
+ if (!Number.isFinite(currentValue) || !Number.isFinite(_value)) {
+ return ErrorValueObject.create(ErrorType.NUM);
}
- if (typeof value === 'boolean') {
- return NumberValueObject.create(
- multiply(currentValue, value ? 1 : 0)
- );
+
+ const result = multiply(currentValue, _value);
+
+ if (!Number.isFinite(result)) {
+ return ErrorValueObject.create(ErrorType.NUM);
}
- return this;
+
+ return NumberValueObject.create(result);
}
override dividedBy(value: string | number | boolean): BaseValueObject {
- const currentValue = this.getValue();
- if (typeof value === 'string') {
+ const currentValue = +this.getValue();
+ const _value = +value;
+
+ if (Number.isNaN(currentValue) || Number.isNaN(_value)) {
return ErrorValueObject.create(ErrorType.VALUE);
}
- if (typeof value === 'number') {
- if (value === 0) {
- return ErrorValueObject.create(ErrorType.DIV_BY_ZERO);
- }
- if (!Number.isFinite(currentValue) || !Number.isFinite(value)) {
- return ErrorValueObject.create(ErrorType.NUM);
- }
-
- const result = divide(currentValue, value);
- if (!Number.isFinite(result)) {
- return ErrorValueObject.create(ErrorType.NUM);
- }
+ if (!Number.isFinite(currentValue) || !Number.isFinite(_value)) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
- return NumberValueObject.create(result);
+ if (_value === 0) {
+ return ErrorValueObject.create(ErrorType.DIV_BY_ZERO);
}
- if (typeof value === 'boolean') {
- if (value === false) {
- return ErrorValueObject.create(ErrorType.DIV_BY_ZERO);
- }
- return NumberValueObject.create(divide(currentValue, 1));
+
+ const result = divide(currentValue, _value);
+
+ if (!Number.isFinite(result)) {
+ return ErrorValueObject.create(ErrorType.NUM);
}
- return this;
+
+ return NumberValueObject.create(result);
}
override compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject {
@@ -1352,6 +1329,22 @@ export class StringValueObject extends BaseValueObject {
return StringValueObject.create(this.concatenate(valueObject.getValue(), ConcatenateType.BACK));
}
+ override plus(valueObject: BaseValueObject): BaseValueObject {
+ return this.convertToNumberObjectValue().plus(valueObject);
+ }
+
+ override minus(valueObject: BaseValueObject): BaseValueObject {
+ return this.convertToNumberObjectValue().minus(valueObject);
+ }
+
+ override multiply(valueObject: BaseValueObject): BaseValueObject {
+ return this.convertToNumberObjectValue().multiply(valueObject);
+ }
+
+ override divided(valueObject: BaseValueObject): BaseValueObject {
+ return this.convertToNumberObjectValue().divided(valueObject);
+ }
+
override compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): BaseValueObject {
if (valueObject.isArray()) {
// const o = valueObject.getReciprocal();
diff --git a/packages/engine-formula/src/functions/engineering/besseli/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/besseli/__tests__/index.spec.ts
index 69bf17fce3..d1ad050c97 100644
--- a/packages/engine-formula/src/functions/engineering/besseli/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/besseli/__tests__/index.spec.ts
@@ -34,6 +34,18 @@ describe('Test besseli function', () => {
expect(result.getValue()).toBe(0.981666428475166);
});
+ it('n < 0 || x === Infinity', () => {
+ const x = NumberValueObject.create(1.5);
+ const n = NumberValueObject.create(-1);
+ const result = testFunction.calculate(x, n);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const x2 = NumberValueObject.create(Infinity);
+ const n2 = NumberValueObject.create(1);
+ const result2 = testFunction.calculate(x2, n2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+ });
+
it('Value is number string', () => {
const x = StringValueObject.create('-0.5');
const n = NumberValueObject.create(1);
diff --git a/packages/engine-formula/src/functions/engineering/besseli/index.ts b/packages/engine-formula/src/functions/engineering/besseli/index.ts
index f7671ee5d3..148474d6a9 100644
--- a/packages/engine-formula/src/functions/engineering/besseli/index.ts
+++ b/packages/engine-formula/src/functions/engineering/besseli/index.ts
@@ -26,7 +26,7 @@ export class Besseli extends BaseFunction {
override maxParams = 2;
- override calculate(x: BaseValueObject, n: BaseValueObject) {
+ override calculate(x: BaseValueObject, n: BaseValueObject): BaseValueObject {
if (x.isNull() || n.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/besselj/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/besselj/__tests__/index.spec.ts
index c6bcdd401b..34c6c3a9e3 100644
--- a/packages/engine-formula/src/functions/engineering/besselj/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/besselj/__tests__/index.spec.ts
@@ -34,6 +34,18 @@ describe('Test besselj function', () => {
expect(result.getValue()).toBe(0.5579365078908043);
});
+ it('n < 0 || result === NaN', () => {
+ const x = NumberValueObject.create(1.5);
+ const n = NumberValueObject.create(-1);
+ const result = testFunction.calculate(x, n);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const x2 = NumberValueObject.create(2);
+ const n2 = NumberValueObject.create(222);
+ const result2 = testFunction.calculate(x2, n2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+ });
+
it('Value is number string', () => {
const x = StringValueObject.create('-0.5');
const n = NumberValueObject.create(1);
diff --git a/packages/engine-formula/src/functions/engineering/besselj/index.ts b/packages/engine-formula/src/functions/engineering/besselj/index.ts
index 0ada8235c5..18f5a1f2e2 100644
--- a/packages/engine-formula/src/functions/engineering/besselj/index.ts
+++ b/packages/engine-formula/src/functions/engineering/besselj/index.ts
@@ -26,7 +26,7 @@ export class Besselj extends BaseFunction {
override maxParams = 2;
- override calculate(x: BaseValueObject, n: BaseValueObject) {
+ override calculate(x: BaseValueObject, n: BaseValueObject): BaseValueObject {
if (x.isNull() || n.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/besselk/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/besselk/__tests__/index.spec.ts
index 2bb7382c45..54ec027ca4 100644
--- a/packages/engine-formula/src/functions/engineering/besselk/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/besselk/__tests__/index.spec.ts
@@ -34,6 +34,13 @@ describe('Test besselk function', () => {
expect(result.getValue()).toBe(0.2773878036322587);
});
+ it('n < 0', () => {
+ const x = NumberValueObject.create(1.5);
+ const n = NumberValueObject.create(-1);
+ const result = testFunction.calculate(x, n);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
it('Value is number string', () => {
const x = StringValueObject.create('-0.5');
const n = NumberValueObject.create(1);
diff --git a/packages/engine-formula/src/functions/engineering/besselk/index.ts b/packages/engine-formula/src/functions/engineering/besselk/index.ts
index fb8ea2c0c2..6b9383a9ae 100644
--- a/packages/engine-formula/src/functions/engineering/besselk/index.ts
+++ b/packages/engine-formula/src/functions/engineering/besselk/index.ts
@@ -26,7 +26,7 @@ export class Besselk extends BaseFunction {
override maxParams = 2;
- override calculate(x: BaseValueObject, n: BaseValueObject) {
+ override calculate(x: BaseValueObject, n: BaseValueObject): BaseValueObject {
if (x.isNull() || n.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/bessely/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bessely/__tests__/index.spec.ts
index 36ca99bd73..917d90188a 100644
--- a/packages/engine-formula/src/functions/engineering/bessely/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bessely/__tests__/index.spec.ts
@@ -34,6 +34,13 @@ describe('Test bessely function', () => {
expect(result.getValue()).toBe(-0.41230862689590375);
});
+ it('n < 0', () => {
+ const x = NumberValueObject.create(1.5);
+ const n = NumberValueObject.create(-1);
+ const result = testFunction.calculate(x, n);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
it('Value is number string', () => {
const x = StringValueObject.create('-0.5');
const n = NumberValueObject.create(1);
diff --git a/packages/engine-formula/src/functions/engineering/bessely/index.ts b/packages/engine-formula/src/functions/engineering/bessely/index.ts
index e976f5a858..bc2e960972 100644
--- a/packages/engine-formula/src/functions/engineering/bessely/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bessely/index.ts
@@ -26,7 +26,7 @@ export class Bessely extends BaseFunction {
override maxParams = 2;
- override calculate(x: BaseValueObject, n: BaseValueObject) {
+ override calculate(x: BaseValueObject, n: BaseValueObject): BaseValueObject {
if (x.isNull() || n.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/bin2dec/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bin2dec/__tests__/index.spec.ts
index 746d5b33fb..83388efbaa 100644
--- a/packages/engine-formula/src/functions/engineering/bin2dec/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bin2dec/__tests__/index.spec.ts
@@ -33,6 +33,12 @@ describe('Test bin2dec function', () => {
expect(result.getValue()).toBe(100);
});
+ it('Number length is 10', () => {
+ const number = NumberValueObject.create(1100100000);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(-224);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const result = testFunction.calculate(number);
diff --git a/packages/engine-formula/src/functions/engineering/bin2dec/index.ts b/packages/engine-formula/src/functions/engineering/bin2dec/index.ts
index c28ab1d958..c912997d06 100644
--- a/packages/engine-formula/src/functions/engineering/bin2dec/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bin2dec/index.ts
@@ -26,7 +26,7 @@ export class Bin2dec extends BaseFunction {
override maxParams = 1;
- override calculate(number: BaseValueObject) {
+ override calculate(number: BaseValueObject): BaseValueObject {
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);
if (isError) {
diff --git a/packages/engine-formula/src/functions/engineering/bin2hex/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bin2hex/__tests__/index.spec.ts
index 2409835169..667fbff5de 100644
--- a/packages/engine-formula/src/functions/engineering/bin2hex/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bin2hex/__tests__/index.spec.ts
@@ -34,6 +34,31 @@ describe('Test bin2hex function', () => {
expect(result.getValue()).toBe('00FB');
});
+ it('Number length is 10', () => {
+ const number = NumberValueObject.create(1100100000);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe('FFFFFFFF20');
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(11111011);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(4);
diff --git a/packages/engine-formula/src/functions/engineering/bin2hex/index.ts b/packages/engine-formula/src/functions/engineering/bin2hex/index.ts
index 15d64e0a40..d3f4cb4772 100644
--- a/packages/engine-formula/src/functions/engineering/bin2hex/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bin2hex/index.ts
@@ -26,7 +26,7 @@ export class Bin2hex extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/bin2oct/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bin2oct/__tests__/index.spec.ts
index ee5a3f4269..541d3339c3 100644
--- a/packages/engine-formula/src/functions/engineering/bin2oct/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bin2oct/__tests__/index.spec.ts
@@ -34,6 +34,31 @@ describe('Test bin2oct function', () => {
expect(result.getValue()).toBe('011');
});
+ it('Number length is 10', () => {
+ const number = NumberValueObject.create(1100100000);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe('7777777440');
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(11111011);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(3);
diff --git a/packages/engine-formula/src/functions/engineering/bin2oct/index.ts b/packages/engine-formula/src/functions/engineering/bin2oct/index.ts
index 29f8bc05d3..3ee715fcdf 100644
--- a/packages/engine-formula/src/functions/engineering/bin2oct/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bin2oct/index.ts
@@ -26,7 +26,7 @@ export class Bin2oct extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/bitand/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bitand/__tests__/index.spec.ts
index 64f65e4bc7..57ff6e93bb 100644
--- a/packages/engine-formula/src/functions/engineering/bitand/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bitand/__tests__/index.spec.ts
@@ -46,6 +46,11 @@ describe('Test bitand function', () => {
const number2 = NumberValueObject.create(25);
const result = testFunction.calculate(number1, number2);
expect(result.getValue()).toBe(ErrorType.VALUE);
+
+ const number3 = NumberValueObject.create(13);
+ const number4 = StringValueObject.create('test');
+ const result2 = testFunction.calculate(number3, number4);
+ expect(result2.getValue()).toBe(ErrorType.VALUE);
});
it('Value is boolean', () => {
@@ -67,6 +72,11 @@ describe('Test bitand function', () => {
const number2 = NumberValueObject.create(25);
const result = testFunction.calculate(number1, number2);
expect(result.getValue()).toBe(ErrorType.NAME);
+
+ const number3 = NumberValueObject.create(13);
+ const number4 = ErrorValueObject.create(ErrorType.NAME);
+ const result2 = testFunction.calculate(number3, number4);
+ expect(result2.getValue()).toBe(ErrorType.NAME);
});
it('Value is array', () => {
diff --git a/packages/engine-formula/src/functions/engineering/bitand/index.ts b/packages/engine-formula/src/functions/engineering/bitand/index.ts
index 42f7f124c0..40ec6641ae 100644
--- a/packages/engine-formula/src/functions/engineering/bitand/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bitand/index.ts
@@ -26,7 +26,7 @@ export class Bitand extends BaseFunction {
override maxParams = 2;
- override calculate(number1: BaseValueObject, number2: BaseValueObject) {
+ override calculate(number1: BaseValueObject, number2: BaseValueObject): BaseValueObject {
if (number1.isError()) {
return number1;
}
diff --git a/packages/engine-formula/src/functions/engineering/bitlshift/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bitlshift/__tests__/index.spec.ts
index 8aa1100b5f..7f3e61a32c 100644
--- a/packages/engine-formula/src/functions/engineering/bitlshift/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bitlshift/__tests__/index.spec.ts
@@ -46,6 +46,11 @@ describe('Test bitlshift function', () => {
const shiftAmount = NumberValueObject.create(2);
const result = testFunction.calculate(number, shiftAmount);
expect(result.getValue()).toBe(ErrorType.VALUE);
+
+ const number2 = NumberValueObject.create(4);
+ const shiftAmount2 = StringValueObject.create('test');
+ const result2 = testFunction.calculate(number2, shiftAmount2);
+ expect(result2.getValue()).toBe(ErrorType.VALUE);
});
it('Value is boolean', () => {
@@ -67,6 +72,18 @@ describe('Test bitlshift function', () => {
const shiftAmount = NumberValueObject.create(2);
const result = testFunction.calculate(number, shiftAmount);
expect(result.getValue()).toBe(ErrorType.NAME);
+
+ const number2 = NumberValueObject.create(4);
+ const shiftAmount2 = ErrorValueObject.create(ErrorType.NAME);
+ const result2 = testFunction.calculate(number2, shiftAmount2);
+ expect(result2.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Result > 281474976710655', () => {
+ const number = NumberValueObject.create(2);
+ const shiftAmount = NumberValueObject.create(52);
+ const result = testFunction.calculate(number, shiftAmount);
+ expect(result.getValue()).toBe(ErrorType.NUM);
});
it('Value is array', () => {
diff --git a/packages/engine-formula/src/functions/engineering/bitlshift/index.ts b/packages/engine-formula/src/functions/engineering/bitlshift/index.ts
index 2367eb3d43..9996136df8 100644
--- a/packages/engine-formula/src/functions/engineering/bitlshift/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bitlshift/index.ts
@@ -26,7 +26,7 @@ export class Bitlshift extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, shiftAmount: BaseValueObject) {
+ override calculate(number: BaseValueObject, shiftAmount: BaseValueObject): BaseValueObject {
if (number.isError()) {
return number;
}
diff --git a/packages/engine-formula/src/functions/engineering/bitor/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bitor/__tests__/index.spec.ts
index 50170542f1..7498414d89 100644
--- a/packages/engine-formula/src/functions/engineering/bitor/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bitor/__tests__/index.spec.ts
@@ -46,6 +46,11 @@ describe('Test bitor function', () => {
const number2 = NumberValueObject.create(10);
const result = testFunction.calculate(number1, number2);
expect(result.getValue()).toBe(ErrorType.VALUE);
+
+ const number3 = NumberValueObject.create(23);
+ const number4 = StringValueObject.create('test');
+ const result2 = testFunction.calculate(number3, number4);
+ expect(result2.getValue()).toBe(ErrorType.VALUE);
});
it('Value is boolean', () => {
@@ -67,6 +72,11 @@ describe('Test bitor function', () => {
const number2 = NumberValueObject.create(10);
const result = testFunction.calculate(number1, number2);
expect(result.getValue()).toBe(ErrorType.NAME);
+
+ const number3 = NumberValueObject.create(23);
+ const number4 = ErrorValueObject.create(ErrorType.NAME);
+ const result2 = testFunction.calculate(number3, number4);
+ expect(result2.getValue()).toBe(ErrorType.NAME);
});
it('Value is array', () => {
diff --git a/packages/engine-formula/src/functions/engineering/bitor/index.ts b/packages/engine-formula/src/functions/engineering/bitor/index.ts
index b8ff50ef6c..0d2ba8fceb 100644
--- a/packages/engine-formula/src/functions/engineering/bitor/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bitor/index.ts
@@ -26,7 +26,7 @@ export class Bitor extends BaseFunction {
override maxParams = 2;
- override calculate(number1: BaseValueObject, number2: BaseValueObject) {
+ override calculate(number1: BaseValueObject, number2: BaseValueObject): BaseValueObject {
if (number1.isError()) {
return number1;
}
diff --git a/packages/engine-formula/src/functions/engineering/bitrshift/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bitrshift/__tests__/index.spec.ts
index 7bc7ecf94a..5a4a58c1b3 100644
--- a/packages/engine-formula/src/functions/engineering/bitrshift/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bitrshift/__tests__/index.spec.ts
@@ -46,6 +46,11 @@ describe('Test bitrshift function', () => {
const shiftAmount = NumberValueObject.create(2);
const result = testFunction.calculate(number, shiftAmount);
expect(result.getValue()).toBe(ErrorType.VALUE);
+
+ const number2 = NumberValueObject.create(13);
+ const shiftAmount2 = StringValueObject.create('test');
+ const result2 = testFunction.calculate(number2, shiftAmount2);
+ expect(result2.getValue()).toBe(ErrorType.VALUE);
});
it('Value is boolean', () => {
@@ -67,6 +72,18 @@ describe('Test bitrshift function', () => {
const shiftAmount = NumberValueObject.create(2);
const result = testFunction.calculate(number, shiftAmount);
expect(result.getValue()).toBe(ErrorType.NAME);
+
+ const number2 = NumberValueObject.create(13);
+ const shiftAmount2 = ErrorValueObject.create(ErrorType.NAME);
+ const result2 = testFunction.calculate(number2, shiftAmount2);
+ expect(result2.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Result > 281474976710655', () => {
+ const number = NumberValueObject.create(2);
+ const shiftAmount = NumberValueObject.create(-52);
+ const result = testFunction.calculate(number, shiftAmount);
+ expect(result.getValue()).toBe(ErrorType.NUM);
});
it('Value is array', () => {
diff --git a/packages/engine-formula/src/functions/engineering/bitrshift/index.ts b/packages/engine-formula/src/functions/engineering/bitrshift/index.ts
index cec017558d..e9d54545ef 100644
--- a/packages/engine-formula/src/functions/engineering/bitrshift/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bitrshift/index.ts
@@ -26,7 +26,7 @@ export class Bitrshift extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, shiftAmount: BaseValueObject) {
+ override calculate(number: BaseValueObject, shiftAmount: BaseValueObject): BaseValueObject {
if (number.isError()) {
return number;
}
diff --git a/packages/engine-formula/src/functions/engineering/bitxor/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/bitxor/__tests__/index.spec.ts
index b4b2a34b82..10cbbe0a91 100644
--- a/packages/engine-formula/src/functions/engineering/bitxor/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/bitxor/__tests__/index.spec.ts
@@ -46,6 +46,11 @@ describe('Test bitxor function', () => {
const number2 = NumberValueObject.create(3);
const result = testFunction.calculate(number1, number2);
expect(result.getValue()).toBe(ErrorType.VALUE);
+
+ const number3 = NumberValueObject.create(5);
+ const number4 = StringValueObject.create('test');
+ const result2 = testFunction.calculate(number3, number4);
+ expect(result2.getValue()).toBe(ErrorType.VALUE);
});
it('Value is boolean', () => {
@@ -67,6 +72,11 @@ describe('Test bitxor function', () => {
const number2 = NumberValueObject.create(3);
const result = testFunction.calculate(number1, number2);
expect(result.getValue()).toBe(ErrorType.NAME);
+
+ const number3 = NumberValueObject.create(5);
+ const number4 = ErrorValueObject.create(ErrorType.NAME);
+ const result2 = testFunction.calculate(number3, number4);
+ expect(result2.getValue()).toBe(ErrorType.NAME);
});
it('Value is array', () => {
diff --git a/packages/engine-formula/src/functions/engineering/bitxor/index.ts b/packages/engine-formula/src/functions/engineering/bitxor/index.ts
index 8eaeb0dd75..ed49cc0f4d 100644
--- a/packages/engine-formula/src/functions/engineering/bitxor/index.ts
+++ b/packages/engine-formula/src/functions/engineering/bitxor/index.ts
@@ -26,7 +26,7 @@ export class Bitxor extends BaseFunction {
override maxParams = 2;
- override calculate(number1: BaseValueObject, number2: BaseValueObject) {
+ override calculate(number1: BaseValueObject, number2: BaseValueObject): BaseValueObject {
if (number1.isError()) {
return number1;
}
diff --git a/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts
index b17217f4db..bd4400061f 100644
--- a/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts
@@ -33,6 +33,10 @@ describe('Test complex function', () => {
const suffix = StringValueObject.create('i');
const result = testFunction.calculate(realNum, iNum, suffix);
expect(result.getValue()).toBe('3+4i');
+
+ const iNum2 = NumberValueObject.create(0);
+ const result2 = testFunction.calculate(realNum, iNum2, suffix);
+ expect(result2.getValue()).toBe(3);
});
it('Value is number string', () => {
diff --git a/packages/engine-formula/src/functions/engineering/complex/index.ts b/packages/engine-formula/src/functions/engineering/complex/index.ts
index a397258729..3f69d4e4dc 100644
--- a/packages/engine-formula/src/functions/engineering/complex/index.ts
+++ b/packages/engine-formula/src/functions/engineering/complex/index.ts
@@ -19,13 +19,14 @@ import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-ob
import { BaseFunction } from '../../base-function';
import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex as COMPLEX } from '../../../basics/complex';
export class Complex extends BaseFunction {
override minParams = 2;
override maxParams = 3;
- override calculate(realNum: BaseValueObject, iNum: BaseValueObject, suffix?: BaseValueObject) {
+ override calculate(realNum: BaseValueObject, iNum: BaseValueObject, suffix?: BaseValueObject): BaseValueObject {
const _suffix = suffix ?? StringValueObject.create('i');
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(realNum, iNum, _suffix);
@@ -48,25 +49,12 @@ export class Complex extends BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
- if (realNumValue === 0 && iNumValue === 0) {
- return NumberValueObject.create(0);
- }
-
- if (realNumValue === 0) {
- if (iNumValue === 1) {
- return StringValueObject.create(suffixValue);
- }
+ const result = COMPLEX.getComplex(realNumValue, iNumValue, suffixValue);
- return StringValueObject.create(`${iNumValue}${suffixValue}`);
+ if (typeof result === 'number') {
+ return NumberValueObject.create(result);
}
- if (iNumValue === 0) {
- return NumberValueObject.create(realNumValue);
- }
-
- const sign = iNumValue > 0 ? '+' : '';
- const suffixStr = iNumValue === 1 ? suffixValue : `${iNumValue}${suffixValue}`;
-
- return StringValueObject.create(`${realNumValue}${sign}${suffixStr}`);
+ return StringValueObject.create(result);
}
}
diff --git a/packages/engine-formula/src/functions/engineering/convert/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/convert/__tests__/index.spec.ts
index 6ec66e9709..3d098c3f2c 100644
--- a/packages/engine-formula/src/functions/engineering/convert/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/convert/__tests__/index.spec.ts
@@ -101,5 +101,177 @@ describe('Test convert function', () => {
const result = testFunction.calculate(number, fromUnit, toUnit);
expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
});
+
+ it('Value with binary prefix', () => {
+ const number = NumberValueObject.create(1);
+ const fromUnit = StringValueObject.create('KiB');
+ const toUnit = StringValueObject.create('bytes');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(ErrorType.NA);
+ });
+
+ it('Value with unit prefix', () => {
+ const number = NumberValueObject.create(1);
+ const fromUnit = StringValueObject.create('km');
+ const toUnit = StringValueObject.create('m');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(1000);
+ });
+
+ it('Temperature conversion C test', () => {
+ const number = NumberValueObject.create(0);
+ const fromUnit = StringValueObject.create('C');
+ let toUnit = StringValueObject.create('F');
+ let result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(32);
+
+ toUnit = StringValueObject.create('K');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(273.15);
+
+ toUnit = StringValueObject.create('Rank');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(491.67);
+
+ toUnit = StringValueObject.create('Reau');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+ });
+
+ it('Temperature conversion F test', () => {
+ const number = NumberValueObject.create(32);
+ const fromUnit = StringValueObject.create('F');
+ let toUnit = StringValueObject.create('C');
+ let result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+
+ toUnit = StringValueObject.create('K');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(273.15);
+
+ toUnit = StringValueObject.create('Rank');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(491.67);
+
+ toUnit = StringValueObject.create('Reau');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+ });
+
+ it('Temperature conversion K test', () => {
+ const number = NumberValueObject.create(273.15);
+ const fromUnit = StringValueObject.create('K');
+ let toUnit = StringValueObject.create('C');
+ let result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+
+ toUnit = StringValueObject.create('F');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(32);
+
+ toUnit = StringValueObject.create('Rank');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(491.67);
+
+ toUnit = StringValueObject.create('Reau');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+ });
+
+ it('Temperature conversion Rank test', () => {
+ const number = NumberValueObject.create(491.67);
+ const fromUnit = StringValueObject.create('Rank');
+ let toUnit = StringValueObject.create('C');
+ let result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+
+ toUnit = StringValueObject.create('F');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(32);
+
+ toUnit = StringValueObject.create('K');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(273.15);
+
+ toUnit = StringValueObject.create('Reau');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+ });
+
+ it('Temperature conversion Reau test', () => {
+ const number = NumberValueObject.create(0);
+ const fromUnit = StringValueObject.create('Reau');
+ let toUnit = StringValueObject.create('C');
+ let result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+
+ toUnit = StringValueObject.create('F');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(32);
+
+ toUnit = StringValueObject.create('K');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(273.15);
+
+ toUnit = StringValueObject.create('Rank');
+ result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(491.67);
+ });
+
+ it('Source unit does not exist', () => {
+ const number = NumberValueObject.create(1);
+ const fromUnit = StringValueObject.create('unknown');
+ const toUnit = StringValueObject.create('m');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(ErrorType.NA);
+ });
+
+ it('Target unit does not exist', () => {
+ const number = NumberValueObject.create(1);
+ const fromUnit = StringValueObject.create('m');
+ const toUnit = StringValueObject.create('unknown');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(ErrorType.NA);
+ });
+
+ it('Conversion with precision', () => {
+ const number = NumberValueObject.create(1);
+ const fromUnit = StringValueObject.create('inch');
+ const toUnit = StringValueObject.create('cm');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(ErrorType.NA);
+ });
+
+ it('Extreme large number conversion', () => {
+ const number = NumberValueObject.create(1e21);
+ const fromUnit = StringValueObject.create('m');
+ const toUnit = StringValueObject.create('km');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(1e18);
+ });
+
+ it('Extreme small number conversion', () => {
+ const number = NumberValueObject.create(1e-21);
+ const fromUnit = StringValueObject.create('m');
+ const toUnit = StringValueObject.create('km');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(1e-24);
+ });
+
+ it('Unit with alternate symbols', () => {
+ const number = NumberValueObject.create(1);
+ const fromUnit = StringValueObject.create('mph');
+ const toUnit = StringValueObject.create('km/h');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(1.609343999999987);
+ });
+
+ it('Null number input', () => {
+ const number = NullValueObject.create();
+ const fromUnit = StringValueObject.create('lbm');
+ const toUnit = StringValueObject.create('kg');
+ const result = testFunction.calculate(number, fromUnit, toUnit);
+ expect(result.getValue()).toStrictEqual(0);
+ });
});
});
diff --git a/packages/engine-formula/src/functions/engineering/convert/index.ts b/packages/engine-formula/src/functions/engineering/convert/index.ts
index 78e227123c..db20bdc9f8 100644
--- a/packages/engine-formula/src/functions/engineering/convert/index.ts
+++ b/packages/engine-formula/src/functions/engineering/convert/index.ts
@@ -22,6 +22,22 @@ import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-
type IUnitItem = Array<string | Array<string> | number | boolean | null>;
+interface IFrom {
+ _from: IUnitItem | null;
+}
+
+interface ITo {
+ _to: IUnitItem | null;
+}
+
+interface IFromMultiplier extends IFrom {
+ _fromMultiplier: number;
+}
+
+interface IToMultiplier extends ITo {
+ _toMultiplier: number;
+}
+
interface IPrefixesKey {
[index: string]: Array<string | number>;
}
@@ -31,7 +47,7 @@ export class Convert extends BaseFunction {
override maxParams = 3;
- override calculate(number: BaseValueObject, fromUnit: BaseValueObject, toUnit: BaseValueObject) {
+ override calculate(number: BaseValueObject, fromUnit: BaseValueObject, toUnit: BaseValueObject): BaseValueObject {
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number, fromUnit, toUnit);
if (isError) {
@@ -89,6 +105,7 @@ export class Convert extends BaseFunction {
if (from[3] === 'temperature') {
result = this._getTemperatureConversion(numberValue, from[1] as string, to[1] as string);
+ result = +result.toFixed(2);
} else {
result = (numberValue * (from[6] as number) * fromMultiplier) / ((to[6] as number) * toMultiplier);
}
@@ -96,7 +113,7 @@ export class Convert extends BaseFunction {
return NumberValueObject.create(result);
}
- private _lookupFromAndToUnits(fromUnitValue: string, toUnitValue: string) {
+ private _lookupFromAndToUnits(fromUnitValue: string, toUnitValue: string): IFrom & ITo {
let _from = null;
let _to = null;
let alt;
@@ -119,7 +136,7 @@ export class Convert extends BaseFunction {
};
}
- private _lookupFromPrefix(fromUnitValue: string) {
+ private _lookupFromPrefix(fromUnitValue: string): IFromMultiplier {
let _from = null;
let _fromMultiplier = 1;
let baseFromUnit = fromUnitValue;
@@ -157,7 +174,7 @@ export class Convert extends BaseFunction {
};
}
- private _lookupToPrefix(toUnitValue: string) {
+ private _lookupToPrefix(toUnitValue: string): IToMultiplier {
let _to = null;
let _toMultiplier = 1;
let baseToUnit = toUnitValue;
@@ -195,7 +212,7 @@ export class Convert extends BaseFunction {
};
}
- private _getTemperatureConversion(number: number, from: string, to: string) {
+ private _getTemperatureConversion(number: number, from: string, to: string): number {
switch (from) {
case 'C':
return this._centigradeConversion(number, to);
@@ -212,7 +229,7 @@ export class Convert extends BaseFunction {
}
}
- private _centigradeConversion(number: number, to: string) {
+ private _centigradeConversion(number: number, to: string): number {
switch (to) {
case 'F':
return (number * 9 / 5) + 32;
@@ -227,7 +244,7 @@ export class Convert extends BaseFunction {
}
}
- private _fahrenheitConversion(number: number, to: string) {
+ private _fahrenheitConversion(number: number, to: string): number {
switch (to) {
case 'C':
return (number - 32) * 5 / 9;
@@ -242,7 +259,7 @@ export class Convert extends BaseFunction {
}
}
- private _kelvinConversion(number: number, to: string) {
+ private _kelvinConversion(number: number, to: string): number {
switch (to) {
case 'C':
return number - 273.15;
@@ -257,7 +274,7 @@ export class Convert extends BaseFunction {
}
}
- private _rankineConversion(number: number, to: string) {
+ private _rankineConversion(number: number, to: string): number {
switch (to) {
case 'C':
return (number - 491.67) * 5 / 9;
@@ -272,7 +289,7 @@ export class Convert extends BaseFunction {
}
}
- private _reaumurConversion(number: number, to: string) {
+ private _reaumurConversion(number: number, to: string): number {
switch (to) {
case 'C':
return number * 5 / 4;
diff --git a/packages/engine-formula/src/functions/engineering/dec2bin/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/dec2bin/__tests__/index.spec.ts
index 7a0ee83054..815039f71d 100644
--- a/packages/engine-formula/src/functions/engineering/dec2bin/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/dec2bin/__tests__/index.spec.ts
@@ -34,6 +34,35 @@ describe('Test dec2bin function', () => {
expect(result.getValue()).toBe('1001');
});
+ it('Number < -512 || > 512 || < 0', () => {
+ const number = NumberValueObject.create(1100100000);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const number2 = NumberValueObject.create(-22);
+ const result2 = testFunction.calculate(number2);
+ expect(result2.getValue()).toBe('1111101010');
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(22);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(4);
diff --git a/packages/engine-formula/src/functions/engineering/dec2bin/index.ts b/packages/engine-formula/src/functions/engineering/dec2bin/index.ts
index e6001d327a..9f9845c900 100644
--- a/packages/engine-formula/src/functions/engineering/dec2bin/index.ts
+++ b/packages/engine-formula/src/functions/engineering/dec2bin/index.ts
@@ -25,7 +25,7 @@ export class Dec2bin extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/dec2hex/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/dec2hex/__tests__/index.spec.ts
index 6d9ffae5b2..98c51f625a 100644
--- a/packages/engine-formula/src/functions/engineering/dec2hex/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/dec2hex/__tests__/index.spec.ts
@@ -34,6 +34,35 @@ describe('Test dec2hex function', () => {
expect(result.getValue()).toBe('0064');
});
+ it('Number < -549755813888 || > 549755813887 || < 0', () => {
+ const number = NumberValueObject.create(549755813889);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const number2 = NumberValueObject.create(-22);
+ const result2 = testFunction.calculate(number2);
+ expect(result2.getValue()).toBe('FFFFFFFFEA');
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(22);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(4);
diff --git a/packages/engine-formula/src/functions/engineering/dec2hex/index.ts b/packages/engine-formula/src/functions/engineering/dec2hex/index.ts
index 75bb941a35..ddccf537c4 100644
--- a/packages/engine-formula/src/functions/engineering/dec2hex/index.ts
+++ b/packages/engine-formula/src/functions/engineering/dec2hex/index.ts
@@ -25,7 +25,7 @@ export class Dec2hex extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/dec2oct/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/dec2oct/__tests__/index.spec.ts
index e6a405aeff..bb9bea0801 100644
--- a/packages/engine-formula/src/functions/engineering/dec2oct/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/dec2oct/__tests__/index.spec.ts
@@ -34,6 +34,35 @@ describe('Test Dec2oct function', () => {
expect(result.getValue()).toBe('072');
});
+ it('Number < -536870912 || > 536870911 || < 0', () => {
+ const number = NumberValueObject.create(536870913);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const number2 = NumberValueObject.create(-22);
+ const result2 = testFunction.calculate(number2);
+ expect(result2.getValue()).toBe('7777777752');
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(22);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(3);
diff --git a/packages/engine-formula/src/functions/engineering/dec2oct/index.ts b/packages/engine-formula/src/functions/engineering/dec2oct/index.ts
index b175020cd4..a204344be9 100644
--- a/packages/engine-formula/src/functions/engineering/dec2oct/index.ts
+++ b/packages/engine-formula/src/functions/engineering/dec2oct/index.ts
@@ -25,7 +25,7 @@ export class Dec2oct extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/delta/index.ts b/packages/engine-formula/src/functions/engineering/delta/index.ts
index ba1d15ad56..ab0e67f4cc 100644
--- a/packages/engine-formula/src/functions/engineering/delta/index.ts
+++ b/packages/engine-formula/src/functions/engineering/delta/index.ts
@@ -25,7 +25,7 @@ export class Delta extends BaseFunction {
override maxParams = 2;
- override calculate(number1: BaseValueObject, number2?: BaseValueObject) {
+ override calculate(number1: BaseValueObject, number2?: BaseValueObject): BaseValueObject {
const _number2 = number2 ?? NumberValueObject.create(0);
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number1, _number2);
diff --git a/packages/engine-formula/src/functions/engineering/erf-precise/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/erf-precise/__tests__/index.spec.ts
index f7e95061bb..1353348016 100644
--- a/packages/engine-formula/src/functions/engineering/erf-precise/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/erf-precise/__tests__/index.spec.ts
@@ -39,6 +39,12 @@ describe('Test erf.precise function', () => {
expect(result.getValue()).toBe(0.9661051464753108);
});
+ it('Value is negative number', () => {
+ const x = NumberValueObject.create(-2);
+ const result = testFunction.calculate(x);
+ expect(result.getValue()).toBe(-0.9953222650189527);
+ });
+
it('Value is normal string', () => {
const x = StringValueObject.create('test');
const result = testFunction.calculate(x);
diff --git a/packages/engine-formula/src/functions/engineering/erf-precise/index.ts b/packages/engine-formula/src/functions/engineering/erf-precise/index.ts
index 76fdbb7ed8..270407b2cd 100644
--- a/packages/engine-formula/src/functions/engineering/erf-precise/index.ts
+++ b/packages/engine-formula/src/functions/engineering/erf-precise/index.ts
@@ -26,7 +26,7 @@ export class ErfPrecise extends BaseFunction {
override maxParams = 1;
- override calculate(x: BaseValueObject) {
+ override calculate(x: BaseValueObject): BaseValueObject {
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x);
if (isError) {
diff --git a/packages/engine-formula/src/functions/engineering/erf/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/erf/__tests__/index.spec.ts
index f273f5f6d3..45235def5d 100644
--- a/packages/engine-formula/src/functions/engineering/erf/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/erf/__tests__/index.spec.ts
@@ -43,10 +43,21 @@ describe('Test erf function', () => {
expect(result.getValue()).toBe(0.9661051464753108);
});
+ it('Value is negative number', () => {
+ const lowerLimit = NumberValueObject.create(-2);
+ const result = testFunction.calculate(lowerLimit);
+ expect(result.getValue()).toBe(-0.9953222650189527);
+ });
+
it('Value is normal string', () => {
const lowerLimit = StringValueObject.create('test');
const result = testFunction.calculate(lowerLimit);
expect(result.getValue()).toBe(ErrorType.VALUE);
+
+ const lowerLimit2 = NumberValueObject.create(1);
+ const upperLimit2 = StringValueObject.create('test');
+ const result2 = testFunction.calculate(lowerLimit2, upperLimit2);
+ expect(result2.getValue()).toBe(ErrorType.VALUE);
});
it('Value is boolean', () => {
@@ -65,6 +76,11 @@ describe('Test erf function', () => {
const lowerLimit = ErrorValueObject.create(ErrorType.NAME);
const result = testFunction.calculate(lowerLimit);
expect(result.getValue()).toBe(ErrorType.NAME);
+
+ const lowerLimit2 = NumberValueObject.create(1);
+ const upperLimit2 = ErrorValueObject.create(ErrorType.NAME);
+ const result2 = testFunction.calculate(lowerLimit2, upperLimit2);
+ expect(result2.getValue()).toBe(ErrorType.NAME);
});
it('Value is array', () => {
diff --git a/packages/engine-formula/src/functions/engineering/erf/index.ts b/packages/engine-formula/src/functions/engineering/erf/index.ts
index 6b2695c829..3fb5c230aa 100644
--- a/packages/engine-formula/src/functions/engineering/erf/index.ts
+++ b/packages/engine-formula/src/functions/engineering/erf/index.ts
@@ -26,7 +26,7 @@ export class Erf extends BaseFunction {
override maxParams = 2;
- override calculate(lowerLimit: BaseValueObject, upperLimit?: BaseValueObject) {
+ override calculate(lowerLimit: BaseValueObject, upperLimit?: BaseValueObject): BaseValueObject {
let result;
if (upperLimit) {
diff --git a/packages/engine-formula/src/functions/engineering/erfc-precise/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/erfc-precise/__tests__/index.spec.ts
index 4a9b4bfb38..f660ecfe78 100644
--- a/packages/engine-formula/src/functions/engineering/erfc-precise/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/erfc-precise/__tests__/index.spec.ts
@@ -39,6 +39,12 @@ describe('Test erfc.precise function', () => {
expect(result.getValue()).toBe(0.03389485352468924);
});
+ it('Value is negative number', () => {
+ const x = NumberValueObject.create(-2);
+ const result = testFunction.calculate(x);
+ expect(result.getValue()).toBe(1.9953222650189528);
+ });
+
it('Value is normal string', () => {
const x = StringValueObject.create('test');
const result = testFunction.calculate(x);
diff --git a/packages/engine-formula/src/functions/engineering/erfc-precise/index.ts b/packages/engine-formula/src/functions/engineering/erfc-precise/index.ts
index 630a56704a..cedeb52d41 100644
--- a/packages/engine-formula/src/functions/engineering/erfc-precise/index.ts
+++ b/packages/engine-formula/src/functions/engineering/erfc-precise/index.ts
@@ -26,7 +26,7 @@ export class ErfcPrecise extends BaseFunction {
override maxParams = 1;
- override calculate(x: BaseValueObject) {
+ override calculate(x: BaseValueObject): BaseValueObject {
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x);
if (isError) {
diff --git a/packages/engine-formula/src/functions/engineering/erfc/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/erfc/__tests__/index.spec.ts
index f7073a9944..547b790d45 100644
--- a/packages/engine-formula/src/functions/engineering/erfc/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/erfc/__tests__/index.spec.ts
@@ -39,6 +39,12 @@ describe('Test erfc function', () => {
expect(result.getValue()).toBe(0.03389485352468924);
});
+ it('Value is negative number', () => {
+ const x = NumberValueObject.create(-2);
+ const result = testFunction.calculate(x);
+ expect(result.getValue()).toBe(1.9953222650189528);
+ });
+
it('Value is normal string', () => {
const x = StringValueObject.create('test');
const result = testFunction.calculate(x);
diff --git a/packages/engine-formula/src/functions/engineering/erfc/index.ts b/packages/engine-formula/src/functions/engineering/erfc/index.ts
index aa3e55be29..3d62de97fd 100644
--- a/packages/engine-formula/src/functions/engineering/erfc/index.ts
+++ b/packages/engine-formula/src/functions/engineering/erfc/index.ts
@@ -26,7 +26,7 @@ export class Erfc extends BaseFunction {
override maxParams = 1;
- override calculate(x: BaseValueObject) {
+ override calculate(x: BaseValueObject): BaseValueObject {
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x);
if (isError) {
diff --git a/packages/engine-formula/src/functions/engineering/function-map.ts b/packages/engine-formula/src/functions/engineering/function-map.ts
index 305e711672..f06aca73e9 100644
--- a/packages/engine-formula/src/functions/engineering/function-map.ts
+++ b/packages/engine-formula/src/functions/engineering/function-map.ts
@@ -37,9 +37,35 @@ import { Erf } from './erf';
import { ErfPrecise } from './erf-precise';
import { Erfc } from './erfc';
import { ErfcPrecise } from './erfc-precise';
+import { Gestep } from './gestep';
import { Hex2bin } from './hex2bin';
import { Hex2dec } from './hex2dec';
import { Hex2oct } from './hex2oct';
+import { Imabs } from './imabs';
+import { Imaginary } from './imaginary';
+import { Imargument } from './imargument';
+import { Imconjugate } from './imconjugate';
+import { Imcos } from './imcos';
+import { Imcosh } from './imcosh';
+import { Imcot } from './imcot';
+import { Imcsc } from './imcsc';
+import { Imcsch } from './imcsch';
+import { Imdiv } from './imdiv';
+import { Imexp } from './imexp';
+import { Imln } from './imln';
+import { Imlog10 } from './imlog10';
+import { Imlog2 } from './imlog2';
+import { Impower } from './impower';
+import { Improduct } from './improduct';
+import { Imreal } from './imreal';
+import { Imsec } from './imsec';
+import { Imsech } from './imsech';
+import { Imsin } from './imsin';
+import { Imsinh } from './imsinh';
+import { Imsqrt } from './imsqrt';
+import { Imsub } from './imsub';
+import { Imsum } from './imsum';
+import { Imtan } from './imtan';
import { Oct2bin } from './oct2bin';
import { Oct2dec } from './oct2dec';
import { Oct2hex } from './oct2hex';
@@ -67,9 +93,35 @@ export const functionEngineering = [
[ErfPrecise, FUNCTION_NAMES_ENGINEERING.ERF_PRECISE],
[Erfc, FUNCTION_NAMES_ENGINEERING.ERFC],
[ErfcPrecise, FUNCTION_NAMES_ENGINEERING.ERFC_PRECISE],
+ [Gestep, FUNCTION_NAMES_ENGINEERING.GESTEP],
[Hex2bin, FUNCTION_NAMES_ENGINEERING.HEX2BIN],
[Hex2dec, FUNCTION_NAMES_ENGINEERING.HEX2DEC],
[Hex2oct, FUNCTION_NAMES_ENGINEERING.HEX2OCT],
+ [Imabs, FUNCTION_NAMES_ENGINEERING.IMABS],
+ [Imaginary, FUNCTION_NAMES_ENGINEERING.IMAGINARY],
+ [Imargument, FUNCTION_NAMES_ENGINEERING.IMARGUMENT],
+ [Imconjugate, FUNCTION_NAMES_ENGINEERING.IMCONJUGATE],
+ [Imcos, FUNCTION_NAMES_ENGINEERING.IMCOS],
+ [Imcosh, FUNCTION_NAMES_ENGINEERING.IMCOSH],
+ [Imcot, FUNCTION_NAMES_ENGINEERING.IMCOT],
+ [Imcsc, FUNCTION_NAMES_ENGINEERING.IMCSC],
+ [Imcsch, FUNCTION_NAMES_ENGINEERING.IMCSCH],
+ [Imdiv, FUNCTION_NAMES_ENGINEERING.IMDIV],
+ [Imexp, FUNCTION_NAMES_ENGINEERING.IMEXP],
+ [Imln, FUNCTION_NAMES_ENGINEERING.IMLN],
+ [Imlog10, FUNCTION_NAMES_ENGINEERING.IMLOG10],
+ [Imlog2, FUNCTION_NAMES_ENGINEERING.IMLOG2],
+ [Impower, FUNCTION_NAMES_ENGINEERING.IMPOWER],
+ [Improduct, FUNCTION_NAMES_ENGINEERING.IMPRODUCT],
+ [Imreal, FUNCTION_NAMES_ENGINEERING.IMREAL],
+ [Imsec, FUNCTION_NAMES_ENGINEERING.IMSEC],
+ [Imsech, FUNCTION_NAMES_ENGINEERING.IMSECH],
+ [Imsin, FUNCTION_NAMES_ENGINEERING.IMSIN],
+ [Imsinh, FUNCTION_NAMES_ENGINEERING.IMSINH],
+ [Imsqrt, FUNCTION_NAMES_ENGINEERING.IMSQRT],
+ [Imsub, FUNCTION_NAMES_ENGINEERING.IMSUB],
+ [Imsum, FUNCTION_NAMES_ENGINEERING.IMSUM],
+ [Imtan, FUNCTION_NAMES_ENGINEERING.IMTAN],
[Oct2bin, FUNCTION_NAMES_ENGINEERING.OCT2BIN],
[Oct2dec, FUNCTION_NAMES_ENGINEERING.OCT2DEC],
[Oct2hex, FUNCTION_NAMES_ENGINEERING.OCT2HEX],
diff --git a/packages/engine-formula/src/functions/engineering/gestep/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/gestep/__tests__/index.spec.ts
new file mode 100644
index 0000000000..f3f9b27d0d
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/gestep/__tests__/index.spec.ts
@@ -0,0 +1,100 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Gestep } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 gestep function', () => {
+ const testFunction = new Gestep(FUNCTION_NAMES_ENGINEERING.GESTEP);
+
+ describe('Gestep', () => {
+ it('Value is normal number', () => {
+ const number = NumberValueObject.create(5);
+ const step = NumberValueObject.create(4);
+ const result = testFunction.calculate(number, step);
+ expect(result.getValue()).toBe(1);
+ });
+
+ it('Value is number string', () => {
+ const number = StringValueObject.create('1.5');
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(1);
+ });
+
+ it('Value is normal string', () => {
+ const number = StringValueObject.create('test');
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const number = BooleanValueObject.create(true);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is null', () => {
+ const number = NullValueObject.create();
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.NA);
+ });
+
+ it('Value is blank cell', () => {
+ const number = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(1);
+ });
+
+ it('Value is error', () => {
+ const number = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const number = 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(number);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/gestep/index.ts b/packages/engine-formula/src/functions/engineering/gestep/index.ts
new file mode 100644
index 0000000000..abee821d56
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/gestep/index.ts
@@ -0,0 +1,54 @@
+/**
+ * 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 { ErrorType } from '../../../basics/error-type';
+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+
+export class Gestep extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 2;
+
+ override calculate(number: BaseValueObject, step?: BaseValueObject): BaseValueObject {
+ if (number.isNull()) {
+ return ErrorValueObject.create(ErrorType.NA);
+ }
+
+ const _step = step ?? NumberValueObject.create(0);
+
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number, _step);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [numberObject, stepObject] = variants as BaseValueObject[];
+
+ const numberValue = +numberObject.getValue();
+ const stepValue = +stepObject.getValue();
+
+ if (Number.isNaN(numberValue) || Number.isNaN(stepValue)) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ const result = numberValue >= stepValue ? 1 : 0;
+
+ return NumberValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/hex2bin/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/hex2bin/__tests__/index.spec.ts
index 2f15c66401..8d2523123f 100644
--- a/packages/engine-formula/src/functions/engineering/hex2bin/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/hex2bin/__tests__/index.spec.ts
@@ -34,6 +34,35 @@ describe('Test hex2bin function', () => {
expect(result.getValue()).toBe('00001111');
});
+ it('Number < -512 || > 511 || < 0', () => {
+ const number = StringValueObject.create('FFFFF00000');
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const number2 = StringValueObject.create('FFFFFFFFF0');
+ const result2 = testFunction.calculate(number2);
+ expect(result2.getValue()).toBe('1111110000');
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(22);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(8);
diff --git a/packages/engine-formula/src/functions/engineering/hex2bin/index.ts b/packages/engine-formula/src/functions/engineering/hex2bin/index.ts
index 2fc23df647..5ec5ccdbb3 100644
--- a/packages/engine-formula/src/functions/engineering/hex2bin/index.ts
+++ b/packages/engine-formula/src/functions/engineering/hex2bin/index.ts
@@ -26,7 +26,7 @@ export class Hex2bin extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/hex2dec/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/hex2dec/__tests__/index.spec.ts
index 5371ada73c..8ae498057b 100644
--- a/packages/engine-formula/src/functions/engineering/hex2dec/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/hex2dec/__tests__/index.spec.ts
@@ -33,6 +33,12 @@ describe('Test hex2dec function', () => {
expect(result.getValue()).toBe(165);
});
+ it('Number >= 549755813888', () => {
+ const number = StringValueObject.create('FFFFFFFFFF');
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(-1);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const result = testFunction.calculate(number);
diff --git a/packages/engine-formula/src/functions/engineering/hex2dec/index.ts b/packages/engine-formula/src/functions/engineering/hex2dec/index.ts
index 0a97f44abe..36929d3a49 100644
--- a/packages/engine-formula/src/functions/engineering/hex2dec/index.ts
+++ b/packages/engine-formula/src/functions/engineering/hex2dec/index.ts
@@ -26,7 +26,7 @@ export class Hex2dec extends BaseFunction {
override maxParams = 1;
- override calculate(number: BaseValueObject) {
+ override calculate(number: BaseValueObject): BaseValueObject {
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);
if (isError) {
diff --git a/packages/engine-formula/src/functions/engineering/hex2oct/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/hex2oct/__tests__/index.spec.ts
index b8c7fed236..b769943ad1 100644
--- a/packages/engine-formula/src/functions/engineering/hex2oct/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/hex2oct/__tests__/index.spec.ts
@@ -34,6 +34,35 @@ describe('Test hex2oct function', () => {
expect(result.getValue()).toBe('017');
});
+ it('Number < 1098974756864 || > 536870911', () => {
+ const number = StringValueObject.create('FFFFF00000');
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe('7774000000');
+
+ const number2 = StringValueObject.create('FFFFF0000');
+ const result2 = testFunction.calculate(number2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(22);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(3);
diff --git a/packages/engine-formula/src/functions/engineering/hex2oct/index.ts b/packages/engine-formula/src/functions/engineering/hex2oct/index.ts
index 52e0f8f831..05d5c39051 100644
--- a/packages/engine-formula/src/functions/engineering/hex2oct/index.ts
+++ b/packages/engine-formula/src/functions/engineering/hex2oct/index.ts
@@ -26,7 +26,7 @@ export class Hex2oct extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/imabs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imabs/__tests__/index.spec.ts
new file mode 100644
index 0000000000..2fc7b86435
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imabs/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imabs } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imabs function', () => {
+ const testFunction = new Imabs(FUNCTION_NAMES_ENGINEERING.IMABS);
+
+ describe('Imabs', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(13);
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(25698432);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1.5);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imabs/index.ts b/packages/engine-formula/src/functions/engineering/imabs/index.ts
new file mode 100644
index 0000000000..9de1e2b83b
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imabs/index.ts
@@ -0,0 +1,51 @@
+/**
+ * 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 { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imabs extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Abs();
+
+ return NumberValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imaginary/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imaginary/__tests__/index.spec.ts
new file mode 100644
index 0000000000..b945d2a75c
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imaginary/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imaginary } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imaginary function', () => {
+ const testFunction = new Imaginary(FUNCTION_NAMES_ENGINEERING.IMAGINARY);
+
+ describe('Imaginary', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(12);
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imaginary/index.ts b/packages/engine-formula/src/functions/engineering/imaginary/index.ts
new file mode 100644
index 0000000000..4b43052b0a
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imaginary/index.ts
@@ -0,0 +1,51 @@
+/**
+ * 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 { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imaginary extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.getINum();
+
+ return NumberValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imargument/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imargument/__tests__/index.spec.ts
new file mode 100644
index 0000000000..7617a8d3fb
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imargument/__tests__/index.spec.ts
@@ -0,0 +1,103 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imargument } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imargument function', () => {
+ const testFunction = new Imargument(FUNCTION_NAMES_ENGINEERING.IMARGUMENT);
+
+ describe('Imargument', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1.176005207095135);
+
+ const inumber2 = StringValueObject.create('5-12i');
+ const result2 = testFunction.calculate(inumber2);
+ expect(result2.getValue()).toBe(-1.176005207095135);
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.DIV_BY_ZERO);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imargument/index.ts b/packages/engine-formula/src/functions/engineering/imargument/index.ts
new file mode 100644
index 0000000000..1bcfeeef8c
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imargument/index.ts
@@ -0,0 +1,55 @@
+/**
+ * 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 { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imargument extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex.getRealNum() === 0 && complex.getINum() === 0) {
+ return ErrorValueObject.create(ErrorType.DIV_BY_ZERO);
+ }
+
+ const result = complex.Argument();
+
+ return NumberValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imconjugate/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imconjugate/__tests__/index.spec.ts
new file mode 100644
index 0000000000..f92791aeeb
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imconjugate/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imconjugate } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imconjugate function', () => {
+ const testFunction = new Imconjugate(FUNCTION_NAMES_ENGINEERING.IMCONJUGATE);
+
+ describe('Imconjugate', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('5-12i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(25698432);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1.5);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imconjugate/index.ts b/packages/engine-formula/src/functions/engineering/imconjugate/index.ts
new file mode 100644
index 0000000000..beda3ef7a2
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imconjugate/index.ts
@@ -0,0 +1,56 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imconjugate extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Conjugate();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imcos/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imcos/__tests__/index.spec.ts
new file mode 100644
index 0000000000..1e98393f2c
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcos/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imcos } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imcos function', () => {
+ const testFunction = new Imcos(FUNCTION_NAMES_ENGINEERING.IMCOS);
+
+ describe('Imcos', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('23083.6899151345+78034.7601517635i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(-0.993968497433099);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.0707372016677029);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imcos/index.ts b/packages/engine-formula/src/functions/engineering/imcos/index.ts
new file mode 100644
index 0000000000..6de7aa8274
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcos/index.ts
@@ -0,0 +1,56 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imcos extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Cos();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imcosh/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imcosh/__tests__/index.spec.ts
new file mode 100644
index 0000000000..c56408dec6
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcosh/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imcosh } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imcosh function', () => {
+ const testFunction = new Imcosh(FUNCTION_NAMES_ENGINEERING.IMCOSH);
+
+ describe('Imcosh', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('62.6223588399767-39.8154332247249i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(2.35240961524325);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imcosh/index.ts b/packages/engine-formula/src/functions/engineering/imcosh/index.ts
new file mode 100644
index 0000000000..1fa3433571
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcosh/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imcosh extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Cosh();
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imcot/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imcot/__tests__/index.spec.ts
new file mode 100644
index 0000000000..4c759406c1
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcot/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imcot } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imcot function', () => {
+ const testFunction = new Imcot(FUNCTION_NAMES_ENGINEERING.IMCOT);
+
+ describe('Imcot', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('-4.10750577681088e-11-0.999999999936648i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(-9.06359967954937);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.0709148443026525);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imcot/index.ts b/packages/engine-formula/src/functions/engineering/imcot/index.ts
new file mode 100644
index 0000000000..a6d2da7d01
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcot/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imcot extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex.getRealNum() === 0 && complex.getINum() === 0) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Cot();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imcsc/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imcsc/__tests__/index.spec.ts
new file mode 100644
index 0000000000..57a40235fa
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcsc/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imcsc } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imcsc function', () => {
+ const testFunction = new Imcsc(FUNCTION_NAMES_ENGINEERING.IMCSC);
+
+ describe('Imcsc', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('-0.0000117836687482814-0.00000348576140783804i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(9.11859852998954);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1.00251130424672);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imcsc/index.ts b/packages/engine-formula/src/functions/engineering/imcsc/index.ts
new file mode 100644
index 0000000000..af3badf022
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcsc/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imcsc extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex.getRealNum() === 0 && complex.getINum() === 0) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Csc();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imcsch/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imcsch/__tests__/index.spec.ts
new file mode 100644
index 0000000000..9087fd03e8
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcsch/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imcsch } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imcsch function', () => {
+ const testFunction = new Imcsch(FUNCTION_NAMES_ENGINEERING.IMCSCH);
+
+ describe('Imcsch', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('0.0113716081825818+0.00723140654863397i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.469642440595225);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imcsch/index.ts b/packages/engine-formula/src/functions/engineering/imcsch/index.ts
new file mode 100644
index 0000000000..be7c8f87c9
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imcsch/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imcsch extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex.getRealNum() === 0 && complex.getINum() === 0) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Csch();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imdiv/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imdiv/__tests__/index.spec.ts
new file mode 100644
index 0000000000..15abe4a8c8
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imdiv/__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_ENGINEERING } from '../../function-names';
+import { Imdiv } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imdiv function', () => {
+ const testFunction = new Imdiv(FUNCTION_NAMES_ENGINEERING.IMDIV);
+
+ describe('Imdiv', () => {
+ it('Value is normal number', () => {
+ const inumber1 = StringValueObject.create('-238+240i');
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('5+12i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber1 = NumberValueObject.create(25698432);
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('380154.319526627-912370.366863905i');
+ });
+
+ it('Value is number string', () => {
+ const inumber1 = StringValueObject.create('1.5');
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('0.022189349112426-0.0532544378698225i');
+ });
+
+ it('Value is normal string', () => {
+ const inumber1 = StringValueObject.create('test');
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber1 = BooleanValueObject.create(true);
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is null', () => {
+ const inumber1 = NullValueObject.create();
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NA);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber1 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(0);
+
+ const inumber3 = StringValueObject.create('-238+240i');
+ const inumber4 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result2 = testFunction.calculate(inumber3, inumber4);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is error', () => {
+ const inumber1 = ErrorValueObject.create(ErrorType.NAME);
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Different suffixes', () => {
+ const inumber1 = StringValueObject.create('10+24i');
+ const inumber2 = StringValueObject.create('10+24j');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is array', () => {
+ const inumber1 = 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 inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imdiv/index.ts b/packages/engine-formula/src/functions/engineering/imdiv/index.ts
new file mode 100644
index 0000000000..d12b578103
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imdiv/index.ts
@@ -0,0 +1,71 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imdiv extends BaseFunction {
+ override minParams = 2;
+
+ override maxParams = 2;
+
+ override calculate(inumber1: BaseValueObject, inumber2: BaseValueObject): BaseValueObject {
+ if (inumber1.isNull() || inumber2.isNull()) {
+ return ErrorValueObject.create(ErrorType.NA);
+ }
+
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber1, inumber2);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumber1Object, inumber2Object] = variants as BaseValueObject[];
+
+ const inumber1Value = `${inumber1Object.getValue()}`;
+ const inumber2Value = `${inumber2Object.getValue()}`;
+
+ const complex1 = new Complex(inumber1Value);
+ const complex2 = new Complex(inumber2Value);
+
+ if (complex1.isError() || complex2.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ // Cannot perform operations on complex numbers with different suffixes.
+ if (complex1.isDifferentSuffixes(complex2)) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex2.getRealNum() === 0 && complex2.getINum() === 0) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex1.Div(complex2);
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imexp/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imexp/__tests__/index.spec.ts
new file mode 100644
index 0000000000..92de3873ad
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imexp/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imexp } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imexp function', () => {
+ const testFunction = new Imexp(FUNCTION_NAMES_ENGINEERING.IMEXP);
+
+ describe('Imexp', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('125.239031836704-79.6344818493324i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(4.48168907033806);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imexp/index.ts b/packages/engine-formula/src/functions/engineering/imexp/index.ts
new file mode 100644
index 0000000000..e7836e9e28
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imexp/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imexp extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Exp();
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imln/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imln/__tests__/index.spec.ts
new file mode 100644
index 0000000000..d83be3d827
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imln/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imln } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imln function', () => {
+ const testFunction = new Imln(FUNCTION_NAMES_ENGINEERING.IMLN);
+
+ describe('Imln', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('2.56494935746154+1.17600520709514i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(17.061940536331);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.405465108108164);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imln/index.ts b/packages/engine-formula/src/functions/engineering/imln/index.ts
new file mode 100644
index 0000000000..93e5793e53
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imln/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imln extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex.getRealNum() === 0 && complex.getINum() === 0) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Ln();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imlog10/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imlog10/__tests__/index.spec.ts
new file mode 100644
index 0000000000..8e274bf15e
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imlog10/__tests__/index.spec.ts
@@ -0,0 +1,103 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imlog10 } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imlog10 function', () => {
+ const testFunction = new Imlog10(FUNCTION_NAMES_ENGINEERING.IMLOG10);
+
+ describe('Imlog10', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('1.11394335230684+0.510732572130908i');
+
+ const inumber2 = StringValueObject.create('5-12i');
+ const result2 = testFunction.calculate(inumber2);
+ expect(result2.getValue()).toBe('1.11394335230684-0.510732572130908i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(7.40990662548997);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.176091259055681);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imlog10/index.ts b/packages/engine-formula/src/functions/engineering/imlog10/index.ts
new file mode 100644
index 0000000000..4a93ac1d4a
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imlog10/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imlog10 extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex.getRealNum() === 0 && complex.getINum() === 0) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Log10();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imlog2/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imlog2/__tests__/index.spec.ts
new file mode 100644
index 0000000000..43631fcaf0
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imlog2/__tests__/index.spec.ts
@@ -0,0 +1,103 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imlog2 } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imlog2 function', () => {
+ const testFunction = new Imlog2(FUNCTION_NAMES_ENGINEERING.IMLOG2);
+
+ describe('Imlog2', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('3.70043971814109+1.69661688033575i');
+
+ const inumber2 = StringValueObject.create('5-12i');
+ const result2 = testFunction.calculate(inumber2);
+ expect(result2.getValue()).toBe('3.70043971814109-1.69661688033575i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(24.6151769997071);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.584962500721156);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imlog2/index.ts b/packages/engine-formula/src/functions/engineering/imlog2/index.ts
new file mode 100644
index 0000000000..2fd47f2dbd
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imlog2/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imlog2 extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex.getRealNum() === 0 && complex.getINum() === 0) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Log2();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/impower/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/impower/__tests__/index.spec.ts
new file mode 100644
index 0000000000..c63b695efc
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/impower/__tests__/index.spec.ts
@@ -0,0 +1,169 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Impower } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 impower function', () => {
+ const testFunction = new Impower(FUNCTION_NAMES_ENGINEERING.IMPOWER);
+
+ describe('Impower', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const number = NumberValueObject.create(3);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe('-2035-828i');
+
+ const number2 = NumberValueObject.create(-3);
+ const result2 = testFunction.calculate(inumber, number2);
+ expect(result2.getValue()).toBe('-0.000421603589452162+0.000171541902735327i');
+
+ const inumber3 = StringValueObject.create('5-12i');
+ const result3 = testFunction.calculate(inumber3, number);
+ expect(result3.getValue()).toBe('-2035+828i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const number = NumberValueObject.create(895);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const number = NumberValueObject.create(3);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe(3.375);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const number = NumberValueObject.create(3);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Number value is normal string', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const number = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const number = NumberValueObject.create(3);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is null', () => {
+ const inumber = NullValueObject.create();
+ const number = NumberValueObject.create(3);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe(ErrorType.NA);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const number = NumberValueObject.create(3);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe(0);
+
+ const inumber2 = StringValueObject.create('5+12i');
+ const number2 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result2 = testFunction.calculate(inumber2, number2);
+ expect(result2.getValue()).toBe(1);
+
+ const inumber3 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const number3 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result3 = testFunction.calculate(inumber3, number3);
+ expect(result3.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const number = NumberValueObject.create(3);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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 number = NumberValueObject.create(3);
+ const result = testFunction.calculate(inumber, number);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/impower/index.ts b/packages/engine-formula/src/functions/engineering/impower/index.ts
new file mode 100644
index 0000000000..e0058bfe1a
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/impower/index.ts
@@ -0,0 +1,70 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Impower extends BaseFunction {
+ override minParams = 2;
+
+ override maxParams = 2;
+
+ override calculate(inumber: BaseValueObject, number: BaseValueObject): BaseValueObject {
+ if (inumber.isNull() || number.isNull()) {
+ return ErrorValueObject.create(ErrorType.NA);
+ }
+
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber, number);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject, numberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const numberValue = +numberObject.getValue();
+
+ if (Number.isNaN(numberValue)) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ const result = complex.Power(numberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/improduct/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/improduct/__tests__/index.spec.ts
new file mode 100644
index 0000000000..ae48f4d16c
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/improduct/__tests__/index.spec.ts
@@ -0,0 +1,114 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Improduct } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 improduct function', () => {
+ const testFunction = new Improduct(FUNCTION_NAMES_ENGINEERING.IMPRODUCT);
+
+ describe('Improduct', () => {
+ it('Value is normal number', () => {
+ const inumber1 = StringValueObject.create('5+12i');
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('-119+120i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber1 = NumberValueObject.create(25698432);
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('128492160+308381184i');
+ });
+
+ it('Value is number string', () => {
+ const inumber1 = StringValueObject.create('1.5');
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('7.5+18i');
+ });
+
+ it('Value is normal string', () => {
+ const inumber1 = StringValueObject.create('test');
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber1 = BooleanValueObject.create(true);
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber1 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber1 = ErrorValueObject.create(ErrorType.NAME);
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Different suffixes', () => {
+ const inumber1 = StringValueObject.create('5+12i');
+ const inumber2 = StringValueObject.create('5+12j');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is array', () => {
+ const inumber1 = 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 inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toStrictEqual(ErrorType.NUM);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/improduct/index.ts b/packages/engine-formula/src/functions/engineering/improduct/index.ts
new file mode 100644
index 0000000000..da415dae58
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/improduct/index.ts
@@ -0,0 +1,114 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
+import { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+
+export class Improduct extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 255;
+
+ override calculate(...variants: BaseValueObject[]): BaseValueObject {
+ let result: number | string | ErrorValueObject = '';
+
+ for (let i = 0; i < variants.length; i++) {
+ if (result instanceof ErrorValueObject) {
+ return result;
+ }
+
+ const variant = variants[i];
+
+ if (variant.isArray()) {
+ let isError = false;
+ let errorObject: Nullable<ErrorValueObject>;
+
+ (variant as ArrayValueObject).iterator((valueObject) => {
+ result = this._handleSingleObject(valueObject as BaseValueObject, result as number | string);
+
+ if (result instanceof ErrorValueObject) {
+ isError = true;
+ errorObject = result;
+ return false;
+ }
+ });
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+ } else {
+ result = this._handleSingleObject(variant, result);
+ }
+ }
+
+ if (result instanceof ErrorValueObject) {
+ return result;
+ }
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+
+ private _handleSingleObject(variant: BaseValueObject, result: number | string): number | string | ErrorValueObject {
+ let _result = result;
+
+ if (variant.isError()) {
+ return variant as ErrorValueObject;
+ }
+
+ if (variant.isBoolean()) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ const value = `${variant.getValue()}`;
+
+ if (typeof result !== 'number' && !result) {
+ const complex = new Complex(value);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ _result = complex.toString();
+ } else {
+ const complex1: Complex = new Complex(result);
+ const complex2 = new Complex(value);
+
+ if (complex1.isError() || complex2.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ // Cannot perform operations on complex numbers with different suffixes.
+ if (complex1.isDifferentSuffixes(complex2)) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ _result = complex1.Product(complex2);
+ }
+
+ return _result;
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imreal/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imreal/__tests__/index.spec.ts
new file mode 100644
index 0000000000..745fcc3cf6
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imreal/__tests__/index.spec.ts
@@ -0,0 +1,107 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imreal } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imreal function', () => {
+ const testFunction = new Imreal(FUNCTION_NAMES_ENGINEERING.IMREAL);
+
+ describe('Imreal', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(5);
+
+ const inumber2 = StringValueObject.create('i');
+ const result2 = testFunction.calculate(inumber2);
+ expect(result2.getValue()).toBe(0);
+
+ const inumber3 = StringValueObject.create('+i');
+ const result3 = testFunction.calculate(inumber3);
+ expect(result3.getValue()).toBe(0);
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(25698432);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1.5);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imreal/index.ts b/packages/engine-formula/src/functions/engineering/imreal/index.ts
new file mode 100644
index 0000000000..488c96cf1f
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imreal/index.ts
@@ -0,0 +1,51 @@
+/**
+ * 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 { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imreal extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.getRealNum();
+
+ return NumberValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imsec/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imsec/__tests__/index.spec.ts
new file mode 100644
index 0000000000..56cfc3649b
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsec/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imsec } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imsec function', () => {
+ const testFunction = new Imsec(FUNCTION_NAMES_ENGINEERING.IMSEC);
+
+ describe('Imsec', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('0.00000348576140854289-0.0000117836687488848i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(-1.00606810234175);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(14.1368329029699);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imsec/index.ts b/packages/engine-formula/src/functions/engineering/imsec/index.ts
new file mode 100644
index 0000000000..1b136b00c1
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsec/index.ts
@@ -0,0 +1,56 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imsec extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Sec();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imsech/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imsech/__tests__/index.spec.ts
new file mode 100644
index 0000000000..9880c03a93
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsech/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imsech } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imsech function', () => {
+ const testFunction = new Imsech(FUNCTION_NAMES_ENGINEERING.IMSECH);
+
+ describe('Imsech', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('0.0113717647601419+0.00723019299882505i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.425096034942281);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imsech/index.ts b/packages/engine-formula/src/functions/engineering/imsech/index.ts
new file mode 100644
index 0000000000..970af10337
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsech/index.ts
@@ -0,0 +1,56 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imsech extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Sech();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imsin/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imsin/__tests__/index.spec.ts
new file mode 100644
index 0000000000..ff13f02f20
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsin/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imsin } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imsin function', () => {
+ const testFunction = new Imsin(FUNCTION_NAMES_ENGINEERING.IMSIN);
+
+ describe('Imsin', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('-78034.7601576553+23083.6899133917i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.109665975172738);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0.997494986604054);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imsin/index.ts b/packages/engine-formula/src/functions/engineering/imsin/index.ts
new file mode 100644
index 0000000000..1ca12822c0
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsin/index.ts
@@ -0,0 +1,56 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imsin extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Sin();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imsinh/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imsinh/__tests__/index.spec.ts
new file mode 100644
index 0000000000..d6a128d936
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsinh/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imsinh } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imsinh function', () => {
+ const testFunction = new Imsinh(FUNCTION_NAMES_ENGINEERING.IMSINH);
+
+ describe('Imsinh', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('62.6166729967278-39.8190486246075i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(2.12927945509482);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imsinh/index.ts b/packages/engine-formula/src/functions/engineering/imsinh/index.ts
new file mode 100644
index 0000000000..9fda0b7662
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsinh/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imsinh extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Sinh();
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imsqrt/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imsqrt/__tests__/index.spec.ts
new file mode 100644
index 0000000000..7b2c671572
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsqrt/__tests__/index.spec.ts
@@ -0,0 +1,103 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imsqrt } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imsqrt function', () => {
+ const testFunction = new Imsqrt(FUNCTION_NAMES_ENGINEERING.IMSQRT);
+
+ describe('Imsqrt', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('3+2i');
+
+ const inumber2 = StringValueObject.create('5-12i');
+ const result2 = testFunction.calculate(inumber2);
+ expect(result2.getValue()).toBe('3-2i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(5069.36209004644);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(1.22474487139159);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imsqrt/index.ts b/packages/engine-formula/src/functions/engineering/imsqrt/index.ts
new file mode 100644
index 0000000000..ce8ab6b77e
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsqrt/index.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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imsqrt extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ if (complex.getRealNum() === 0 && complex.getINum() === 0) {
+ return NumberValueObject.create(0);
+ }
+
+ const result = complex.Sqrt();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imsub/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imsub/__tests__/index.spec.ts
new file mode 100644
index 0000000000..9ef1158b1b
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsub/__tests__/index.spec.ts
@@ -0,0 +1,126 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imsub } from '../index';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imsub function', () => {
+ const testFunction = new Imsub(FUNCTION_NAMES_ENGINEERING.IMSUB);
+
+ describe('Imsub', () => {
+ it('Value is normal number', () => {
+ const inumber1 = StringValueObject.create('-238+240i');
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('-248+216i');
+
+ const inumber3 = NumberValueObject.create(-238);
+ const inumber4 = NumberValueObject.create(10);
+ const result2 = testFunction.calculate(inumber3, inumber4);
+ expect(result2.getValue()).toBe(-248);
+ });
+
+ it('Value is large numbers', () => {
+ const inumber1 = NumberValueObject.create(25698432);
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('25698422-24i');
+ });
+
+ it('Value is number string', () => {
+ const inumber1 = StringValueObject.create('1.5');
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('-8.5-24i');
+ });
+
+ it('Value is normal string', () => {
+ const inumber1 = StringValueObject.create('test');
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber1 = BooleanValueObject.create(true);
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is null', () => {
+ const inumber1 = NullValueObject.create();
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NA);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber1 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('-10-24i');
+ });
+
+ it('Value is error', () => {
+ const inumber1 = ErrorValueObject.create(ErrorType.NAME);
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Different suffixes', () => {
+ const inumber1 = StringValueObject.create('10+24i');
+ const inumber2 = StringValueObject.create('10+24j');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is array', () => {
+ const inumber1 = 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 inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imsub/index.ts b/packages/engine-formula/src/functions/engineering/imsub/index.ts
new file mode 100644
index 0000000000..38c7691fe0
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsub/index.ts
@@ -0,0 +1,67 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imsub extends BaseFunction {
+ override minParams = 2;
+
+ override maxParams = 2;
+
+ override calculate(inumber1: BaseValueObject, inumber2: BaseValueObject): BaseValueObject {
+ if (inumber1.isNull() || inumber2.isNull()) {
+ return ErrorValueObject.create(ErrorType.NA);
+ }
+
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber1, inumber2);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumber1Object, inumber2Object] = variants as BaseValueObject[];
+
+ const inumber1Value = `${inumber1Object.getValue()}`;
+ const inumber2Value = `${inumber2Object.getValue()}`;
+
+ const complex1 = new Complex(inumber1Value);
+ const complex2 = new Complex(inumber2Value);
+
+ if (complex1.isError() || complex2.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ // Cannot perform operations on complex numbers with different suffixes.
+ if (complex1.isDifferentSuffixes(complex2)) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex1.Sub(complex2);
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imsum/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imsum/__tests__/index.spec.ts
new file mode 100644
index 0000000000..0ab7e4760e
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsum/__tests__/index.spec.ts
@@ -0,0 +1,119 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imsum } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imsum function', () => {
+ const testFunction = new Imsum(FUNCTION_NAMES_ENGINEERING.IMSUM);
+
+ describe('Imsum', () => {
+ it('Value is normal number', () => {
+ const inumber1 = StringValueObject.create('5+12i');
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('10+24i');
+
+ const inumber3 = NumberValueObject.create(5);
+ const inumber4 = NumberValueObject.create(12);
+ const result2 = testFunction.calculate(inumber3, inumber4);
+ expect(result2.getValue()).toBe(17);
+ });
+
+ it('Value is large numbers', () => {
+ const inumber1 = NumberValueObject.create(25698432);
+ const inumber2 = StringValueObject.create('10+24i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('25698442+24i');
+ });
+
+ it('Value is number string', () => {
+ const inumber1 = StringValueObject.create('1.5');
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('6.5+12i');
+ });
+
+ it('Value is normal string', () => {
+ const inumber1 = StringValueObject.create('test');
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber1 = BooleanValueObject.create(true);
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber1 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe('5+12i');
+ });
+
+ it('Value is error', () => {
+ const inumber1 = ErrorValueObject.create(ErrorType.NAME);
+ const inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Different suffixes', () => {
+ const inumber1 = StringValueObject.create('5+12i');
+ const inumber2 = StringValueObject.create('5+12j');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is array', () => {
+ const inumber1 = 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 inumber2 = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber1, inumber2);
+ expect(result.getValue()).toStrictEqual(ErrorType.NUM);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imsum/index.ts b/packages/engine-formula/src/functions/engineering/imsum/index.ts
new file mode 100644
index 0000000000..a6cb5b26d1
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imsum/index.ts
@@ -0,0 +1,114 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
+import { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+
+export class Imsum extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 255;
+
+ override calculate(...variants: BaseValueObject[]): BaseValueObject {
+ let result: number | string | ErrorValueObject = '';
+
+ for (let i = 0; i < variants.length; i++) {
+ if (result instanceof ErrorValueObject) {
+ return result;
+ }
+
+ const variant = variants[i];
+
+ if (variant.isArray()) {
+ let isError = false;
+ let errorObject: Nullable<ErrorValueObject>;
+
+ (variant as ArrayValueObject).iterator((valueObject) => {
+ result = this._handleSingleObject(valueObject as BaseValueObject, result as number | string);
+
+ if (result instanceof ErrorValueObject) {
+ isError = true;
+ errorObject = result;
+ return false;
+ }
+ });
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+ } else {
+ result = this._handleSingleObject(variant, result);
+ }
+ }
+
+ if (result instanceof ErrorValueObject) {
+ return result;
+ }
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+
+ private _handleSingleObject(variant: BaseValueObject, result: number | string): number | string | ErrorValueObject {
+ let _result = result;
+
+ if (variant.isError()) {
+ return variant as ErrorValueObject;
+ }
+
+ if (variant.isBoolean()) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ const value = `${variant.getValue()}`;
+
+ if (typeof result !== 'number' && !result) {
+ const complex = new Complex(value);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ _result = complex.toString();
+ } else {
+ const complex1: Complex = new Complex(result);
+ const complex2 = new Complex(value);
+
+ if (complex1.isError() || complex2.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ // Cannot perform operations on complex numbers with different suffixes.
+ if (complex1.isDifferentSuffixes(complex2)) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ _result = complex1.Sum(complex2);
+ }
+
+ return _result;
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/imtan/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imtan/__tests__/index.spec.ts
new file mode 100644
index 0000000000..bc7420ddb2
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imtan/__tests__/index.spec.ts
@@ -0,0 +1,99 @@
+/**
+ * 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_ENGINEERING } from '../../function-names';
+import { Imtan } from '../index';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { ArrayValueObject, 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 imtan function', () => {
+ const testFunction = new Imtan(FUNCTION_NAMES_ENGINEERING.IMTAN);
+
+ describe('Imtan', () => {
+ it('Value is normal number', () => {
+ const inumber = StringValueObject.create('5+12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('-4.10750577733132e-11+1.00000000006335i');
+ });
+
+ it('Value is large numbers', () => {
+ const inumber = NumberValueObject.create(25698432);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(-0.110331439533494);
+ });
+
+ it('Value is number string', () => {
+ const inumber = StringValueObject.create('1.5');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(14.1014199471717);
+ });
+
+ it('Value is normal string', () => {
+ const inumber = StringValueObject.create('test');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+ });
+
+ it('Value is boolean', () => {
+ const inumber = BooleanValueObject.create(true);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.VALUE);
+ });
+
+ it('Value is blank cell', () => {
+ const inumber = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [null],
+ ]),
+ rowCount: 1,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(0);
+ });
+
+ it('Value is error', () => {
+ const inumber = ErrorValueObject.create(ErrorType.NAME);
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe(ErrorType.NAME);
+ });
+
+ it('Value is array', () => {
+ const inumber = 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(inumber);
+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
+ });
+ });
+});
diff --git a/packages/engine-formula/src/functions/engineering/imtan/index.ts b/packages/engine-formula/src/functions/engineering/imtan/index.ts
new file mode 100644
index 0000000000..76133b80e2
--- /dev/null
+++ b/packages/engine-formula/src/functions/engineering/imtan/index.ts
@@ -0,0 +1,56 @@
+/**
+ * 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 { isRealNum } from '@univerjs/core';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { checkVariantsErrorIsArrayOrBoolean } from '../../../engine/utils/check-variant-error';
+import { Complex } from '../../../basics/complex';
+import { ErrorType } from '../../../basics/error-type';
+
+export class Imtan extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override calculate(inumber: BaseValueObject): BaseValueObject {
+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(inumber);
+
+ if (isError) {
+ return errorObject as ErrorValueObject;
+ }
+
+ const [inumberObject] = variants as BaseValueObject[];
+
+ const inumberValue = `${inumberObject.getValue()}`;
+
+ const complex = new Complex(inumberValue);
+
+ if (complex.isError()) {
+ return ErrorValueObject.create(ErrorType.NUM);
+ }
+
+ const result = complex.Tan();
+
+ if (typeof result === 'number' || isRealNum(result)) {
+ return NumberValueObject.create(+result);
+ }
+
+ return StringValueObject.create(result);
+ }
+}
diff --git a/packages/engine-formula/src/functions/engineering/oct2bin/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/oct2bin/__tests__/index.spec.ts
index c1bdd941a7..b9284fb8a1 100644
--- a/packages/engine-formula/src/functions/engineering/oct2bin/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/oct2bin/__tests__/index.spec.ts
@@ -34,6 +34,35 @@ describe('Test oct2bin function', () => {
expect(result.getValue()).toBe('011');
});
+ it('Number < -512 || > 511', () => {
+ const number = NumberValueObject.create(1111);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const number2 = StringValueObject.create('7777777777');
+ const result2 = testFunction.calculate(number2);
+ expect(result2.getValue()).toBe('1111111111');
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(22);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(3);
diff --git a/packages/engine-formula/src/functions/engineering/oct2bin/index.ts b/packages/engine-formula/src/functions/engineering/oct2bin/index.ts
index 411c36c561..2c5dadff3b 100644
--- a/packages/engine-formula/src/functions/engineering/oct2bin/index.ts
+++ b/packages/engine-formula/src/functions/engineering/oct2bin/index.ts
@@ -26,7 +26,7 @@ export class Oct2bin extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/engineering/oct2dec/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/oct2dec/__tests__/index.spec.ts
index 9d6939ccde..79ca0cee1c 100644
--- a/packages/engine-formula/src/functions/engineering/oct2dec/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/oct2dec/__tests__/index.spec.ts
@@ -33,6 +33,12 @@ describe('Test oct2dec function', () => {
expect(result.getValue()).toBe(44);
});
+ it('Number >= 536870912', () => {
+ const number = NumberValueObject.create(7777777777);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe(-1);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const result = testFunction.calculate(number);
diff --git a/packages/engine-formula/src/functions/engineering/oct2dec/index.ts b/packages/engine-formula/src/functions/engineering/oct2dec/index.ts
index 1a4148c368..e828faea18 100644
--- a/packages/engine-formula/src/functions/engineering/oct2dec/index.ts
+++ b/packages/engine-formula/src/functions/engineering/oct2dec/index.ts
@@ -26,7 +26,7 @@ export class Oct2dec extends BaseFunction {
override maxParams = 1;
- override calculate(number: BaseValueObject) {
+ override calculate(number: BaseValueObject): BaseValueObject {
const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);
if (isError) {
diff --git a/packages/engine-formula/src/functions/engineering/oct2hex/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/oct2hex/__tests__/index.spec.ts
index 715f2e50d1..a3fa151142 100644
--- a/packages/engine-formula/src/functions/engineering/oct2hex/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/oct2hex/__tests__/index.spec.ts
@@ -34,6 +34,31 @@ describe('Test oct2hex function', () => {
expect(result.getValue()).toBe('0040');
});
+ it('Number >= 536870912', () => {
+ const number = NumberValueObject.create(7777777777);
+ const result = testFunction.calculate(number);
+ expect(result.getValue()).toBe('FFFFFFFFFF');
+ });
+
+ it('Places test', () => {
+ const number = NumberValueObject.create(22);
+ const places = NumberValueObject.create(1);
+ const result = testFunction.calculate(number, places);
+ expect(result.getValue()).toBe(ErrorType.NUM);
+
+ const places2 = NumberValueObject.create(-1);
+ const result2 = testFunction.calculate(number, places2);
+ expect(result2.getValue()).toBe(ErrorType.NUM);
+
+ const places3 = BooleanValueObject.create(true);
+ const result3 = testFunction.calculate(number, places3);
+ expect(result3.getValue()).toBe(ErrorType.VALUE);
+
+ const places4 = StringValueObject.create('test');
+ const result4 = testFunction.calculate(number, places4);
+ expect(result4.getValue()).toBe(ErrorType.VALUE);
+ });
+
it('Value is number string', () => {
const number = StringValueObject.create('-0.5');
const places = NumberValueObject.create(4);
diff --git a/packages/engine-formula/src/functions/engineering/oct2hex/index.ts b/packages/engine-formula/src/functions/engineering/oct2hex/index.ts
index 85d8ad50ab..c88c0874a1 100644
--- a/packages/engine-formula/src/functions/engineering/oct2hex/index.ts
+++ b/packages/engine-formula/src/functions/engineering/oct2hex/index.ts
@@ -26,7 +26,7 @@ export class Oct2hex extends BaseFunction {
override maxParams = 2;
- override calculate(number: BaseValueObject, places?: BaseValueObject) {
+ override calculate(number: BaseValueObject, places?: BaseValueObject): BaseValueObject {
if (number.isNull()) {
return ErrorValueObject.create(ErrorType.NA);
}
diff --git a/packages/engine-formula/src/functions/math/sum/index.ts b/packages/engine-formula/src/functions/math/sum/index.ts
index fb1d8f94cf..35e8ca099c 100644
--- a/packages/engine-formula/src/functions/math/sum/index.ts
+++ b/packages/engine-formula/src/functions/math/sum/index.ts
@@ -40,6 +40,10 @@ export class Sum extends BaseFunction {
variant = variant.sum();
}
+ if (variant.isError()) {
+ return variant;
+ }
+
accumulatorAll = accumulatorAll.plus(variant);
if (accumulatorAll.isError()) {
diff --git a/packages/sheets-formula/src/locale/function-list/engineering/en-US.ts b/packages/sheets-formula/src/locale/function-list/engineering/en-US.ts
index 450187ecbb..40a705ae72 100644
--- a/packages/sheets-formula/src/locale/function-list/engineering/en-US.ts
+++ b/packages/sheets-formula/src/locale/function-list/engineering/en-US.ts
@@ -331,8 +331,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: 'number', detail: 'The value to test against step.' },
+ step: { name: 'step', detail: 'The threshold value. If you omit a value for step, GESTEP uses zero.' },
},
},
HEX2BIN: {
@@ -386,8 +386,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the absolute value.' },
},
},
IMAGINARY: {
@@ -400,8 +399,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the imaginary coefficient.' },
},
},
IMARGUMENT: {
@@ -414,8 +412,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the argument theta.' },
},
},
IMCONJUGATE: {
@@ -428,8 +425,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the conjugate.' },
},
},
IMCOS: {
@@ -442,8 +438,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the cosine.' },
},
},
IMCOSH: {
@@ -456,8 +451,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the hyperbolic cosine.' },
},
},
IMCOT: {
@@ -470,8 +464,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the cotangent.' },
},
},
IMCSC: {
@@ -484,8 +477,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the cosecant.' },
},
},
IMCSCH: {
@@ -498,8 +490,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the hyperbolic cosecant.' },
},
},
IMDIV: {
@@ -512,8 +503,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: 'inumber1', detail: 'The complex numerator or dividend.' },
+ inumber2: { name: 'inumber2', detail: 'The complex denominator or divisor.' },
},
},
IMEXP: {
@@ -526,8 +517,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the exponential.' },
},
},
IMLN: {
@@ -540,8 +530,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the natural logarithm.' },
},
},
IMLOG10: {
@@ -554,8 +543,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the common logarithm.' },
},
},
IMLOG2: {
@@ -568,8 +556,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the base-2 logarithm.' },
},
},
IMPOWER: {
@@ -582,8 +569,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number you want to raise to a power.' },
+ number: { name: 'number', detail: 'The power to which you want to raise the complex number.' },
},
},
IMPRODUCT: {
@@ -596,8 +583,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: 'inumber1', detail: '1 to 255 complex numbers to multiply.' },
+ inumber2: { name: 'inumber2', detail: '1 to 255 complex numbers to multiply.' },
},
},
IMREAL: {
@@ -610,8 +597,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the real coefficient.' },
},
},
IMSEC: {
@@ -624,8 +610,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the secant.' },
},
},
IMSECH: {
@@ -638,8 +623,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the hyperbolic secant.' },
},
},
IMSIN: {
@@ -652,8 +636,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the sine.' },
},
},
IMSINH: {
@@ -666,8 +649,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the hyperbolic sine.' },
},
},
IMSQRT: {
@@ -680,8 +662,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the square root.' },
},
},
IMSUB: {
@@ -694,8 +675,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: 'inumber1', detail: 'inumber1.' },
+ inumber2: { name: 'inumber2', detail: 'inumber2.' },
},
},
IMSUM: {
@@ -708,8 +689,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: 'inumber1', detail: '1 to 255 complex numbers to add.' },
+ inumber2: { name: 'inumber2', detail: '1 to 255 complex numbers to add.' },
},
},
IMTAN: {
@@ -722,8 +703,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: 'inumber', detail: 'A complex number for which you want the tangent.' },
},
},
OCT2BIN: {
diff --git a/packages/sheets-formula/src/locale/function-list/engineering/ja-JP.ts b/packages/sheets-formula/src/locale/function-list/engineering/ja-JP.ts
index bb3aa69dad..8f0b5361d7 100644
--- a/packages/sheets-formula/src/locale/function-list/engineering/ja-JP.ts
+++ b/packages/sheets-formula/src/locale/function-list/engineering/ja-JP.ts
@@ -331,8 +331,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数値', detail: 'しきい値に対して判定する値を指定します。' },
+ step: { name: 'しきい値', detail: 'しきい値にする値を指定します。しきい値を省略すると、0 が使用されます。' },
},
},
HEX2BIN: {
@@ -386,8 +386,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '絶対値を求める複素数を指定します。' },
},
},
IMAGINARY: {
@@ -400,8 +399,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '虚数係数を求める複素数を指定します。' },
},
},
IMARGUMENT: {
@@ -414,8 +412,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '引数を theta する複素数。' },
},
},
IMCONJUGATE: {
@@ -428,8 +425,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '共役を求める複素数を指定します。' },
},
},
IMCOS: {
@@ -442,8 +438,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: 'コサインを求める複素数を指定します。' },
},
},
IMCOSH: {
@@ -456,8 +451,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '双曲線余弦を求めたい複素数。' },
},
},
IMCOT: {
@@ -470,8 +464,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '余接を求める複素数を指定します。' },
},
},
IMCSC: {
@@ -484,8 +477,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '余割を求める複素数を指定します。' },
},
},
IMCSCH: {
@@ -498,8 +490,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '双曲線余割を求める複素数を指定します。' },
},
},
IMDIV: {
@@ -512,8 +503,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '複素数分子', detail: '割り算の分子または被除数となる複素数を指定します。' },
+ inumber2: { name: '複素数分母', detail: '割り算の分母または除数となる複素数を指定します。' },
},
},
IMEXP: {
@@ -526,8 +517,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: 'べき乗を求める複素数を指定します。' },
},
},
IMLN: {
@@ -540,8 +530,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '自然対数を求める複素数を指定します。' },
},
},
IMLOG10: {
@@ -554,8 +543,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '常用対数を求める複素数を指定します。' },
},
},
IMLOG2: {
@@ -568,8 +556,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '2 を底とする対数を求める複素数を指定します。' },
},
},
IMPOWER: {
@@ -582,13 +569,13 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: 'べき乗を求める複素数を指定します。' },
+ number: { name: '数値', detail: '複素数を底とするべき乗の指数です。' },
},
},
IMPRODUCT: {
- description: '2 ~ 255 個の複素数の積を返します。',
- abstract: '2 ~ 255 個の複素数の積を返します。',
+ description: '複素数の積を返します',
+ abstract: '複素数の積を返します',
links: [
{
title: '指導',
@@ -596,8 +583,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '複素数1', detail: '積を求める複素数を 1 ~ 255 個まで指定します。' },
+ inumber2: { name: '複素数2', detail: '積を求める複素数を 1 ~ 255 個まで指定します。' },
},
},
IMREAL: {
@@ -610,8 +597,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '実数係数を求める複素数を指定します。' },
},
},
IMSEC: {
@@ -624,8 +610,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '正割を求める複素数。' },
},
},
IMSECH: {
@@ -638,8 +623,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '双曲線正割を求める複素数。' },
},
},
IMSIN: {
@@ -652,8 +636,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: 'サインを求める複素数を指定します。' },
},
},
IMSINH: {
@@ -666,8 +649,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '双曲線正弦を求める複素数を指定します。' },
},
},
IMSQRT: {
@@ -680,8 +662,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '平方根を求める複素数を指定します。' },
},
},
IMSUB: {
@@ -694,8 +675,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '複素数1', detail: '複素数1。' },
+ inumber2: { name: '複素数2', detail: '複素数2。' },
},
},
IMSUM: {
@@ -708,8 +689,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '複素数1', detail: '和を求める複素数を 1 ~ 255 個まで指定します。' },
+ inumber2: { name: '複素数2', detail: '和を求める複素数を 1 ~ 255 個まで指定します。' },
},
},
IMTAN: {
@@ -722,8 +703,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複素数', detail: '正接を求める接線を指定します。' },
},
},
OCT2BIN: {
diff --git a/packages/sheets-formula/src/locale/function-list/engineering/vi-VN.ts b/packages/sheets-formula/src/locale/function-list/engineering/vi-VN.ts
index 8c6099a1c6..5baf5f08ed 100644
--- a/packages/sheets-formula/src/locale/function-list/engineering/vi-VN.ts
+++ b/packages/sheets-formula/src/locale/function-list/engineering/vi-VN.ts
@@ -332,14 +332,8 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ number: { name: 'số', detail: 'Giá trị để kiểm tra bước.' },
+ step: { name: 'ngưỡng', detail: 'Giá trị ngưỡng. Nếu bạn bỏ qua giá trị của bước, hàm GESTEP sẽ dùng số 0.' },
},
},
HEX2BIN: {
@@ -393,14 +387,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm giá trị tuyệt đối của nó.' },
},
},
IMAGINARY: {
@@ -413,14 +400,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm hệ số ảo của nó.' },
},
},
IMARGUMENT: {
@@ -433,14 +413,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm đối số theta.' },
},
},
IMCONJUGATE: {
@@ -453,14 +426,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm số liên hợp của nó.' },
},
},
IMCOS: {
@@ -473,14 +439,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm cosin của nó.' },
},
},
IMCOSH: {
@@ -493,14 +452,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy cosin hyperbolic.' },
},
},
IMCOT: {
@@ -513,14 +465,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy cotangent.' },
},
},
IMCSC: {
@@ -533,14 +478,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy cosecant.' },
},
},
IMCSCH: {
@@ -553,14 +491,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy hyperbolic cosecant.' },
},
},
IMDIV: {
@@ -573,14 +504,8 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber1: { name: 'tử số phức', detail: 'Số bị chia hoặc tử số phức.' },
+ inumber2: { name: 'mẫu số phức', detail: 'Ước số hoặc mẫu số phức.' },
},
},
IMEXP: {
@@ -593,14 +518,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm hàm mũ của nó.' },
},
},
IMLN: {
@@ -613,14 +531,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm lô-ga-rit tự nhiên của nó.' },
},
},
IMLOG10: {
@@ -633,14 +544,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm lô-ga-rit thập phân của nó.' },
},
},
IMLOG2: {
@@ -653,14 +557,7 @@ export default {
},
],
functionParameter: {
- number1: {
- name: 'number1',
- detail: 'đầu tiên',
- },
- number2: {
- name: 'number2',
- detail: 'thứ hai',
- },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm lô-ga-rit cơ số 2 của nó.' },
},
},
@@ -674,13 +571,13 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber: { name: 'số phức', detail: 'Một số phức mà bạn muốn nâng lên theo một lũy thừa.' },
+ number: { name: 'số', detail: 'Lũy thừa mà bạn muốn nâng số phức lên theo đó.' },
},
},
IMPRODUCT: {
- description: 'Trả về tích của từ 2 đến 255 số phức',
- abstract: 'Trả về tích của từ 2 đến 255 số phức',
+ description: 'Trả về tích của nhiều số phức',
+ abstract: 'Trả về tích của nhiều số phức',
links: [
{
title: 'Giảng dạy',
@@ -688,8 +585,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber1: { name: 'số phức 1', detail: '1 tới 255 số phức cần nhân với nhau.' },
+ inumber2: { name: 'số phức 2', detail: '1 tới 255 số phức cần nhân với nhau.' },
},
},
IMREAL: {
@@ -702,8 +599,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm hệ số thực của nó.' },
},
},
IMSEC: {
@@ -716,8 +612,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy sec.' },
},
},
IMSECH: {
@@ -730,8 +625,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy sech.' },
},
},
IMSIN: {
@@ -744,8 +638,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy sin.' },
},
},
IMSINH: {
@@ -758,8 +651,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy sinh.' },
},
},
IMSQRT: {
@@ -772,8 +664,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn tìm căn bậc hai của nó.' },
},
},
IMSUB: {
@@ -786,8 +677,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber1: { name: 'số phức 1', detail: 'số phức 1.' },
+ inumber2: { name: 'số phức 2', detail: 'số phức 2.' },
},
},
IMSUM: {
@@ -800,8 +691,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber1: { name: 'số phức 1', detail: '1 tới 255 số phức cần cộng với nhau.' },
+ inumber2: { name: 'số phức 2', detail: '1 tới 255 số phức cần cộng với nhau.' },
},
},
IMTAN: {
@@ -814,8 +705,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'đầu tiên' },
- number2: { name: 'number2', detail: 'thứ hai' },
+ inumber: { name: 'số phức', detail: 'Số phức mà bạn muốn lấy tang.' },
},
},
OCT2BIN: {
diff --git a/packages/sheets-formula/src/locale/function-list/engineering/zh-CN.ts b/packages/sheets-formula/src/locale/function-list/engineering/zh-CN.ts
index f83e61a3ab..bf28f52c02 100644
--- a/packages/sheets-formula/src/locale/function-list/engineering/zh-CN.ts
+++ b/packages/sheets-formula/src/locale/function-list/engineering/zh-CN.ts
@@ -331,8 +331,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '数值', detail: '要针对阈值进行测试的值。' },
+ step: { name: '阈值', detail: '阈值。如果省略阈值,则 GESTEP 使用零。' },
},
},
HEX2BIN: {
@@ -386,8 +386,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其绝对值的复数。' },
},
},
IMAGINARY: {
@@ -400,8 +399,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其虚系数的复数。' },
},
},
IMARGUMENT: {
@@ -414,8 +412,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '要为其参数 theta 的复数。' },
},
},
IMCONJUGATE: {
@@ -428,8 +425,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其共轭数的复数。' },
},
},
IMCOS: {
@@ -442,8 +438,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其余弦的复数。' },
},
},
IMCOSH: {
@@ -456,13 +451,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其双曲余弦值的复数。' },
},
},
IMCOT: {
- description: '返回复数的余弦值',
- abstract: '返回复数的余弦值',
+ description: '返回复数的余切值',
+ abstract: '返回复数的余切值',
links: [
{
title: '教学',
@@ -470,8 +464,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其余切的复数。' },
},
},
IMCSC: {
@@ -484,8 +477,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其余割值的复数。' },
},
},
IMCSCH: {
@@ -498,8 +490,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其双曲余割值的复数。' },
},
},
IMDIV: {
@@ -512,8 +503,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '复数分子', detail: '复数分子或被除数。' },
+ inumber2: { name: '复数分母', detail: '复数分母或除数。' },
},
},
IMEXP: {
@@ -526,8 +517,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其指数的复数。' },
},
},
IMLN: {
@@ -540,8 +530,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其自然对数的复数。' },
},
},
IMLOG10: {
@@ -554,8 +543,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其常用对数的复数。' },
},
},
IMLOG2: {
@@ -568,8 +556,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算以 2 为底数的对数的复数。' },
},
},
IMPOWER: {
@@ -582,13 +569,13 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其幂值的复数。' },
+ number: { name: '数值', detail: '需要对复数应用的幂次。' },
},
},
IMPRODUCT: {
- description: '返回从 2 到 255 的复数的乘积',
- abstract: '返回从 2 到 255 的复数的乘积',
+ description: '返回多个复数的乘积',
+ abstract: '返回多个复数的乘积',
links: [
{
title: '教学',
@@ -596,8 +583,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '复数1', detail: '1 到 255 个要相乘的复数。' },
+ inumber2: { name: '复数2', detail: '1 到 255 个要相乘的复数。' },
},
},
IMREAL: {
@@ -610,13 +597,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其实系数的复数。' },
},
},
IMSEC: {
- description: '返回复数的正切值',
- abstract: '返回复数的正切值',
+ description: '返回复数的正割值',
+ abstract: '返回复数的正割值',
links: [
{
title: '教学',
@@ -624,13 +610,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其正割值的复数。' },
},
},
IMSECH: {
- description: '返回复数的双曲正切值',
- abstract: '返回复数的双曲正切值',
+ description: '返回复数的双曲正割值',
+ abstract: '返回复数的双曲正割值',
links: [
{
title: '教学',
@@ -638,8 +623,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其双曲正割值的复数。' },
},
},
IMSIN: {
@@ -652,8 +636,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其正弦值的复数。' },
},
},
IMSINH: {
@@ -666,8 +649,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其双曲正弦值的复数。' },
},
},
IMSQRT: {
@@ -680,8 +662,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其平方根的复数。' },
},
},
IMSUB: {
@@ -694,8 +675,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '复数1', detail: '复数1。' },
+ inumber2: { name: '复数2', detail: '复数2。' },
},
},
IMSUM: {
@@ -708,8 +689,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '复数1', detail: '1 到 255 个要相加的复数。' },
+ inumber2: { name: '复数2', detail: '1 到 255 个要相加的复数。' },
},
},
IMTAN: {
@@ -722,8 +703,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '复数', detail: '需要计算其正切值的复数。' },
},
},
OCT2BIN: {
diff --git a/packages/sheets-formula/src/locale/function-list/engineering/zh-TW.ts b/packages/sheets-formula/src/locale/function-list/engineering/zh-TW.ts
index 872cda9d3c..e3702ef82e 100644
--- a/packages/sheets-formula/src/locale/function-list/engineering/zh-TW.ts
+++ b/packages/sheets-formula/src/locale/function-list/engineering/zh-TW.ts
@@ -331,8 +331,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ number: { name: '數值', detail: '這是要檢定閾值的值。' },
+ step: { name: '閾值', detail: '這是閾值。如果您省略閾值的值,GESTEP 會使用零。' },
},
},
HEX2BIN: {
@@ -386,8 +386,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得絕對值的複數。' },
},
},
IMAGINARY: {
@@ -400,8 +399,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得虛係數的複數。' },
},
},
IMARGUMENT: {
@@ -414,8 +412,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求自變數 theta 的複數。' },
},
},
IMCONJUGATE: {
@@ -428,8 +425,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得共軛的複數。' },
},
},
IMCOS: {
@@ -442,8 +438,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得餘弦值的複數。' },
},
},
IMCOSH: {
@@ -456,13 +451,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得雙曲餘弦值的複數。' },
},
},
IMCOT: {
- description: '傳回複數的餘弦值',
- abstract: '傳回複數的餘弦值',
+ description: '傳回複數的餘切值',
+ abstract: '傳回複數的餘切值',
links: [
{
title: '教導',
@@ -470,8 +464,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得餘切值的複數。' },
},
},
IMCSC: {
@@ -484,8 +477,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得餘割值的複數。' },
},
},
IMCSCH: {
@@ -498,8 +490,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得雙曲餘割值的複數。' },
},
},
IMDIV: {
@@ -512,8 +503,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '複數分子', detail: '這是複數分子或被除數。' },
+ inumber2: { name: '複數分母', detail: '這是複數分母或除數。' },
},
},
IMEXP: {
@@ -526,8 +517,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得指數的複數。' },
},
},
IMLN: {
@@ -540,8 +530,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得自然對數的複數。' },
},
},
IMLOG10: {
@@ -554,8 +543,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得常用對數的複數。' },
},
},
IMLOG2: {
@@ -568,8 +556,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得底數為 2 之對數的複數。' },
},
},
IMPOWER: {
@@ -582,13 +569,13 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要遞增至乘冪的複數。' },
+ number: { name: '數值', detail: '這是要遞增至複數的乘冪。' },
},
},
IMPRODUCT: {
- description: '傳回 2 到 255 的複數的乘積',
- abstract: '傳回 2 到 255 的複數的乘積',
+ description: '傳回多個複數的乘積',
+ abstract: '傳回多個複數的乘積',
links: [
{
title: '教導',
@@ -596,8 +583,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '複數1', detail: '這是 1 到 255 個要乘以的複數。' },
+ inumber2: { name: '複數2', detail: '這是 1 到 255 個要乘以的複數。' },
},
},
IMREAL: {
@@ -610,13 +597,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得實係數的複數。' },
},
},
IMSEC: {
- description: '傳回複數的正切值',
- abstract: '傳回複數的正切值',
+ description: '傳回複數的正割值',
+ abstract: '傳回複數的正割值',
links: [
{
title: '教導',
@@ -624,13 +610,12 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得正割值的複數。' },
},
},
IMSECH: {
- description: '傳回複數的雙曲正切值',
- abstract: '傳回複數的雙曲正切值',
+ description: '傳回複數的雙曲正割值',
+ abstract: '傳回複數的雙曲正割值',
links: [
{
title: '教導',
@@ -638,8 +623,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得雙曲正割值的複數。' },
},
},
IMSIN: {
@@ -652,8 +636,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得正弦值的複數。' },
},
},
IMSINH: {
@@ -666,8 +649,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得雙曲正弦值的複數。' },
},
},
IMSQRT: {
@@ -680,8 +662,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得平方根的複數。' },
},
},
IMSUB: {
@@ -694,8 +675,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '複數1', detail: '複數1。' },
+ inumber2: { name: '複數2', detail: '複數2。' },
},
},
IMSUM: {
@@ -708,8 +689,8 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber1: { name: '複數1', detail: '這是 1 到 255 個要相加的複數。' },
+ inumber2: { name: '複數2', detail: '這是 1 到 255 個要相加的複數。' },
},
},
IMTAN: {
@@ -722,8 +703,7 @@ export default {
},
],
functionParameter: {
- number1: { name: 'number1', detail: 'first' },
- number2: { name: 'number2', detail: 'second' },
+ inumber: { name: '複數', detail: '這是要求得正切值的複數。' },
},
},
OCT2BIN: {
diff --git a/packages/sheets-formula/src/services/function-list/engineering.ts b/packages/sheets-formula/src/services/function-list/engineering.ts
index ed7244374f..b2eef865da 100644
--- a/packages/sheets-formula/src/services/function-list/engineering.ts
+++ b/packages/sheets-formula/src/services/function-list/engineering.ts
@@ -494,17 +494,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.GESTEP.abstract',
functionParameter: [
{
- name: 'formula.functionList.GESTEP.functionParameter.number1.name',
- detail: 'formula.functionList.GESTEP.functionParameter.number1.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.GESTEP.functionParameter.number.name',
+ detail: 'formula.functionList.GESTEP.functionParameter.number.detail',
+ example: '5',
require: 1,
repeat: 0,
},
{
- name: 'formula.functionList.GESTEP.functionParameter.number2.name',
- detail: 'formula.functionList.GESTEP.functionParameter.number2.detail',
- example: 'A1:A20',
- require: 1,
+ name: 'formula.functionList.GESTEP.functionParameter.step.name',
+ detail: 'formula.functionList.GESTEP.functionParameter.step.detail',
+ example: '4',
+ require: 0,
repeat: 0,
},
],
@@ -575,16 +575,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMABS.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMABS.functionParameter.number1.name',
- detail: 'formula.functionList.IMABS.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMABS.functionParameter.number2.name',
- detail: 'formula.functionList.IMABS.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMABS.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMABS.functionParameter.inumber.detail',
+ example: '"5+12i"',
require: 1,
repeat: 0,
},
@@ -597,16 +590,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMAGINARY.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMAGINARY.functionParameter.number1.name',
- detail: 'formula.functionList.IMAGINARY.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMAGINARY.functionParameter.number2.name',
- detail: 'formula.functionList.IMAGINARY.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMAGINARY.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMAGINARY.functionParameter.inumber.detail',
+ example: '"3+4i"',
require: 1,
repeat: 0,
},
@@ -619,16 +605,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMARGUMENT.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMARGUMENT.functionParameter.number1.name',
- detail: 'formula.functionList.IMARGUMENT.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMARGUMENT.functionParameter.number2.name',
- detail: 'formula.functionList.IMARGUMENT.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMARGUMENT.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMARGUMENT.functionParameter.inumber.detail',
+ example: '"3+4i"',
require: 1,
repeat: 0,
},
@@ -641,16 +620,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMCONJUGATE.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMCONJUGATE.functionParameter.number1.name',
- detail: 'formula.functionList.IMCONJUGATE.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMCONJUGATE.functionParameter.number2.name',
- detail: 'formula.functionList.IMCONJUGATE.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMCONJUGATE.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMCONJUGATE.functionParameter.inumber.detail',
+ example: '"3+4i"',
require: 1,
repeat: 0,
},
@@ -663,16 +635,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMCOS.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMCOS.functionParameter.number1.name',
- detail: 'formula.functionList.IMCOS.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMCOS.functionParameter.number2.name',
- detail: 'formula.functionList.IMCOS.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMCOS.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMCOS.functionParameter.inumber.detail',
+ example: '"1+i"',
require: 1,
repeat: 0,
},
@@ -685,16 +650,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMCOSH.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMCOSH.functionParameter.number1.name',
- detail: 'formula.functionList.IMCOSH.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMCOSH.functionParameter.number2.name',
- detail: 'formula.functionList.IMCOSH.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMCOSH.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMCOSH.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
@@ -707,16 +665,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMCOT.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMCOT.functionParameter.number1.name',
- detail: 'formula.functionList.IMCOT.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMCOT.functionParameter.number2.name',
- detail: 'formula.functionList.IMCOT.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMCOT.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMCOT.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
@@ -729,16 +680,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMCSC.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMCSC.functionParameter.number1.name',
- detail: 'formula.functionList.IMCSC.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMCSC.functionParameter.number2.name',
- detail: 'formula.functionList.IMCSC.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMCSC.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMCSC.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
@@ -751,16 +695,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMCSCH.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMCSCH.functionParameter.number1.name',
- detail: 'formula.functionList.IMCSCH.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMCSCH.functionParameter.number2.name',
- detail: 'formula.functionList.IMCSCH.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMCSCH.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMCSCH.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
@@ -773,16 +710,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMDIV.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMDIV.functionParameter.number1.name',
- detail: 'formula.functionList.IMDIV.functionParameter.number1.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMDIV.functionParameter.inumber1.name',
+ detail: 'formula.functionList.IMDIV.functionParameter.inumber1.detail',
+ example: '"-238+240i"',
require: 1,
repeat: 0,
},
{
- name: 'formula.functionList.IMDIV.functionParameter.number2.name',
- detail: 'formula.functionList.IMDIV.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMDIV.functionParameter.inumber2.name',
+ detail: 'formula.functionList.IMDIV.functionParameter.inumber2.detail',
+ example: '"10+24i"',
require: 1,
repeat: 0,
},
@@ -795,16 +732,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMEXP.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMEXP.functionParameter.number1.name',
- detail: 'formula.functionList.IMEXP.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMEXP.functionParameter.number2.name',
- detail: 'formula.functionList.IMEXP.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMEXP.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMEXP.functionParameter.inumber.detail',
+ example: '"1+i"',
require: 1,
repeat: 0,
},
@@ -817,16 +747,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMLN.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMLN.functionParameter.number1.name',
- detail: 'formula.functionList.IMLN.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMLN.functionParameter.number2.name',
- detail: 'formula.functionList.IMLN.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMLN.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMLN.functionParameter.inumber.detail',
+ example: '"3+4i"',
require: 1,
repeat: 0,
},
@@ -839,16 +762,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMLOG10.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMLOG10.functionParameter.number1.name',
- detail: 'formula.functionList.IMLOG10.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMLOG10.functionParameter.number2.name',
- detail: 'formula.functionList.IMLOG10.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMLOG10.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMLOG10.functionParameter.inumber.detail',
+ example: '"3+4i"',
require: 1,
repeat: 0,
},
@@ -861,16 +777,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMLOG2.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMLOG2.functionParameter.number1.name',
- detail: 'formula.functionList.IMLOG2.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMLOG2.functionParameter.number2.name',
- detail: 'formula.functionList.IMLOG2.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMLOG2.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMLOG2.functionParameter.inumber.detail',
+ example: '"3+4i"',
require: 1,
repeat: 0,
},
@@ -883,16 +792,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMPOWER.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMPOWER.functionParameter.number1.name',
- detail: 'formula.functionList.IMPOWER.functionParameter.number1.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMPOWER.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMPOWER.functionParameter.inumber.detail',
+ example: '"2+3i"',
require: 1,
repeat: 0,
},
{
- name: 'formula.functionList.IMPOWER.functionParameter.number2.name',
- detail: 'formula.functionList.IMPOWER.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMPOWER.functionParameter.number.name',
+ detail: 'formula.functionList.IMPOWER.functionParameter.number.detail',
+ example: '3',
require: 1,
repeat: 0,
},
@@ -905,18 +814,18 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMPRODUCT.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMPRODUCT.functionParameter.number1.name',
- detail: 'formula.functionList.IMPRODUCT.functionParameter.number1.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMPRODUCT.functionParameter.inumber1.name',
+ detail: 'formula.functionList.IMPRODUCT.functionParameter.inumber1.detail',
+ example: '"3+4i"',
require: 1,
repeat: 0,
},
{
- name: 'formula.functionList.IMPRODUCT.functionParameter.number2.name',
- detail: 'formula.functionList.IMPRODUCT.functionParameter.number2.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
+ name: 'formula.functionList.IMPRODUCT.functionParameter.inumber2.name',
+ detail: 'formula.functionList.IMPRODUCT.functionParameter.inumber2.detail',
+ example: '"5-3i"',
+ require: 0,
+ repeat: 1,
},
],
},
@@ -927,16 +836,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMREAL.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMREAL.functionParameter.number1.name',
- detail: 'formula.functionList.IMREAL.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMREAL.functionParameter.number2.name',
- detail: 'formula.functionList.IMREAL.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMREAL.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMREAL.functionParameter.inumber.detail',
+ example: '"6-9i"',
require: 1,
repeat: 0,
},
@@ -949,16 +851,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMSEC.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMSEC.functionParameter.number1.name',
- detail: 'formula.functionList.IMSEC.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMSEC.functionParameter.number2.name',
- detail: 'formula.functionList.IMSEC.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMSEC.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMSEC.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
@@ -971,16 +866,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMSECH.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMSECH.functionParameter.number1.name',
- detail: 'formula.functionList.IMSECH.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMSECH.functionParameter.number2.name',
- detail: 'formula.functionList.IMSECH.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMSECH.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMSECH.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
@@ -993,16 +881,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMSIN.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMSIN.functionParameter.number1.name',
- detail: 'formula.functionList.IMSIN.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMSIN.functionParameter.number2.name',
- detail: 'formula.functionList.IMSIN.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMSIN.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMSIN.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
@@ -1015,16 +896,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMSINH.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMSINH.functionParameter.number1.name',
- detail: 'formula.functionList.IMSINH.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMSINH.functionParameter.number2.name',
- detail: 'formula.functionList.IMSINH.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMSINH.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMSINH.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
@@ -1037,16 +911,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMSQRT.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMSQRT.functionParameter.number1.name',
- detail: 'formula.functionList.IMSQRT.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMSQRT.functionParameter.number2.name',
- detail: 'formula.functionList.IMSQRT.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMSQRT.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMSQRT.functionParameter.inumber.detail',
+ example: '"1+i"',
require: 1,
repeat: 0,
},
@@ -1059,16 +926,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMSUB.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMSUB.functionParameter.number1.name',
- detail: 'formula.functionList.IMSUB.functionParameter.number1.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMSUB.functionParameter.inumber1.name',
+ detail: 'formula.functionList.IMSUB.functionParameter.inumber1.detail',
+ example: '"13+4i"',
require: 1,
repeat: 0,
},
{
- name: 'formula.functionList.IMSUB.functionParameter.number2.name',
- detail: 'formula.functionList.IMSUB.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMSUB.functionParameter.inumber2.name',
+ detail: 'formula.functionList.IMSUB.functionParameter.inumber2.detail',
+ example: '"5+3i"',
require: 1,
repeat: 0,
},
@@ -1081,18 +948,18 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMSUM.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMSUM.functionParameter.number1.name',
- detail: 'formula.functionList.IMSUM.functionParameter.number1.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMSUM.functionParameter.inumber1.name',
+ detail: 'formula.functionList.IMSUM.functionParameter.inumber1.detail',
+ example: '"3+4i"',
require: 1,
repeat: 0,
},
{
- name: 'formula.functionList.IMSUM.functionParameter.number2.name',
- detail: 'formula.functionList.IMSUM.functionParameter.number2.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
+ name: 'formula.functionList.IMSUM.functionParameter.inumber2.name',
+ detail: 'formula.functionList.IMSUM.functionParameter.inumber2.detail',
+ example: '"5-3i"',
+ require: 0,
+ repeat: 1,
},
],
},
@@ -1103,16 +970,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [
abstract: 'formula.functionList.IMTAN.abstract',
functionParameter: [
{
- name: 'formula.functionList.IMTAN.functionParameter.number1.name',
- detail: 'formula.functionList.IMTAN.functionParameter.number1.detail',
- example: 'A1:A20',
- require: 1,
- repeat: 0,
- },
- {
- name: 'formula.functionList.IMTAN.functionParameter.number2.name',
- detail: 'formula.functionList.IMTAN.functionParameter.number2.detail',
- example: 'A1:A20',
+ name: 'formula.functionList.IMTAN.functionParameter.inumber.name',
+ detail: 'formula.functionList.IMTAN.functionParameter.inumber.detail',
+ example: '"4+3i"',
require: 1,
repeat: 0,
},
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 710af4ae22..08bec53389 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1414,6 +1414,9 @@ importers:
packages/engine-formula:
dependencies:
+ decimal.js:
+ specifier: ^10.4.3
+ version: 10.4.3
numfmt:
specifier: ^2.5.2
version: 2.5.2