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.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
feat(formula): add some engineering functions (#3070)
wpxp123456dbe1dab799fb
diff --git a/packages/engine-formula/package.json b/packages/engine-formula/package.jsonindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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-namespaceexport 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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-obimport { 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.yamlindex 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.3numfmt:specifier: ^2.5.2version: 2.5.2