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 function (#2893)
wpxp1234569386c6bbd093
diff --git a/packages/engine-formula/src/basics/engineering.ts b/packages/engine-formula/src/basics/engineering.tsnew file mode 100644index 0000000000..325b998790--- /dev/null+++ b/packages/engine-formula/src/basics/engineering.ts@@ -0,0 +1,470 @@+/**+ * 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 { ArrayValueObject } from '../engine/value-object/array-value-object';+import type { BaseValueObject } from '../engine/value-object/base-value-object';+import { ErrorValueObject } from '../engine/value-object/base-value-object';+import { ErrorType } from './error-type';++export function checkVariantsErrorIsArrayOrBoolean(...variants: BaseValueObject[]) {+ for (let i = 0; i < variants.length; i++) {+ let variant = variants[i];++ if (variant.isArray()) {+ const rowCount = (variant as ArrayValueObject).getRowCount();+ const columnCount = (variant as ArrayValueObject).getColumnCount();++ if (rowCount > 1 || columnCount > 1) {+ return {+ isError: true,+ errorObject: ErrorValueObject.create(ErrorType.VALUE),+ };+ }++ variant = (variant as ArrayValueObject).get(0, 0) as BaseValueObject;+ }++ if (variant.isError()) {+ return {+ isError: true,+ errorObject: variant,+ };+ }++ if (variant.isBoolean()) {+ return {+ isError: true,+ errorObject: ErrorValueObject.create(ErrorType.VALUE),+ };+ }++ variants[i] = variant;+ }++ return {+ isError: false,+ variants,+ };+}++// eslint-disable-next-line ts/no-namespace+export namespace BESSEL {+ const W = 0.636619772;++ function _horner(arr: number[], v: number): number {+ let z = 0;++ for (let i = 0; i < arr.length; ++i) {+ z = v * z + arr[i];+ }++ return z;+ }++ function _bessel_iter(x: number, n: number, f0: number, f1: number, sign: number): number {+ if (n === 0) {+ return f0;+ }++ if (n === 1) {+ return f1;+ }++ const tdx = 2 / x;+ let _f0 = f0;+ let _f1 = f1;+ let f2 = f1;++ for (let o = 1; o < n; ++o) {+ f2 = _f1 * o * tdx + sign * _f0;+ _f0 = _f1;+ _f1 = f2;+ }++ return f2;+ }++ function _bessel_wrap(bessel0: Function, bessel1: Function, nonzero: number, sign: number) {+ return function bessel(x: number, n: number) {+ if (nonzero) {+ if (x === 0) {+ return nonzero === 1 ? -Infinity : Infinity;+ } else if (x < 0) {+ return Number.NaN;+ }+ }++ if (n === 0) {+ return bessel0(x);+ }++ if (n === 1) {+ return bessel1(x);+ }++ if (n < 0) {+ return Number.NaN;+ }++ const _n = n | 0;++ const b0 = bessel0(x);+ const b1 = bessel1(x);++ return _bessel_iter(x, _n, b0, b1, sign);+ };+ }++ export const besselj = (() => {+ const b0_a1a = [-184.9052456, 77392.33017, -11214424.18, 651619640.7, -13362590354.0, 57568490574.0];+ const b0_a2a = [1.0, 267.8532712, 59272.64853, 9494680.718, 1029532985.0, 57568490411.0];+ const b0_a1b = [0.2093887211e-6, -0.2073370639e-5, 0.2734510407e-4, -0.1098628627e-2, 1.0];+ const b0_a2b = [-0.934935152e-7, 0.7621095161e-6, -0.6911147651e-5, 0.1430488765e-3, -0.1562499995e-1];++ function bessel0(x: number): number {+ let a = 0;+ let a1 = 0;+ let a2 = 0;+ let y = x * x;++ if (x < 8) {+ a1 = _horner(b0_a1a, y);+ a2 = _horner(b0_a2a, y);+ a = a1 / a2;+ } else {+ const xx = x - 0.785398164;+ y = 64 / y;+ a1 = _horner(b0_a1b, y);+ a2 = _horner(b0_a2b, y);+ a = Math.sqrt(W / x) * (Math.cos(xx) * a1 - Math.sin(xx) * a2 * 8 / x);+ }++ return a;+ }++ const b1_a1a = [-30.16036606, 15704.48260, -2972611.439, 242396853.1, -7895059235.0, 72362614232.0];+ const b1_a2a = [1.0, 376.9991397, 99447.43394, 18583304.74, 2300535178.0, 144725228442.0];+ const b1_a1b = [-0.240337019e-6, 0.2457520174e-5, -0.3516396496e-4, 0.183105e-2, 1.0];+ const b1_a2b = [0.105787412e-6, -0.88228987e-6, 0.8449199096e-5, -0.2002690873e-3, 0.04687499995];++ function bessel1(x: number): number {+ let a = 0;+ let a1 = 0;+ let a2 = 0;+ let y = x * x;+ const xx = Math.abs(x) - 2.356194491;++ if (Math.abs(x) < 8) {+ a1 = x * _horner(b1_a1a, y);+ a2 = _horner(b1_a2a, y);+ a = a1 / a2;+ } else {+ y = 64 / y;+ a1 = _horner(b1_a1b, y);+ a2 = _horner(b1_a2b, y);+ a = Math.sqrt(W / Math.abs(x)) * (Math.cos(xx) * a1 - Math.sin(xx) * a2 * 8 / Math.abs(x));++ if (x < 0) {+ a = -a;+ }+ }++ return a;+ }++ return function besselj(x: number, n: number): number {+ const _n = Math.round(n);++ if (!Number.isFinite(x)) {+ return Number.isNaN(x) ? x : 0;+ }++ if (_n < 0) {+ return ((_n % 2) ? -1 : 1) * besselj(x, -_n);+ }++ if (x < 0) {+ return ((_n % 2) ? -1 : 1) * besselj(-x, _n);+ }++ if (_n === 0) {+ return bessel0(x);+ }++ if (_n === 1) {+ return bessel1(x);+ }++ if (x === 0) {+ return 0;+ }++ let ret = 0.0;++ if (x > _n) {+ ret = _bessel_iter(x, _n, bessel0(x), bessel1(x), -1);+ } else {+ const m = 2 * Math.floor((_n + Math.floor(Math.sqrt(40 * _n))) / 2);+ let jsum = false;+ let bjp = 0.0;+ let sum = 0.0;+ let bj = 1.0;+ let bjm = 0.0;+ const tox = 2 / x;++ for (let j = m; j > 0; j--) {+ bjm = j * tox * bj - bjp;+ bjp = bj;+ bj = bjm;++ if (Math.abs(bj) > 1e10) {+ bj *= 1e-10;+ bjp *= 1e-10;+ ret *= 1e-10;+ sum *= 1e-10;+ }++ if (jsum) {+ sum += bj;+ }++ jsum = !jsum;++ if (j === _n) {+ ret = bjp;+ }+ }++ sum = 2.0 * sum - bj;+ ret /= sum;+ }++ return ret;+ };+ })();++ export const bessely = (() => {+ const b0_a1a = [228.4622733, -86327.92757, 10879881.29, -512359803.6, 7062834065.0, -2957821389.0];+ const b0_a2a = [1.0, 226.1030244, 47447.26470, 7189466.438, 745249964.8, 40076544269.0];+ const b0_a1b = [0.2093887211e-6, -0.2073370639e-5, 0.2734510407e-4, -0.1098628627e-2, 1.0];+ const b0_a2b = [-0.934945152e-7, 0.7621095161e-6, -0.6911147651e-5, 0.1430488765e-3, -0.1562499995e-1];++ function bessel0(x: number): number {+ let a = 0;+ let a1 = 0;+ let a2 = 0;+ let y = x * x;+ const xx = x - 0.785398164;++ if (x < 8) {+ a1 = _horner(b0_a1a, y);+ a2 = _horner(b0_a2a, y);+ a = a1 / a2 + W * besselj(x, 0) * Math.log(x);+ } else {+ y = 64 / y;+ a1 = _horner(b0_a1b, y);+ a2 = _horner(b0_a2b, y);+ a = Math.sqrt(W / x) * (Math.sin(xx) * a1 + Math.cos(xx) * a2 * 8 / x);+ }++ return a;+ }++ const b1_a1a = [0.8511937935e4, -0.4237922726e7, 0.7349264551e9, -0.5153438139e11, 0.1275274390e13, -0.4900604943e13];+ const b1_a2a = [1, 0.3549632885e3, 0.1020426050e6, 0.2245904002e8, 0.3733650367e10, 0.4244419664e12, 0.2499580570e14];+ const b1_a1b = [-0.240337019e-6, 0.2457520174e-5, -0.3516396496e-4, 0.183105e-2, 1.0];+ const b1_a2b = [0.105787412e-6, -0.88228987e-6, 0.8449199096e-5, -0.2002690873e-3, 0.04687499995];++ function bessel1(x: number): number {+ let a = 0;+ let a1 = 0;+ let a2 = 0;+ let y = x * x;+ const xx = x - 2.356194491;++ if (x < 8) {+ a1 = x * _horner(b1_a1a, y);+ a2 = _horner(b1_a2a, y);+ a = a1 / a2 + W * (besselj(x, 1) * Math.log(x) - 1 / x);+ } else {+ y = 64 / y;+ a1 = _horner(b1_a1b, y);+ a2 = _horner(b1_a2b, y);+ a = Math.sqrt(W / x) * (Math.sin(xx) * a1 + Math.cos(xx) * a2 * 8 / x);+ }++ return a;+ }++ return _bessel_wrap(bessel0, bessel1, 1, -1);+ })();++ export const besseli = (() => {+ const b0_a = [0.45813e-2, 0.360768e-1, 0.2659732, 1.2067492, 3.0899424, 3.5156229, 1.0];+ const b0_b = [0.392377e-2, -0.1647633e-1, 0.2635537e-1, -0.2057706e-1, 0.916281e-2, -0.157565e-2, 0.225319e-2, 0.1328592e-1, 0.39894228];++ function bessel0(x: number): number {+ if (x <= 3.75) {+ return _horner(b0_a, x * x / (3.75 * 3.75));+ }++ return Math.exp(Math.abs(x)) / Math.sqrt(Math.abs(x)) * _horner(b0_b, 3.75 / Math.abs(x));+ }++ const b1_a = [0.32411e-3, 0.301532e-2, 0.2658733e-1, 0.15084934, 0.51498869, 0.87890594, 0.5];+ const b1_b = [-0.420059e-2, 0.1787654e-1, -0.2895312e-1, 0.2282967e-1, -0.1031555e-1, 0.163801e-2, -0.362018e-2, -0.3988024e-1, 0.39894228];++ function bessel1(x: number): number {+ if (x < 3.75) {+ return x * _horner(b1_a, x * x / (3.75 * 3.75));+ }++ return (x < 0 ? -1 : 1) * Math.exp(Math.abs(x)) / Math.sqrt(Math.abs(x)) * _horner(b1_b, 3.75 / Math.abs(x));+ }++ return function besseli(x: number, n: number): number {+ const _n = Math.round(n);++ if (_n === 0) {+ return bessel0(x);+ }++ if (_n === 1) {+ return bessel1(x);+ }++ if (_n < 0) {+ return Number.NaN;+ }++ if (Math.abs(x) === 0) {+ return 0;+ }++ if (x === Infinity) {+ return Infinity;+ }++ let ret = 0.0;+ let j;+ const tox = 2 / Math.abs(x);+ let bip = 0.0;+ let bi = 1.0;+ let bim = 0.0;++ const m = 2 * Math.round((_n + Math.round(Math.sqrt(40 * _n))) / 2);++ for (j = m; j > 0; j--) {+ bim = j * tox * bi + bip;+ bip = bi;+ bi = bim;++ if (Math.abs(bi) > 1e10) {+ bi *= 1e-10;+ bip *= 1e-10;+ ret *= 1e-10;+ }++ if (j === _n) ret = bip;+ }++ ret *= besseli(x, 0) / bi;++ return x < 0 && (_n % 2) ? -ret : ret;+ };+ })();++ export const besselk = (() => {+ const b0_a = [0.74e-5, 0.10750e-3, 0.262698e-2, 0.3488590e-1, 0.23069756, 0.42278420, -0.57721566];+ const b0_b = [0.53208e-3, -0.251540e-2, 0.587872e-2, -0.1062446e-1, 0.2189568e-1, -0.7832358e-1, 1.25331414];++ function bessel0(x: number): number {+ if (x <= 2) {+ return -Math.log(x / 2) * besseli(x, 0) + _horner(b0_a, x * x / 4);+ }++ return Math.exp(-x) / Math.sqrt(x) * _horner(b0_b, 2 / x);+ }++ const b1_a = [-0.4686e-4, -0.110404e-2, -0.1919402e-1, -0.18156897, -0.67278579, 0.15443144, 1.0];+ const b1_b = [-0.68245e-3, 0.325614e-2, -0.780353e-2, 0.1504268e-1, -0.3655620e-1, 0.23498619, 1.25331414];++ function bessel1(x: number): number {+ if (x <= 2) {+ return Math.log(x / 2) * besseli(x, 1) + (1 / x) * _horner(b1_a, x * x / 4);+ }++ return Math.exp(-x) / Math.sqrt(x) * _horner(b1_b, 2 / x);+ }++ return _bessel_wrap(bessel0, bessel1, 2, 1);+ })();+}++export function isValidBinaryNumber(number: string): boolean {+ return /^[01]{1,10}$/.test(number);+}++export function isValidOctalNumber(number: string): boolean {+ return /^[0-7]{1,10}$/.test(number);+}++export function isValidHexadecimalNumber(number: string): boolean {+ return /^[0-9A-Fa-f]{1,10}$/.test(number);+}++export function erf(x: number): number {+ if (x === 0) {+ return 0;+ }++ // eslint-disable-next-line+ const cof = [-1.3026537197817094, 6.4196979235649026e-1, 1.9476473204185836e-2,+ -9.561514786808631e-3, -9.46595344482036e-4, 3.66839497852761e-4,+ 4.2523324806907e-5, -2.0278578112534e-5, -1.624290004647e-6,+ 1.303655835580e-6, 1.5626441722e-8, -8.5238095915e-8,+ 6.529054439e-9, 5.059343495e-9, -9.91364156e-10,+ -2.27365122e-10, 9.6467911e-11, 2.394038e-12,+ -6.886027e-12, 8.94487e-13, 3.13092e-13,+ -1.12708e-13, 3.81e-16, 7.106e-15,+ -1.523e-15, -9.4e-17, 1.21e-16,+ -2.8e-17];++ let _x = x;+ let isneg = false;++ if (_x < 0) {+ _x = -_x;+ isneg = true;+ }++ const t = 2 / (2 + _x);+ const ty = 4 * t - 2;++ let d = 0;+ let dd = 0;+ let tmp;++ for (let j = cof.length - 1; j > 0; j--) {+ tmp = d;+ d = ty * d - dd + cof[j];+ dd = tmp;+ }++ const res = t * Math.exp(-_x * _x + 0.5 * (cof[0] + ty * d) - dd);++ return isneg ? res - 1 : 1 - res;+};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.tsnew file mode 100644index 0000000000..69bf17fce3--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/besseli/__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 { Besseli } 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 besseli function', () => {+ const testFunction = new Besseli(FUNCTION_NAMES_ENGINEERING.BESSELI);++ describe('Besseli', () => {+ it('Value is normal number', () => {+ const x = NumberValueObject.create(1.5);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(0.981666428475166);+ });++ it('Value is number string', () => {+ const x = StringValueObject.create('-0.5');+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(-0.25789430328903556);+ });++ it('Value is normal string', () => {+ const x = StringValueObject.create('test');+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const x = BooleanValueObject.create(true);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const x = NullValueObject.create();+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NA);+ });++ it('Value is blank cell', () => {+ const x = ArrayValueObject.create({+ calculateValueList: transformToValueObject([+ [null],+ ]),+ rowCount: 1,+ columnCount: 1,+ unitId: '',+ sheetId: '',+ row: 0,+ column: 0,+ });+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const x = ErrorValueObject.create(ErrorType.NAME);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const x = 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 n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/besseli/index.ts b/packages/engine-formula/src/functions/engineering/besseli/index.tsnew file mode 100644index 0000000000..a6473b13c0--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/besseli/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 { BESSEL, checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+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';++export class Besseli extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(x: BaseValueObject, n: BaseValueObject) {+ if (x.isNull() || n.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x, n);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [xObject, nObject] = variants as BaseValueObject[];++ const xValue = +xObject.getValue();+ const nValue = Math.floor(+nObject.getValue());++ if (Number.isNaN(xValue) || Number.isNaN(nValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (nValue < 0) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ const result = BESSEL.besseli(xValue, nValue);++ if (Number.isNaN(result) || !Number.isFinite(result)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..c6bcdd401b--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/besselj/__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 { Besselj } 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 besselj function', () => {+ const testFunction = new Besselj(FUNCTION_NAMES_ENGINEERING.BESSELJ);++ describe('Besselj', () => {+ it('Value is normal number', () => {+ const x = NumberValueObject.create(1.5);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(0.5579365078908043);+ });++ it('Value is number string', () => {+ const x = StringValueObject.create('-0.5');+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(-0.24226845767957006);+ });++ it('Value is normal string', () => {+ const x = StringValueObject.create('test');+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const x = BooleanValueObject.create(true);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const x = NullValueObject.create();+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NA);+ });++ it('Value is blank cell', () => {+ const x = ArrayValueObject.create({+ calculateValueList: transformToValueObject([+ [null],+ ]),+ rowCount: 1,+ columnCount: 1,+ unitId: '',+ sheetId: '',+ row: 0,+ column: 0,+ });+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const x = ErrorValueObject.create(ErrorType.NAME);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const x = 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 n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/besselj/index.ts b/packages/engine-formula/src/functions/engineering/besselj/index.tsnew file mode 100644index 0000000000..3c6a4cfdf4--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/besselj/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 { BESSEL, checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+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';++export class Besselj extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(x: BaseValueObject, n: BaseValueObject) {+ if (x.isNull() || n.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x, n);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [xObject, nObject] = variants as BaseValueObject[];++ const xValue = +xObject.getValue();+ const nValue = Math.floor(+nObject.getValue());++ if (Number.isNaN(xValue) || Number.isNaN(nValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (nValue < 0) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ const result = BESSEL.besselj(xValue, nValue);++ if (Number.isNaN(result) || !Number.isFinite(result)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..2bb7382c45--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/besselk/__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 { Besselk } 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 besselk function', () => {+ const testFunction = new Besselk(FUNCTION_NAMES_ENGINEERING.BESSELK);++ describe('Besselk', () => {+ it('Value is normal number', () => {+ const x = NumberValueObject.create(1.5);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(0.2773878036322587);+ });++ it('Value is number string', () => {+ const x = StringValueObject.create('-0.5');+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const x = StringValueObject.create('test');+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const x = BooleanValueObject.create(true);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const x = NullValueObject.create();+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NA);+ });++ it('Value is blank cell', () => {+ const x = ArrayValueObject.create({+ calculateValueList: transformToValueObject([+ [null],+ ]),+ rowCount: 1,+ columnCount: 1,+ unitId: '',+ sheetId: '',+ row: 0,+ column: 0,+ });+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is error', () => {+ const x = ErrorValueObject.create(ErrorType.NAME);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const x = 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 n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/besselk/index.ts b/packages/engine-formula/src/functions/engineering/besselk/index.tsnew file mode 100644index 0000000000..5486bb1a0c--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/besselk/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 { BESSEL, checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+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';++export class Besselk extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(x: BaseValueObject, n: BaseValueObject) {+ if (x.isNull() || n.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x, n);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [xObject, nObject] = variants as BaseValueObject[];++ const xValue = +xObject.getValue();+ const nValue = Math.floor(+nObject.getValue());++ if (Number.isNaN(xValue) || Number.isNaN(nValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (nValue < 0) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ const result = BESSEL.besselk(xValue, nValue);++ if (Number.isNaN(result) || !Number.isFinite(result)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..36ca99bd73--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bessely/__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 { Bessely } 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 bessely function', () => {+ const testFunction = new Bessely(FUNCTION_NAMES_ENGINEERING.BESSELY);++ describe('Bessely', () => {+ it('Value is normal number', () => {+ const x = NumberValueObject.create(1.5);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(-0.41230862689590375);+ });++ it('Value is number string', () => {+ const x = StringValueObject.create('-0.5');+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const x = StringValueObject.create('test');+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const x = BooleanValueObject.create(true);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const x = NullValueObject.create();+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NA);+ });++ it('Value is blank cell', () => {+ const x = ArrayValueObject.create({+ calculateValueList: transformToValueObject([+ [null],+ ]),+ rowCount: 1,+ columnCount: 1,+ unitId: '',+ sheetId: '',+ row: 0,+ column: 0,+ });+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is error', () => {+ const x = ErrorValueObject.create(ErrorType.NAME);+ const n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const x = 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 n = NumberValueObject.create(1);+ const result = testFunction.calculate(x, n);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/bessely/index.ts b/packages/engine-formula/src/functions/engineering/bessely/index.tsnew file mode 100644index 0000000000..1fb1c840a5--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bessely/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 { BESSEL, checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+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';++export class Bessely extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(x: BaseValueObject, n: BaseValueObject) {+ if (x.isNull() || n.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x, n);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [xObject, nObject] = variants as BaseValueObject[];++ const xValue = +xObject.getValue();+ const nValue = Math.floor(+nObject.getValue());++ if (Number.isNaN(xValue) || Number.isNaN(nValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (nValue < 0) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ const result = BESSEL.bessely(xValue, nValue);++ if (Number.isNaN(result) || !Number.isFinite(result)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..746d5b33fb--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bin2dec/__tests__/index.spec.ts@@ -0,0 +1,83 @@+/**+ * 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 { Bin2dec } 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 bin2dec function', () => {+ const testFunction = new Bin2dec(FUNCTION_NAMES_ENGINEERING.BIN2DEC);++ describe('Bin2dec', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(1100100);+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(100);+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const number = NullValueObject.create();+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(0);+ });++ 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/bin2dec/index.ts b/packages/engine-formula/src/functions/engineering/bin2dec/index.tsnew file mode 100644index 0000000000..9973c8aed2--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bin2dec/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 { checkVariantsErrorIsArrayOrBoolean, isValidBinaryNumber } from '../../../basics/engineering';+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';++export class Bin2dec extends BaseFunction {+ override minParams = 1;++ override maxParams = 1;++ override calculate(number: BaseValueObject) {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not binary or contains more than 10 characters (10 digits)+ if (!isValidBinaryNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (numberValue.length === 10 && numberValue.substring(0, 1) === '1') {+ result = Number.parseInt(numberValue.substring(1), 2) - 512;+ } else {+ result = Number.parseInt(numberValue, 2);+ }++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..2409835169--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bin2hex/__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 { Bin2hex } 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 bin2hex function', () => {+ const testFunction = new Bin2hex(FUNCTION_NAMES_ENGINEERING.BIN2HEX);++ describe('Bin2hex', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(11111011);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('00FB');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('0000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/bin2hex/index.ts b/packages/engine-formula/src/functions/engineering/bin2hex/index.tsnew file mode 100644index 0000000000..006260e37e--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bin2hex/index.ts@@ -0,0 +1,89 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean, isValidBinaryNumber } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Bin2hex extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not binary or contains more than 10 characters (10 digits)+ if (!isValidBinaryNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (numberValue.length === 10 && numberValue.substring(0, 1) === '1') {+ result = (1099511627264 + Number.parseInt(numberValue.substring(1), 2)).toString(16);+ } else {+ result = Number.parseInt(numberValue, 2).toString(16);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + result;+ }+ }++ return StringValueObject.create(result.toLocaleUpperCase());+ }+}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.tsnew file mode 100644index 0000000000..ee5a3f4269--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bin2oct/__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 { Bin2oct } 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 bin2oct function', () => {+ const testFunction = new Bin2oct(FUNCTION_NAMES_ENGINEERING.BIN2OCT);++ describe('Bin2oct', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(1001);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('011');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/bin2oct/index.ts b/packages/engine-formula/src/functions/engineering/bin2oct/index.tsnew file mode 100644index 0000000000..7b9ab63c3a--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bin2oct/index.ts@@ -0,0 +1,89 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean, isValidBinaryNumber } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Bin2oct extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not binary or contains more than 10 characters (10 digits)+ if (!isValidBinaryNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (numberValue.length === 10 && numberValue.substring(0, 1) === '1') {+ result = (1073741312 + Number.parseInt(numberValue.substring(1), 2)).toString(8);+ } else {+ result = Number.parseInt(numberValue, 2).toString(8);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + result;+ }+ }++ return StringValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..64f65e4bc7--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitand/__tests__/index.spec.ts@@ -0,0 +1,93 @@+/**+ * 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 { Bitand } from '../index';+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';+import { ErrorType } from '../../../../basics/error-type';+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';++describe('Test bitand function', () => {+ const testFunction = new Bitand(FUNCTION_NAMES_ENGINEERING.BITAND);++ describe('Bitand', () => {+ it('Value is normal number', () => {+ const number1 = NumberValueObject.create(13);+ const number2 = NumberValueObject.create(25);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(9);+ });++ it('Value is number string', () => {+ const number1 = StringValueObject.create('1');+ const number2 = NumberValueObject.create(5);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(1);+ });++ it('Value is normal string', () => {+ const number1 = StringValueObject.create('test');+ const number2 = NumberValueObject.create(25);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number1 = BooleanValueObject.create(true);+ const number2 = NumberValueObject.create(25);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(1);+ });++ it('Value is blank cell', () => {+ const number1 = NullValueObject.create();+ const number2 = NumberValueObject.create(25);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const number1 = ErrorValueObject.create(ErrorType.NAME);+ const number2 = NumberValueObject.create(25);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const number1 = 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 number2 = NumberValueObject.create(25);+ const result = testFunction.calculate(number1, number2);+ expect(transformToValue(result.getArrayValue())).toStrictEqual([+ [1, ErrorType.VALUE, ErrorType.NUM, 1, 0, 0],+ [0, 0, ErrorType.NUM, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME],+ ]);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/bitand/index.ts b/packages/engine-formula/src/functions/engineering/bitand/index.tsnew file mode 100644index 0000000000..42f7f124c0--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitand/index.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 { 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 type { ArrayValueObject } from '../../../engine/value-object/array-value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';++export class Bitand extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(number1: BaseValueObject, number2: BaseValueObject) {+ if (number1.isError()) {+ return number1;+ }++ if (number2.isError()) {+ return number2;+ }++ const maxRowLength = Math.max(+ number1.isArray() ? (number1 as ArrayValueObject).getRowCount() : 1,+ number2.isArray() ? (number2 as ArrayValueObject).getRowCount() : 1+ );++ const maxColumnLength = Math.max(+ number1.isArray() ? (number1 as ArrayValueObject).getColumnCount() : 1,+ number2.isArray() ? (number2 as ArrayValueObject).getColumnCount() : 1+ );++ const number1Array = expandArrayValueObject(maxRowLength, maxColumnLength, number1, ErrorValueObject.create(ErrorType.NA));+ const number2Array = expandArrayValueObject(maxRowLength, maxColumnLength, number2, ErrorValueObject.create(ErrorType.NA));++ const resultArray = number1Array.map((itemObject, rowIndex, columnIndex) => {+ let number1Object = itemObject;++ if (number1Object.isString()) {+ number1Object = number1Object.convertToNumberObjectValue();+ }++ if (number1Object.isError()) {+ return number1Object;+ }++ let number2Object = number2Array.get(rowIndex, columnIndex) as BaseValueObject;++ if (number2Object.isString()) {+ number2Object = number2Object.convertToNumberObjectValue();+ }++ if (number2Object.isError()) {+ return number2Object;+ }++ const number1Value = +number1Object.getValue();+ const number2Value = +number2Object.getValue();++ // Return error if either number is less than 0+ // Return error if either number is a non-integer+ // Return error if either number is greater than (2^48)-1+ if (+ number1Value < 0 ||+ number2Value < 0 ||+ Math.floor(number1Value) !== number1Value ||+ Math.floor(number2Value) !== number2Value ||+ number1Value > 281474976710655 ||+ number2Value > 281474976710655+ ) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ const result = number1Value & number2Value;++ return NumberValueObject.create(result);+ });++ if (maxRowLength === 1 && maxColumnLength === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;+ }++ return resultArray;+ }+}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.tsnew file mode 100644index 0000000000..8aa1100b5f--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitlshift/__tests__/index.spec.ts@@ -0,0 +1,93 @@+/**+ * 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 { Bitlshift } from '../index';+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';+import { ErrorType } from '../../../../basics/error-type';+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';++describe('Test bitlshift function', () => {+ const testFunction = new Bitlshift(FUNCTION_NAMES_ENGINEERING.BITLSHIFT);++ describe('Bitlshift', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(4);+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(16);+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('1');+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(4);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(4);+ });++ it('Value is blank cell', () => {+ const number = NullValueObject.create();+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ 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 shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(transformToValue(result.getArrayValue())).toStrictEqual([+ [4, ErrorType.VALUE, ErrorType.NUM, 4, 0, 0],+ [0, 400, ErrorType.NUM, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME],+ ]);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/bitlshift/index.ts b/packages/engine-formula/src/functions/engineering/bitlshift/index.tsnew file mode 100644index 0000000000..2367eb3d43--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitlshift/index.ts@@ -0,0 +1,106 @@+/**+ * 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 type { ArrayValueObject } from '../../../engine/value-object/array-value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';++export class Bitlshift extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(number: BaseValueObject, shiftAmount: BaseValueObject) {+ if (number.isError()) {+ return number;+ }++ if (shiftAmount.isError()) {+ return shiftAmount;+ }++ const maxRowLength = Math.max(+ number.isArray() ? (number as ArrayValueObject).getRowCount() : 1,+ shiftAmount.isArray() ? (shiftAmount as ArrayValueObject).getRowCount() : 1+ );++ const maxColumnLength = Math.max(+ number.isArray() ? (number as ArrayValueObject).getColumnCount() : 1,+ shiftAmount.isArray() ? (shiftAmount as ArrayValueObject).getColumnCount() : 1+ );++ const numberArray = expandArrayValueObject(maxRowLength, maxColumnLength, number, ErrorValueObject.create(ErrorType.NA));+ const shiftAmountArray = expandArrayValueObject(maxRowLength, maxColumnLength, shiftAmount, ErrorValueObject.create(ErrorType.NA));++ const resultArray = numberArray.map((itemObject, rowIndex, columnIndex) => {+ let numberObject = itemObject;++ if (numberObject.isString()) {+ numberObject = numberObject.convertToNumberObjectValue();+ }++ if (numberObject.isError()) {+ return numberObject;+ }++ let shiftAmountObject = shiftAmountArray.get(rowIndex, columnIndex) as BaseValueObject;++ if (shiftAmountObject.isString()) {+ shiftAmountObject = shiftAmountObject.convertToNumberObjectValue();+ }++ if (shiftAmountObject.isError()) {+ return shiftAmountObject;+ }++ const numberValue = +numberObject.getValue();+ let shiftAmountValue = +shiftAmountObject.getValue();++ // Return error if number is less than 0+ // Return error if number is a non-integer+ // Return error if number is greater than (2^48)-1+ // Return error if the absolute value of shift is greater than 53+ if (+ numberValue < 0 ||+ Math.floor(numberValue) !== numberValue ||+ numberValue > 281474976710655 ||+ Math.abs(shiftAmountValue) > 53+ ) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ shiftAmountValue = Math.trunc(shiftAmountValue);++ // Return number shifted by shift bits to the left or to the right if shift is negative+ const result = Number(shiftAmountValue >= 0 ? BigInt(numberValue) << BigInt(shiftAmountValue) : BigInt(numberValue) >> BigInt(-shiftAmountValue));++ if (result > 281474976710655) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ return NumberValueObject.create(result);+ });++ if (maxRowLength === 1 && maxColumnLength === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;+ }++ return resultArray;+ }+}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.tsnew file mode 100644index 0000000000..50170542f1--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitor/__tests__/index.spec.ts@@ -0,0 +1,93 @@+/**+ * 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 { Bitor } from '../index';+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';+import { ErrorType } from '../../../../basics/error-type';+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';++describe('Test bitor function', () => {+ const testFunction = new Bitor(FUNCTION_NAMES_ENGINEERING.BITOR);++ describe('Bitor', () => {+ it('Value is normal number', () => {+ const number1 = NumberValueObject.create(23);+ const number2 = NumberValueObject.create(10);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(31);+ });++ it('Value is number string', () => {+ const number1 = StringValueObject.create('1');+ const number2 = NumberValueObject.create(10);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(11);+ });++ it('Value is normal string', () => {+ const number1 = StringValueObject.create('test');+ const number2 = NumberValueObject.create(10);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number1 = BooleanValueObject.create(true);+ const number2 = NumberValueObject.create(10);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(11);+ });++ it('Value is blank cell', () => {+ const number1 = NullValueObject.create();+ const number2 = NumberValueObject.create(10);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(10);+ });++ it('Value is error', () => {+ const number1 = ErrorValueObject.create(ErrorType.NAME);+ const number2 = NumberValueObject.create(10);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const number1 = 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 number2 = NumberValueObject.create(10);+ const result = testFunction.calculate(number1, number2);+ expect(transformToValue(result.getArrayValue())).toStrictEqual([+ [11, ErrorType.VALUE, ErrorType.NUM, 11, 10, 10],+ [10, 110, ErrorType.NUM, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME],+ ]);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/bitor/index.ts b/packages/engine-formula/src/functions/engineering/bitor/index.tsnew file mode 100644index 0000000000..b8ff50ef6c--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitor/index.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 { 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 type { ArrayValueObject } from '../../../engine/value-object/array-value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';++export class Bitor extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(number1: BaseValueObject, number2: BaseValueObject) {+ if (number1.isError()) {+ return number1;+ }++ if (number2.isError()) {+ return number2;+ }++ const maxRowLength = Math.max(+ number1.isArray() ? (number1 as ArrayValueObject).getRowCount() : 1,+ number2.isArray() ? (number2 as ArrayValueObject).getRowCount() : 1+ );++ const maxColumnLength = Math.max(+ number1.isArray() ? (number1 as ArrayValueObject).getColumnCount() : 1,+ number2.isArray() ? (number2 as ArrayValueObject).getColumnCount() : 1+ );++ const number1Array = expandArrayValueObject(maxRowLength, maxColumnLength, number1, ErrorValueObject.create(ErrorType.NA));+ const number2Array = expandArrayValueObject(maxRowLength, maxColumnLength, number2, ErrorValueObject.create(ErrorType.NA));++ const resultArray = number1Array.map((itemObject, rowIndex, columnIndex) => {+ let number1Object = itemObject;++ if (number1Object.isString()) {+ number1Object = number1Object.convertToNumberObjectValue();+ }++ if (number1Object.isError()) {+ return number1Object;+ }++ let number2Object = number2Array.get(rowIndex, columnIndex) as BaseValueObject;++ if (number2Object.isString()) {+ number2Object = number2Object.convertToNumberObjectValue();+ }++ if (number2Object.isError()) {+ return number2Object;+ }++ const number1Value = +number1Object.getValue();+ const number2Value = +number2Object.getValue();++ // Return error if either number is less than 0+ // Return error if either number is a non-integer+ // Return error if either number is greater than (2^48)-1+ if (+ number1Value < 0 ||+ number2Value < 0 ||+ Math.floor(number1Value) !== number1Value ||+ Math.floor(number2Value) !== number2Value ||+ number1Value > 281474976710655 ||+ number2Value > 281474976710655+ ) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ const result = Number(BigInt(number1Value) | BigInt(number2Value));++ return NumberValueObject.create(result);+ });++ if (maxRowLength === 1 && maxColumnLength === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;+ }++ return resultArray;+ }+}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.tsnew file mode 100644index 0000000000..7bc7ecf94a--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitrshift/__tests__/index.spec.ts@@ -0,0 +1,93 @@+/**+ * 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 { Bitrshift } from '../index';+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';+import { ErrorType } from '../../../../basics/error-type';+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';++describe('Test bitrshift function', () => {+ const testFunction = new Bitrshift(FUNCTION_NAMES_ENGINEERING.BITRSHIFT);++ describe('Bitrshift', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(13);+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(3);+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('1');+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(0);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(0);+ });++ it('Value is blank cell', () => {+ const number = NullValueObject.create();+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ 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 shiftAmount = NumberValueObject.create(2);+ const result = testFunction.calculate(number, shiftAmount);+ expect(transformToValue(result.getArrayValue())).toStrictEqual([+ [0, ErrorType.VALUE, ErrorType.NUM, 0, 0, 0],+ [0, 25, ErrorType.NUM, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME],+ ]);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/bitrshift/index.ts b/packages/engine-formula/src/functions/engineering/bitrshift/index.tsnew file mode 100644index 0000000000..cec017558d--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitrshift/index.ts@@ -0,0 +1,106 @@+/**+ * 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 type { ArrayValueObject } from '../../../engine/value-object/array-value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';++export class Bitrshift extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(number: BaseValueObject, shiftAmount: BaseValueObject) {+ if (number.isError()) {+ return number;+ }++ if (shiftAmount.isError()) {+ return shiftAmount;+ }++ const maxRowLength = Math.max(+ number.isArray() ? (number as ArrayValueObject).getRowCount() : 1,+ shiftAmount.isArray() ? (shiftAmount as ArrayValueObject).getRowCount() : 1+ );++ const maxColumnLength = Math.max(+ number.isArray() ? (number as ArrayValueObject).getColumnCount() : 1,+ shiftAmount.isArray() ? (shiftAmount as ArrayValueObject).getColumnCount() : 1+ );++ const numberArray = expandArrayValueObject(maxRowLength, maxColumnLength, number, ErrorValueObject.create(ErrorType.NA));+ const shiftAmountArray = expandArrayValueObject(maxRowLength, maxColumnLength, shiftAmount, ErrorValueObject.create(ErrorType.NA));++ const resultArray = numberArray.map((itemObject, rowIndex, columnIndex) => {+ let numberObject = itemObject;++ if (numberObject.isString()) {+ numberObject = numberObject.convertToNumberObjectValue();+ }++ if (numberObject.isError()) {+ return numberObject;+ }++ let shiftAmountObject = shiftAmountArray.get(rowIndex, columnIndex) as BaseValueObject;++ if (shiftAmountObject.isString()) {+ shiftAmountObject = shiftAmountObject.convertToNumberObjectValue();+ }++ if (shiftAmountObject.isError()) {+ return shiftAmountObject;+ }++ const numberValue = +numberObject.getValue();+ let shiftAmountValue = +shiftAmountObject.getValue();++ // Return error if number is less than 0+ // Return error if number is a non-integer+ // Return error if number is greater than (2^48)-1+ // Return error if the absolute value of shift is greater than 53+ if (+ numberValue < 0 ||+ Math.floor(numberValue) !== numberValue ||+ numberValue > 281474976710655 ||+ Math.abs(shiftAmountValue) > 53+ ) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ shiftAmountValue = Math.trunc(shiftAmountValue);++ // Return number shifted by shift bits to the right or to the left if shift is negative+ const result = Number(shiftAmountValue >= 0 ? BigInt(numberValue) >> BigInt(shiftAmountValue) : BigInt(numberValue) << BigInt(-shiftAmountValue));++ if (result > 281474976710655) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ return NumberValueObject.create(result);+ });++ if (maxRowLength === 1 && maxColumnLength === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;+ }++ return resultArray;+ }+}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.tsnew file mode 100644index 0000000000..b4b2a34b82--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitxor/__tests__/index.spec.ts@@ -0,0 +1,93 @@+/**+ * 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 { Bitxor } from '../index';+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';+import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';+import { ErrorType } from '../../../../basics/error-type';+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';++describe('Test bitxor function', () => {+ const testFunction = new Bitxor(FUNCTION_NAMES_ENGINEERING.BITXOR);++ describe('Bitxor', () => {+ it('Value is normal number', () => {+ const number1 = NumberValueObject.create(5);+ const number2 = NumberValueObject.create(3);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(6);+ });++ it('Value is number string', () => {+ const number1 = StringValueObject.create('1');+ const number2 = NumberValueObject.create(3);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(2);+ });++ it('Value is normal string', () => {+ const number1 = StringValueObject.create('test');+ const number2 = NumberValueObject.create(3);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number1 = BooleanValueObject.create(true);+ const number2 = NumberValueObject.create(3);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(2);+ });++ it('Value is blank cell', () => {+ const number1 = NullValueObject.create();+ const number2 = NumberValueObject.create(3);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(3);+ });++ it('Value is error', () => {+ const number1 = ErrorValueObject.create(ErrorType.NAME);+ const number2 = NumberValueObject.create(3);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const number1 = 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 number2 = NumberValueObject.create(3);+ const result = testFunction.calculate(number1, number2);+ expect(transformToValue(result.getArrayValue())).toStrictEqual([+ [2, ErrorType.VALUE, ErrorType.NUM, 2, 3, 3],+ [3, 103, ErrorType.NUM, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME],+ ]);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/bitxor/index.ts b/packages/engine-formula/src/functions/engineering/bitxor/index.tsnew file mode 100644index 0000000000..8eaeb0dd75--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/bitxor/index.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 { 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 type { ArrayValueObject } from '../../../engine/value-object/array-value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';++export class Bitxor extends BaseFunction {+ override minParams = 2;++ override maxParams = 2;++ override calculate(number1: BaseValueObject, number2: BaseValueObject) {+ if (number1.isError()) {+ return number1;+ }++ if (number2.isError()) {+ return number2;+ }++ const maxRowLength = Math.max(+ number1.isArray() ? (number1 as ArrayValueObject).getRowCount() : 1,+ number2.isArray() ? (number2 as ArrayValueObject).getRowCount() : 1+ );++ const maxColumnLength = Math.max(+ number1.isArray() ? (number1 as ArrayValueObject).getColumnCount() : 1,+ number2.isArray() ? (number2 as ArrayValueObject).getColumnCount() : 1+ );++ const number1Array = expandArrayValueObject(maxRowLength, maxColumnLength, number1, ErrorValueObject.create(ErrorType.NA));+ const number2Array = expandArrayValueObject(maxRowLength, maxColumnLength, number2, ErrorValueObject.create(ErrorType.NA));++ const resultArray = number1Array.map((itemObject, rowIndex, columnIndex) => {+ let number1Object = itemObject;++ if (number1Object.isString()) {+ number1Object = number1Object.convertToNumberObjectValue();+ }++ if (number1Object.isError()) {+ return number1Object;+ }++ let number2Object = number2Array.get(rowIndex, columnIndex) as BaseValueObject;++ if (number2Object.isString()) {+ number2Object = number2Object.convertToNumberObjectValue();+ }++ if (number2Object.isError()) {+ return number2Object;+ }++ const number1Value = +number1Object.getValue();+ const number2Value = +number2Object.getValue();++ // Return error if either number is less than 0+ // Return error if either number is a non-integer+ // Return error if either number is greater than (2^48)-1+ if (+ number1Value < 0 ||+ number2Value < 0 ||+ Math.floor(number1Value) !== number1Value ||+ Math.floor(number2Value) !== number2Value ||+ number1Value > 281474976710655 ||+ number2Value > 281474976710655+ ) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ const result = number1Value ^ number2Value;++ return NumberValueObject.create(result);+ });++ if (maxRowLength === 1 && maxColumnLength === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;+ }++ return resultArray;+ }+}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.tsnew file mode 100644index 0000000000..b17217f4db--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts@@ -0,0 +1,105 @@+/**+ * 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 { Complex } 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 complex function', () => {+ const testFunction = new Complex(FUNCTION_NAMES_ENGINEERING.COMPLEX);++ describe('Complex', () => {+ it('Value is normal number', () => {+ const realNum = NumberValueObject.create(3);+ const iNum = NumberValueObject.create(4);+ const suffix = StringValueObject.create('i');+ const result = testFunction.calculate(realNum, iNum, suffix);+ expect(result.getValue()).toBe('3+4i');+ });++ it('Value is number string', () => {+ const realNum = StringValueObject.create('-0.5');+ const iNum = NumberValueObject.create(4);+ const suffix = StringValueObject.create('i');+ const result = testFunction.calculate(realNum, iNum, suffix);+ expect(result.getValue()).toBe('-0.5+4i');+ });++ it('Value is normal string', () => {+ const realNum = StringValueObject.create('test');+ const iNum = NumberValueObject.create(4);+ const suffix = StringValueObject.create('i');+ const result = testFunction.calculate(realNum, iNum, suffix);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const realNum = BooleanValueObject.create(true);+ const iNum = NumberValueObject.create(4);+ const suffix = StringValueObject.create('i');+ const result = testFunction.calculate(realNum, iNum, suffix);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const realNum = NullValueObject.create();+ const iNum = NumberValueObject.create(4);+ const suffix = StringValueObject.create('i');+ const result = testFunction.calculate(realNum, iNum, suffix);+ expect(result.getValue()).toBe('4i');+ });++ it('Value is error', () => {+ const realNum = ErrorValueObject.create(ErrorType.NAME);+ const iNum = NumberValueObject.create(4);+ const suffix = StringValueObject.create('i');+ const result = testFunction.calculate(realNum, iNum, suffix);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Suffix value is not i or j', () => {+ const realNum = NumberValueObject.create(3);+ const iNum = NumberValueObject.create(4);+ const suffix = StringValueObject.create('test');+ const result = testFunction.calculate(realNum, iNum, suffix);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is array', () => {+ const realNum = 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 iNum = NumberValueObject.create(4);+ const suffix = StringValueObject.create('i');+ const result = testFunction.calculate(realNum, iNum, suffix);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/complex/index.ts b/packages/engine-formula/src/functions/engineering/complex/index.tsnew file mode 100644index 0000000000..8e32664597--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/complex/index.ts@@ -0,0 +1,72 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';++export class Complex extends BaseFunction {+ override minParams = 2;++ override maxParams = 3;++ override calculate(realNum: BaseValueObject, iNum: BaseValueObject, suffix?: BaseValueObject) {+ const _suffix = suffix ?? StringValueObject.create('i');++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(realNum, iNum, _suffix);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [realNumObject, iNumObject, suffixObject] = variants as BaseValueObject[];++ const realNumValue = +realNumObject.getValue();+ const iNumValue = +iNumObject.getValue();+ const suffixValue = `${suffixObject.getValue()}`;++ if (+ Number.isNaN(realNumValue) ||+ Number.isNaN(iNumValue) ||+ (suffixValue !== 'i' && suffixValue !== 'j')+ ) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (realNumValue === 0 && iNumValue === 0) {+ return NumberValueObject.create(0);+ }++ if (realNumValue === 0) {+ if (iNumValue === 1) {+ return StringValueObject.create(suffixValue);+ }++ return StringValueObject.create(`${iNumValue}${suffixValue}`);+ }++ if (iNumValue === 0) {+ return NumberValueObject.create(realNumValue);+ }++ const sign = iNumValue > 0 ? '+' : '';+ const suffixStr = iNumValue === 1 ? suffixValue : `${iNumValue}${suffixValue}`;++ return StringValueObject.create(`${realNumValue}${sign}${suffixStr}`);+ }+}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.tsnew file mode 100644index 0000000000..6ec66e9709--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/convert/__tests__/index.spec.ts@@ -0,0 +1,105 @@+/**+ * 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 { Convert } 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 convert function', () => {+ const testFunction = new Convert(FUNCTION_NAMES_ENGINEERING.CONVERT);++ describe('Convert', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(1);+ const fromUnit = StringValueObject.create('lbm');+ const toUnit = StringValueObject.create('kg');+ const result = testFunction.calculate(number, fromUnit, toUnit);+ expect(result.getValue()).toBe(0.45359237);+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const fromUnit = StringValueObject.create('lbm');+ const toUnit = StringValueObject.create('kg');+ const result = testFunction.calculate(number, fromUnit, toUnit);+ expect(result.getValue()).toBe(-0.226796185);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const fromUnit = StringValueObject.create('lbm');+ const toUnit = StringValueObject.create('kg');+ const result = testFunction.calculate(number, fromUnit, toUnit);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const fromUnit = StringValueObject.create('lbm');+ const toUnit = StringValueObject.create('kg');+ const result = testFunction.calculate(number, fromUnit, toUnit);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const number = NullValueObject.create();+ const fromUnit = StringValueObject.create('lbm');+ const toUnit = StringValueObject.create('kg');+ const result = testFunction.calculate(number, fromUnit, toUnit);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const fromUnit = StringValueObject.create('lbm');+ const toUnit = StringValueObject.create('kg');+ const result = testFunction.calculate(number, fromUnit, toUnit);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Units represent different quantities', () => {+ const number = NumberValueObject.create(2.5);+ const fromUnit = StringValueObject.create('ft');+ const toUnit = StringValueObject.create('sec');+ const result = testFunction.calculate(number, fromUnit, toUnit);+ expect(result.getValue()).toBe(ErrorType.NA);+ });++ 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 fromUnit = StringValueObject.create('lbm');+ const toUnit = StringValueObject.create('kg');+ const result = testFunction.calculate(number, fromUnit, toUnit);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/convert/index.ts b/packages/engine-formula/src/functions/engineering/convert/index.tsnew file mode 100644index 0000000000..4376fdf2b0--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/convert/index.ts@@ -0,0 +1,479 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+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';++type IUnitItem = Array<string | Array<string> | number | boolean | null>;++interface IPrefixesKey {+ [index: string]: Array<string | number>;+}++export class Convert extends BaseFunction {+ override minParams = 3;++ override maxParams = 3;++ override calculate(number: BaseValueObject, fromUnit: BaseValueObject, toUnit: BaseValueObject) {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number, fromUnit, toUnit);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject, fromUnitObject, toUnitObject] = variants as BaseValueObject[];++ const numberValue = +numberObject.getValue();+ const fromUnitValue = `${fromUnitObject.getValue()}`;+ const toUnitValue = `${toUnitObject.getValue()}`;++ if (Number.isNaN(numberValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ // Initialize units and multipliers+ let from: IUnitItem | null;+ let fromMultiplier = 1;++ let to: IUnitItem | null;+ let toMultiplier = 1;++ // Lookup from and to units+ const { _from, _to } = this._lookupFromAndToUnits(fromUnitValue, toUnitValue);++ from = _from;+ to = _to;++ // Lookup from prefix+ if (from === null) {+ const { _from, _fromMultiplier } = this._lookupFromPrefix(fromUnitValue);+ from = _from;+ fromMultiplier = _fromMultiplier;+ }++ // Lookup to prefix+ if (to === null) {+ const { _to, _toMultiplier } = this._lookupToPrefix(toUnitValue);+ to = _to;+ toMultiplier = _toMultiplier;+ }++ // Return error if a unit does not exist+ if (from === null || to === null) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ // Return error if units represent different quantities+ if (from[3] !== to[3]) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let result;++ if (from[3] === 'temperature') {+ result = this._getTemperatureConversion(numberValue, from[1] as string, to[1] as string);+ } else {+ result = (numberValue * (from[6] as number) * fromMultiplier) / ((to[6] as number) * toMultiplier);+ }++ return NumberValueObject.create(result);+ }++ private _lookupFromAndToUnits(fromUnitValue: string, toUnitValue: string) {+ let _from = null;+ let _to = null;+ let alt;++ for (let i = 0; i < this._units.length; i++) {+ alt = this._units[i][2] === null ? [] : this._units[i][2];++ if (this._units[i][1] === fromUnitValue || (alt as Array<string>).indexOf(fromUnitValue) >= 0) {+ _from = this._units[i];+ }++ if (this._units[i][1] === toUnitValue || (alt as Array<string>).indexOf(toUnitValue) >= 0) {+ _to = this._units[i];+ }+ }++ return {+ _from,+ _to,+ };+ }++ private _lookupFromPrefix(fromUnitValue: string) {+ let _from = null;+ let _fromMultiplier = 1;+ let baseFromUnit = fromUnitValue;+ let alt;++ const fromBinaryPrefix = this._binaryPrefixes[fromUnitValue.substring(0, 2)];+ let fromUnitPrefix = this._unitPrefixes[fromUnitValue.substring(0, 1)];++ // Handle dekao unit prefix (only unit prefix with two characters)+ if (fromUnitValue.substring(0, 2) === 'da') {+ fromUnitPrefix = ['dekao', 1e1, 'da'];+ }++ // Handle binary prefixes first (so that 'Yi' is processed before 'Y')+ if (fromBinaryPrefix) {+ _fromMultiplier = fromBinaryPrefix[2] as number;+ baseFromUnit = fromUnitValue.substring(2);+ } else if (fromUnitPrefix) {+ _fromMultiplier = fromUnitPrefix[1] as number;+ baseFromUnit = fromUnitValue.substring((fromUnitPrefix[2] as string).length);+ }++ // Lookup from unit+ for (let j = 0; j < this._units.length; j++) {+ alt = this._units[j][2] === null ? [] : this._units[j][2];++ if (this._units[j][1] === baseFromUnit || (alt as Array<string>).indexOf(baseFromUnit) >= 0) {+ _from = this._units[j];+ }+ }++ return {+ _from,+ _fromMultiplier,+ };+ }++ private _lookupToPrefix(toUnitValue: string) {+ let _to = null;+ let _toMultiplier = 1;+ let baseToUnit = toUnitValue;+ let alt;++ const toBinaryPrefix = this._binaryPrefixes[toUnitValue.substring(0, 2)];+ let toUnitPrefix = this._unitPrefixes[toUnitValue.substring(0, 1)];++ // Handle dekao unit prefix (only unit prefix with two characters)+ if (toUnitValue.substring(0, 2) === 'da') {+ toUnitPrefix = ['dekao', 1e1, 'da'];+ }++ // Handle binary prefixes first (so that 'Yi' is processed before 'Y')+ if (toBinaryPrefix) {+ _toMultiplier = toBinaryPrefix[2] as number;+ baseToUnit = toUnitValue.substring(2);+ } else if (toUnitPrefix) {+ _toMultiplier = toUnitPrefix[1] as number;+ baseToUnit = toUnitValue.substring((toUnitPrefix[2] as string).length);+ }++ // Lookup to unit+ for (let k = 0; k < this._units.length; k++) {+ alt = this._units[k][2] === null ? [] : this._units[k][2];++ if (this._units[k][1] === baseToUnit || (alt as Array<string>).indexOf(baseToUnit) >= 0) {+ _to = this._units[k];+ }+ }++ return {+ _to,+ _toMultiplier,+ };+ }++ private _getTemperatureConversion(number: number, from: string, to: string) {+ switch (from) {+ case 'C':+ return this._centigradeConversion(number, to);+ case 'F':+ return this._fahrenheitConversion(number, to);+ case 'K':+ return this._kelvinConversion(number, to);+ case 'Rank':+ return this._rankineConversion(number, to);+ case 'Reau':+ return this._reaumurConversion(number, to);+ default:+ return number;+ }+ }++ private _centigradeConversion(number: number, to: string) {+ switch (to) {+ case 'F':+ return (number * 9 / 5) + 32;+ case 'K':+ return number + 273.15;+ case 'Rank':+ return (number + 273.15) * 9 / 5;+ case 'Reau':+ return number * 4 / 5;+ default:+ return number;+ }+ }++ private _fahrenheitConversion(number: number, to: string) {+ switch (to) {+ case 'C':+ return (number - 32) * 5 / 9;+ case 'K':+ return (number - 32) * 5 / 9 + 273.15;+ case 'Rank':+ return number + 459.67;+ case 'Reau':+ return (number - 32) * 4 / 9;+ default:+ return number;+ }+ }++ private _kelvinConversion(number: number, to: string) {+ switch (to) {+ case 'C':+ return number - 273.15;+ case 'F':+ return (number - 273.15) * 9 / 5 + 32;+ case 'Rank':+ return number * 9 / 5;+ case 'Reau':+ return (number - 273.15) * 4 / 5;+ default:+ return number;+ }+ }++ private _rankineConversion(number: number, to: string) {+ switch (to) {+ case 'C':+ return (number - 491.67) * 5 / 9;+ case 'F':+ return number - 459.67;+ case 'K':+ return number * 5 / 9;+ case 'Reau':+ return (number - 491.67) * 4 / 9;+ default:+ return number;+ }+ }++ private _reaumurConversion(number: number, to: string) {+ switch (to) {+ case 'C':+ return number * 5 / 4;+ case 'F':+ return (number * 9 / 4) + 32;+ case 'K':+ return (number * 5 / 4) + 273.15;+ case 'Rank':+ return (number * 9 / 4) + 491.67;+ default:+ return number;+ }+ }++ // List of units supported by CONVERT and units defined by the International System of Units+ // [Name, Symbol, Alternate symbols, Quantity, ISU, CONVERT, Conversion ratio]+ private _units: Array<IUnitItem> = [+ ['a.u. of action', '?', null, 'action', false, false, 1.05457168181818e-34],+ ['a.u. of charge', 'e', null, 'electric_charge', false, false, 1.60217653141414e-19],+ ['a.u. of energy', 'Eh', null, 'energy', false, false, 4.35974417757576e-18],+ ['a.u. of length', 'a?', null, 'length', false, false, 5.29177210818182e-11],+ ['a.u. of mass', 'm?', null, 'mass', false, false, 9.10938261616162e-31],+ ['a.u. of time', '?/Eh', null, 'time', false, false, 2.41888432650516e-17],+ ['admiralty knot', 'admkn', null, 'speed', false, true, 0.514773333],+ ['ampere', 'A', null, 'electric_current', true, false, 1],+ ['ampere per meter', 'A/m', null, 'magnetic_field_intensity', true, false, 1],+ ['ångström', 'Å', ['ang'], 'length', false, true, 1e-10],+ ['are', 'ar', null, 'area', false, true, 100],+ ['astronomical unit', 'ua', null, 'length', false, false, 1.49597870691667e-11],+ ['bar', 'bar', null, 'pressure', false, false, 100000],+ ['barn', 'b', null, 'area', false, false, 1e-28],+ ['becquerel', 'Bq', null, 'radioactivity', true, false, 1],+ ['bit', 'bit', ['b'], 'information', false, true, 1],+ ['btu', 'BTU', ['btu'], 'energy', false, true, 1055.05585262],+ ['byte', 'byte', null, 'information', false, true, 8],+ ['candela', 'cd', null, 'luminous_intensity', true, false, 1],+ ['candela per square metre', 'cd/m?', null, 'luminance', true, false, 1],+ ['centigrade', 'C', ['cel'], 'temperature', true, false, 1],+ ['cubic ångström', 'ang3', ['ang^3'], 'volume', false, true, 1e-30],+ ['cubic foot', 'ft3', ['ft^3'], 'volume', false, true, 0.028316846592],+ ['cubic inch', 'in3', ['in^3'], 'volume', false, true, 0.000016387064],+ ['cubic light-year', 'ly3', ['ly^3'], 'volume', false, true, 8.46786664623715e-47],+ ['cubic metre', 'm3', ['m^3'], 'volume', true, true, 1],+ ['cubic mile', 'mi3', ['mi^3'], 'volume', false, true, 4168181825.44058],+ ['cubic nautical mile', 'Nmi3', ['Nmi^3'], 'volume', false, true, 6352182208],+ ['cubic Pica', 'Pica3', ['Picapt3', 'Pica^3', 'Picapt^3'], 'volume', false, true, 7.58660370370369e-8],+ ['cubic yard', 'yd3', ['yd^3'], 'volume', false, true, 0.764554857984],+ ['cup', 'cup', null, 'volume', false, true, 0.0002365882365],+ ['dalton', 'Da', ['u'], 'mass', false, false, 1.66053886282828e-27],+ ['day', 'd', ['day'], 'time', false, true, 86400],+ ['degree', '°', null, 'angle', false, false, 0.0174532925199433],+ ['dyne', 'dyn', ['dy'], 'force', false, true, 0.00001],+ ['electronvolt', 'eV', ['ev'], 'energy', false, true, 1.60217656514141],+ ['ell', 'ell', null, 'length', false, true, 1.143],+ ['erg', 'erg', ['e'], 'energy', false, true, 1e-7],+ ['fahrenheit', 'F', ['fah'], 'temperature', true, false, 1],+ ['fluid ounce', 'oz', null, 'volume', false, true, 0.0000295735295625],+ ['foot', 'ft', null, 'length', false, true, 0.3048],+ ['foot-pound', 'flb', null, 'energy', false, true, 1.3558179483314],+ ['gal', 'Gal', null, 'acceleration', false, false, 0.01],+ ['gallon', 'gal', null, 'volume', false, true, 0.003785411784],+ ['gauss', 'G', ['ga'], 'magnetic_flux_density', false, true, 1],+ ['grain', 'grain', null, 'mass', false, true, 0.0000647989],+ ['gram', 'g', null, 'mass', false, true, 0.001],+ ['gray', 'Gy', null, 'absorbed_dose', true, false, 1],+ ['gross registered ton', 'GRT', ['regton'], 'volume', false, true, 2.8316846592],+ ['hectare', 'ha', null, 'area', false, true, 10000],+ ['henry', 'H', null, 'inductance', true, false, 1],+ ['hertz', 'Hz', null, 'frequency', true, false, 1],+ ['horsepower', 'HP', ['h'], 'power', false, true, 745.69987158227],+ ['horsepower-hour', 'HPh', ['hh', 'hph'], 'energy', false, true, 2684519.538],+ ['hour', 'h', ['hr'], 'time', false, true, 3600],+ ['imperial gallon (U.K.)', 'uk_gal', null, 'volume', false, true, 0.00454609],+ ['imperial hundredweight', 'lcwt', ['uk_cwt', 'hweight'], 'mass', false, true, 50.802345],+ ['imperial quart (U.K)', 'uk_qt', null, 'volume', false, true, 0.0011365225],+ ['imperial ton', 'brton', ['uk_ton', 'LTON'], 'mass', false, true, 1016.046909],+ ['inch', 'in', null, 'length', false, true, 0.0254],+ ['international acre', 'uk_acre', null, 'area', false, true, 4046.8564224],+ ['IT calorie', 'cal', null, 'energy', false, true, 4.1868],+ ['joule', 'J', null, 'energy', true, true, 1],+ ['katal', 'kat', null, 'catalytic_activity', true, false, 1],+ ['kelvin', 'K', ['kel'], 'temperature', true, true, 1],+ ['kilogram', 'kg', null, 'mass', true, true, 1],+ ['knot', 'kn', null, 'speed', false, true, 0.514444444444444],+ ['light-year', 'ly', null, 'length', false, true, 9460730472580800],+ ['litre', 'L', ['l', 'lt'], 'volume', false, true, 0.001],+ ['lumen', 'lm', null, 'luminous_flux', true, false, 1],+ ['lux', 'lx', null, 'illuminance', true, false, 1],+ ['maxwell', 'Mx', null, 'magnetic_flux', false, false, 1e-18],+ ['measurement ton', 'MTON', null, 'volume', false, true, 1.13267386368],+ ['meter per hour', 'm/h', ['m/hr'], 'speed', false, true, 0.00027777777777778],+ ['meter per second', 'm/s', ['m/sec'], 'speed', true, true, 1],+ ['meter per second squared', 'm?s??', null, 'acceleration', true, false, 1],+ ['parsec', 'pc', ['parsec'], 'length', false, true, 30856775814671900],+ ['meter squared per second', 'm?/s', null, 'kinematic_viscosity', true, false, 1],+ ['metre', 'm', null, 'length', true, true, 1],+ ['miles per hour', 'mph', null, 'speed', false, true, 0.44704],+ ['millimetre of mercury', 'mmHg', null, 'pressure', false, false, 133.322],+ ['minute', '?', null, 'angle', false, false, 0.000290888208665722],+ ['minute', 'min', ['mn'], 'time', false, true, 60],+ ['modern teaspoon', 'tspm', null, 'volume', false, true, 0.000005],+ ['mole', 'mol', null, 'amount_of_substance', true, false, 1],+ ['morgen', 'Morgen', null, 'area', false, true, 2500],+ ['n.u. of action', '?', null, 'action', false, false, 1.05457168181818e-34],+ ['n.u. of mass', 'm?', null, 'mass', false, false, 9.10938261616162e-31],+ ['n.u. of speed', 'c?', null, 'speed', false, false, 299792458],+ ['n.u. of time', '?/(me?c??)', null, 'time', false, false, 1.28808866778687e-21],+ ['nautical mile', 'M', ['Nmi'], 'length', false, true, 1852],+ ['newton', 'N', null, 'force', true, true, 1],+ ['œrsted', 'Oe ', null, 'magnetic_field_intensity', false, false, 79.5774715459477],+ ['ohm', 'Ω', null, 'electric_resistance', true, false, 1],+ ['ounce mass', 'ozm', null, 'mass', false, true, 0.028349523125],+ ['pascal', 'Pa', null, 'pressure', true, false, 1],+ ['pascal second', 'Pa?s', null, 'dynamic_viscosity', true, false, 1],+ ['pferdestärke', 'PS', null, 'power', false, true, 735.49875],+ ['phot', 'ph', null, 'illuminance', false, false, 0.0001],+ ['pica (1/6 inch)', 'pica', null, 'length', false, true, 0.00035277777777778],+ ['pica (1/72 inch)', 'Pica', ['Picapt'], 'length', false, true, 0.00423333333333333],+ ['poise', 'P', null, 'dynamic_viscosity', false, false, 0.1],+ ['pond', 'pond', null, 'force', false, true, 0.00980665],+ ['pound force', 'lbf', null, 'force', false, true, 4.4482216152605],+ ['pound mass', 'lbm', null, 'mass', false, true, 0.45359237],+ ['quart', 'qt', null, 'volume', false, true, 0.000946352946],+ ['radian', 'rad', null, 'angle', true, false, 1],+ ['rankine', 'Rank', null, 'temperature', false, true, 1],+ ['reaumur', 'Reau', null, 'temperature', false, true, 1],+ ['second', '?', null, 'angle', false, false, 0.00000484813681109536],+ ['second', 's', ['sec'], 'time', true, true, 1],+ ['short hundredweight', 'cwt', ['shweight'], 'mass', false, true, 45.359237],+ ['siemens', 'S', null, 'electrical_conductance', true, false, 1],+ ['sievert', 'Sv', null, 'equivalent_dose', true, false, 1],+ ['slug', 'sg', null, 'mass', false, true, 14.59390294],+ ['square ångström', 'ang2', ['ang^2'], 'area', false, true, 1e-20],+ ['square foot', 'ft2', ['ft^2'], 'area', false, true, 0.09290304],+ ['square inch', 'in2', ['in^2'], 'area', false, true, 0.00064516],+ ['square light-year', 'ly2', ['ly^2'], 'area', false, true, 8.95054210748189e31],+ ['square meter', 'm?', null, 'area', true, true, 1],+ ['square mile', 'mi2', ['mi^2'], 'area', false, true, 2589988.110336],+ ['square nautical mile', 'Nmi2', ['Nmi^2'], 'area', false, true, 3429904],+ ['square Pica', 'Pica2', ['Picapt2', 'Pica^2', 'Picapt^2'], 'area', false, true, 0.00001792111111111],+ ['square yard', 'yd2', ['yd^2'], 'area', false, true, 0.83612736],+ ['statute mile', 'mi', null, 'length', false, true, 1609.344],+ ['steradian', 'sr', null, 'solid_angle', true, false, 1],+ ['stilb', 'sb', null, 'luminance', false, false, 0.0001],+ ['stokes', 'St', null, 'kinematic_viscosity', false, false, 0.0001],+ ['stone', 'stone', null, 'mass', false, true, 6.35029318],+ ['tablespoon', 'tbs', null, 'volume', false, true, 0.0000147868],+ ['teaspoon', 'tsp', null, 'volume', false, true, 0.00000492892],+ ['tesla', 'T', null, 'magnetic_flux_density', true, true, 1],+ ['thermodynamic calorie', 'c', null, 'energy', false, true, 4.184],+ ['ton', 'ton', null, 'mass', false, true, 907.18474],+ ['tonne', 't', null, 'mass', false, false, 1000],+ ['U.K. pint', 'uk_pt', null, 'volume', false, true, 0.00056826125],+ ['U.S. bushel', 'bushel', null, 'volume', false, true, 0.03523907],+ ['U.S. oil barrel', 'barrel', null, 'volume', false, true, 0.158987295],+ ['U.S. pint', 'pt', ['us_pt'], 'volume', false, true, 0.000473176473],+ ['U.S. survey mile', 'survey_mi', null, 'length', false, true, 1609.347219],+ ['U.S. survey/statute acre', 'us_acre', null, 'area', false, true, 4046.87261],+ ['volt', 'V', null, 'voltage', true, false, 1],+ ['watt', 'W', null, 'power', true, true, 1],+ ['watt-hour', 'Wh', ['wh'], 'energy', false, true, 3600],+ ['weber', 'Wb', null, 'magnetic_flux', true, false, 1],+ ['yard', 'yd', null, 'length', false, true, 0.9144],+ ['year', 'yr', null, 'time', false, true, 31557600],+ ];++ // Binary prefixes+ // [Name, Prefix power of 2 value, Previx value, Abbreviation, Derived from]+ private _binaryPrefixes: IPrefixesKey = {+ Yi: ['yobi', 80, 1208925819614629174706176, 'Yi', 'yotta'],+ Zi: ['zebi', 70, 1180591620717411303424, 'Zi', 'zetta'],+ Ei: ['exbi', 60, 1152921504606846976, 'Ei', 'exa'],+ Pi: ['pebi', 50, 1125899906842624, 'Pi', 'peta'],+ Ti: ['tebi', 40, 1099511627776, 'Ti', 'tera'],+ Gi: ['gibi', 30, 1073741824, 'Gi', 'giga'],+ Mi: ['mebi', 20, 1048576, 'Mi', 'mega'],+ ki: ['kibi', 10, 1024, 'ki', 'kilo'],+ };++ // Unit prefixes+ // [Name, Multiplier, Abbreviation]+ private _unitPrefixes: IPrefixesKey = {+ Y: ['yotta', 1e24, 'Y'],+ Z: ['zetta', 1e21, 'Z'],+ E: ['exa', 1e18, 'E'],+ P: ['peta', 1e15, 'P'],+ T: ['tera', 1e12, 'T'],+ G: ['giga', 1e9, 'G'],+ M: ['mega', 1e6, 'M'],+ k: ['kilo', 1e3, 'k'],+ h: ['hecto', 1e2, 'h'],+ e: ['dekao', 1e1, 'e'],+ d: ['deci', 1e-1, 'd'],+ c: ['centi', 1e-2, 'c'],+ m: ['milli', 1e-3, 'm'],+ u: ['micro', 1e-6, 'u'],+ n: ['nano', 1e-9, 'n'],+ p: ['pico', 1e-12, 'p'],+ f: ['femto', 1e-15, 'f'],+ a: ['atto', 1e-18, 'a'],+ z: ['zepto', 1e-21, 'z'],+ y: ['yocto', 1e-24, 'y'],+ };+}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.tsnew file mode 100644index 0000000000..7a0ee83054--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/dec2bin/__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 { Dec2bin } 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 dec2bin function', () => {+ const testFunction = new Dec2bin(FUNCTION_NAMES_ENGINEERING.DEC2BIN);++ describe('Dec2bin', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(9);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('1001');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('0000');+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('0000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/dec2bin/index.ts b/packages/engine-formula/src/functions/engineering/dec2bin/index.tsnew file mode 100644index 0000000000..b87b0257d0--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/dec2bin/index.ts@@ -0,0 +1,95 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Dec2bin extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = Math.trunc(+numberObject.getValue());++ if (Number.isNaN(numberValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ // Return error if number is not decimal, is lower than -512, or is greater than 511+ if (!/^-?[0-9]{1,3}$/.test(`${numberValue}`) || numberValue < -512 || numberValue > 511) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (numberValue < 0) {+ const toStr = (512 + numberValue).toString(2);++ result = `1${'0'.repeat(9 - toStr.length)}${toStr}`;+ } else {+ result = Number.parseInt(`${numberValue}`, 10).toString(2);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + result;+ }+ }++ return StringValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..6d9ffae5b2--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/dec2hex/__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 { Dec2hex } 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 dec2hex function', () => {+ const testFunction = new Dec2hex(FUNCTION_NAMES_ENGINEERING.DEC2HEX);++ describe('Dec2hex', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(100);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('0064');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('0000');+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('0000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/dec2hex/index.ts b/packages/engine-formula/src/functions/engineering/dec2hex/index.tsnew file mode 100644index 0000000000..511d4af70a--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/dec2hex/index.ts@@ -0,0 +1,93 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Dec2hex extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = Math.trunc(+numberObject.getValue());++ if (Number.isNaN(numberValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ // Return error if number is not decimal, is lower than -549755813888, or is greater than 549755813887+ if (!/^-?[0-9]{1,12}$/.test(`${numberValue}`) || numberValue < -549755813888 || numberValue > 549755813887) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (numberValue < 0) {+ result = (1099511627776 + numberValue).toString(16);+ } else {+ result = Number.parseInt(`${numberValue}`, 10).toString(16);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + result;+ }+ }++ return StringValueObject.create(result.toLocaleUpperCase());+ }+}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.tsnew file mode 100644index 0000000000..e6a405aeff--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/dec2oct/__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 { Dec2oct } 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 Dec2oct function', () => {+ const testFunction = new Dec2oct(FUNCTION_NAMES_ENGINEERING.DEC2OCT);++ describe('Dec2oct', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(58);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('072');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('000');+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/dec2oct/index.ts b/packages/engine-formula/src/functions/engineering/dec2oct/index.tsnew file mode 100644index 0000000000..6fa43bfa24--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/dec2oct/index.ts@@ -0,0 +1,93 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Dec2oct extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = Math.trunc(+numberObject.getValue());++ if (Number.isNaN(numberValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ // Return error if number is not decimal, is lower than -536870912, or is greater than 536870911+ if (!/^-?[0-9]{1,9}$/.test(`${numberValue}`) || numberValue < -536870912 || numberValue > 536870911) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (numberValue < 0) {+ result = (1073741824 + numberValue).toString(8);+ } else {+ result = Number.parseInt(`${numberValue}`, 10).toString(8);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + result;+ }+ }++ return StringValueObject.create(result);+ }+}diff --git a/packages/engine-formula/src/functions/engineering/delta/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/delta/__tests__/index.spec.tsnew file mode 100644index 0000000000..59b07ada7d--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/delta/__tests__/index.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 { FUNCTION_NAMES_ENGINEERING } from '../../function-names';+import { Delta } 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 delta function', () => {+ const testFunction = new Delta(FUNCTION_NAMES_ENGINEERING.DELTA);++ describe('Delta', () => {+ it('Value is normal number', () => {+ const number1 = NumberValueObject.create(5);+ const number2 = NumberValueObject.create(4);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(0);+ });++ it('Value is number string', () => {+ const number1 = StringValueObject.create('1');+ const number2 = NumberValueObject.create(4);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(0);+ });++ it('Value is normal string', () => {+ const number1 = StringValueObject.create('test');+ const number2 = NumberValueObject.create(4);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const number1 = BooleanValueObject.create(true);+ const number2 = NumberValueObject.create(4);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const number1 = NullValueObject.create();+ const number2 = NumberValueObject.create(4);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const number1 = ErrorValueObject.create(ErrorType.NAME);+ const number2 = NumberValueObject.create(4);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const number1 = 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 number2 = NumberValueObject.create(4);+ const result = testFunction.calculate(number1, number2);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/delta/index.ts b/packages/engine-formula/src/functions/engineering/delta/index.tsnew file mode 100644index 0000000000..99de46ec91--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/delta/index.ts@@ -0,0 +1,50 @@+/**+ * 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 '../../../basics/engineering';++export class Delta extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number1: BaseValueObject, number2?: BaseValueObject) {+ const _number2 = number2 ?? NumberValueObject.create(0);++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number1, _number2);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [number1Object, number2Object] = variants as BaseValueObject[];++ const number1Value = +number1Object.getValue();+ const number2Value = +number2Object.getValue();++ if (Number.isNaN(number1Value) || Number.isNaN(number2Value)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ const result = number1Value === number2Value ? 1 : 0;++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..f7e95061bb--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/erf-precise/__tests__/index.spec.ts@@ -0,0 +1,83 @@+/**+ * 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 { ErfPrecise } 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 erf.precise function', () => {+ const testFunction = new ErfPrecise(FUNCTION_NAMES_ENGINEERING.ERF_PRECISE);++ describe('ErfPrecise', () => {+ it('Value is normal number', () => {+ const x = NumberValueObject.create(1);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(0.8427007929497149);+ });++ it('Value is number string', () => {+ const x = StringValueObject.create('1.5');+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(0.9661051464753108);+ });++ it('Value is normal string', () => {+ const x = StringValueObject.create('test');+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const x = BooleanValueObject.create(true);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const x = NullValueObject.create();+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const x = ErrorValueObject.create(ErrorType.NAME);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const x = 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(x);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/erf-precise/index.ts b/packages/engine-formula/src/functions/engineering/erf-precise/index.tsnew file mode 100644index 0000000000..75eb0ed2c5--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/erf-precise/index.ts@@ -0,0 +1,47 @@+/**+ * Copyright 2023-present DreamNum Inc.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { 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, erf } from '../../../basics/engineering';++export class ErfPrecise extends BaseFunction {+ override minParams = 1;++ override maxParams = 1;++ override calculate(x: BaseValueObject) {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [xObject] = variants as BaseValueObject[];++ const xValue = +xObject.getValue();++ if (Number.isNaN(xValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ const result = erf(xValue);++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..f273f5f6d3--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/erf/__tests__/index.spec.ts@@ -0,0 +1,87 @@+/**+ * Copyright 2023-present DreamNum Inc.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { describe, expect, it } from 'vitest';++import { FUNCTION_NAMES_ENGINEERING } from '../../function-names';+import { Erf } 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 erf function', () => {+ const testFunction = new Erf(FUNCTION_NAMES_ENGINEERING.ERF);++ describe('Erf', () => {+ it('Value is normal number', () => {+ const lowerLimit = NumberValueObject.create(1);+ const result = testFunction.calculate(lowerLimit);+ expect(result.getValue()).toBe(0.8427007929497149);++ const upperLimit = NumberValueObject.create(4);+ const result2 = testFunction.calculate(lowerLimit, upperLimit);+ expect(result2.getValue()).toBe(0.1572991916330272);+ });++ it('Value is number string', () => {+ const lowerLimit = StringValueObject.create('1.5');+ const result = testFunction.calculate(lowerLimit);+ expect(result.getValue()).toBe(0.9661051464753108);+ });++ it('Value is normal string', () => {+ const lowerLimit = StringValueObject.create('test');+ const result = testFunction.calculate(lowerLimit);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const lowerLimit = BooleanValueObject.create(true);+ const result = testFunction.calculate(lowerLimit);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const lowerLimit = NullValueObject.create();+ const result = testFunction.calculate(lowerLimit);+ expect(result.getValue()).toBe(0);+ });++ it('Value is error', () => {+ const lowerLimit = ErrorValueObject.create(ErrorType.NAME);+ const result = testFunction.calculate(lowerLimit);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const lowerLimit = 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(lowerLimit);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/erf/index.ts b/packages/engine-formula/src/functions/engineering/erf/index.tsnew file mode 100644index 0000000000..2a0095d772--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/erf/index.ts@@ -0,0 +1,68 @@+/**+ * 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, erf } from '../../../basics/engineering';++export class Erf extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(lowerLimit: BaseValueObject, upperLimit?: BaseValueObject) {+ let result;++ if (upperLimit) {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(lowerLimit, upperLimit);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [lowerLimitObject, upperLimitObject] = variants as BaseValueObject[];++ const lowerLimitValue = +lowerLimitObject.getValue();+ const upperLimitValue = +upperLimitObject.getValue();++ if (Number.isNaN(lowerLimitValue) || Number.isNaN(upperLimitValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ result = erf(upperLimitValue) - erf(lowerLimitValue);+ } else {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(lowerLimit);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [lowerLimitObject] = variants as BaseValueObject[];++ const lowerLimitValue = +lowerLimitObject.getValue();++ if (Number.isNaN(lowerLimitValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ result = erf(lowerLimitValue);+ }++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..4a9b4bfb38--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/erfc-precise/__tests__/index.spec.ts@@ -0,0 +1,83 @@+/**+ * 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 { ErfcPrecise } 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 erfc.precise function', () => {+ const testFunction = new ErfcPrecise(FUNCTION_NAMES_ENGINEERING.ERFC_PRECISE);++ describe('ErfcPrecise', () => {+ it('Value is normal number', () => {+ const x = NumberValueObject.create(1);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(0.1572992070502851);+ });++ it('Value is number string', () => {+ const x = StringValueObject.create('1.5');+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(0.03389485352468924);+ });++ it('Value is normal string', () => {+ const x = StringValueObject.create('test');+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const x = BooleanValueObject.create(true);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const x = NullValueObject.create();+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(1);+ });++ it('Value is error', () => {+ const x = ErrorValueObject.create(ErrorType.NAME);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const x = 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(x);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/erfc-precise/index.ts b/packages/engine-formula/src/functions/engineering/erfc-precise/index.tsnew file mode 100644index 0000000000..a7b11233f6--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/erfc-precise/index.ts@@ -0,0 +1,47 @@+/**+ * Copyright 2023-present DreamNum Inc.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { 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, erf } from '../../../basics/engineering';++export class ErfcPrecise extends BaseFunction {+ override minParams = 1;++ override maxParams = 1;++ override calculate(x: BaseValueObject) {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [xObject] = variants as BaseValueObject[];++ const xValue = +xObject.getValue();++ if (Number.isNaN(xValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ const result = 1 - erf(xValue);++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..f7073a9944--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/erfc/__tests__/index.spec.ts@@ -0,0 +1,83 @@+/**+ * 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 { Erfc } 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 erfc function', () => {+ const testFunction = new Erfc(FUNCTION_NAMES_ENGINEERING.ERFC);++ describe('Erfc', () => {+ it('Value is normal number', () => {+ const x = NumberValueObject.create(1);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(0.1572992070502851);+ });++ it('Value is number string', () => {+ const x = StringValueObject.create('1.5');+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(0.03389485352468924);+ });++ it('Value is normal string', () => {+ const x = StringValueObject.create('test');+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is boolean', () => {+ const x = BooleanValueObject.create(true);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const x = NullValueObject.create();+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(1);+ });++ it('Value is error', () => {+ const x = ErrorValueObject.create(ErrorType.NAME);+ const result = testFunction.calculate(x);+ expect(result.getValue()).toBe(ErrorType.NAME);+ });++ it('Value is array', () => {+ const x = 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(x);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/erfc/index.ts b/packages/engine-formula/src/functions/engineering/erfc/index.tsnew file mode 100644index 0000000000..4ddfa1cb69--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/erfc/index.ts@@ -0,0 +1,47 @@+/**+ * Copyright 2023-present DreamNum Inc.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { 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, erf } from '../../../basics/engineering';++export class Erfc extends BaseFunction {+ override minParams = 1;++ override maxParams = 1;++ override calculate(x: BaseValueObject) {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(x);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [xObject] = variants as BaseValueObject[];++ const xValue = +xObject.getValue();++ if (Number.isNaN(xValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ const result = 1 - erf(xValue);++ return NumberValueObject.create(result);+ }+}diff --git a/packages/engine-formula/src/functions/engineering/function-map.ts b/packages/engine-formula/src/functions/engineering/function-map.tsindex 5e65e0ae5e..305e711672 100644--- a/packages/engine-formula/src/functions/engineering/function-map.ts+++ b/packages/engine-formula/src/functions/engineering/function-map.ts@@ -14,4 +14,63 @@* limitations under the License.*/-export const functionEngineering = [];+import { FUNCTION_NAMES_ENGINEERING } from './function-names';+import { Besseli } from './besseli';+import { Besselj } from './besselj';+import { Besselk } from './besselk';+import { Bessely } from './bessely';+import { Bin2dec } from './bin2dec';+import { Bin2hex } from './bin2hex';+import { Bin2oct } from './bin2oct';+import { Bitand } from './bitand';+import { Bitlshift } from './bitlshift';+import { Bitor } from './bitor';+import { Bitrshift } from './bitrshift';+import { Bitxor } from './bitxor';+import { Complex } from './complex';+import { Convert } from './convert';+import { Dec2bin } from './dec2bin';+import { Dec2hex } from './dec2hex';+import { Dec2oct } from './dec2oct';+import { Delta } from './delta';+import { Erf } from './erf';+import { ErfPrecise } from './erf-precise';+import { Erfc } from './erfc';+import { ErfcPrecise } from './erfc-precise';+import { Hex2bin } from './hex2bin';+import { Hex2dec } from './hex2dec';+import { Hex2oct } from './hex2oct';+import { Oct2bin } from './oct2bin';+import { Oct2dec } from './oct2dec';+import { Oct2hex } from './oct2hex';++export const functionEngineering = [+ [Besseli, FUNCTION_NAMES_ENGINEERING.BESSELI],+ [Besselj, FUNCTION_NAMES_ENGINEERING.BESSELJ],+ [Besselk, FUNCTION_NAMES_ENGINEERING.BESSELK],+ [Bessely, FUNCTION_NAMES_ENGINEERING.BESSELY],+ [Bin2dec, FUNCTION_NAMES_ENGINEERING.BIN2DEC],+ [Bin2hex, FUNCTION_NAMES_ENGINEERING.BIN2HEX],+ [Bin2oct, FUNCTION_NAMES_ENGINEERING.BIN2OCT],+ [Bitand, FUNCTION_NAMES_ENGINEERING.BITAND],+ [Bitlshift, FUNCTION_NAMES_ENGINEERING.BITLSHIFT],+ [Bitor, FUNCTION_NAMES_ENGINEERING.BITOR],+ [Bitrshift, FUNCTION_NAMES_ENGINEERING.BITRSHIFT],+ [Bitxor, FUNCTION_NAMES_ENGINEERING.BITXOR],+ [Complex, FUNCTION_NAMES_ENGINEERING.COMPLEX],+ [Convert, FUNCTION_NAMES_ENGINEERING.CONVERT],+ [Dec2bin, FUNCTION_NAMES_ENGINEERING.DEC2BIN],+ [Dec2hex, FUNCTION_NAMES_ENGINEERING.DEC2HEX],+ [Dec2oct, FUNCTION_NAMES_ENGINEERING.DEC2OCT],+ [Delta, FUNCTION_NAMES_ENGINEERING.DELTA],+ [Erf, FUNCTION_NAMES_ENGINEERING.ERF],+ [ErfPrecise, FUNCTION_NAMES_ENGINEERING.ERF_PRECISE],+ [Erfc, FUNCTION_NAMES_ENGINEERING.ERFC],+ [ErfcPrecise, FUNCTION_NAMES_ENGINEERING.ERFC_PRECISE],+ [Hex2bin, FUNCTION_NAMES_ENGINEERING.HEX2BIN],+ [Hex2dec, FUNCTION_NAMES_ENGINEERING.HEX2DEC],+ [Hex2oct, FUNCTION_NAMES_ENGINEERING.HEX2OCT],+ [Oct2bin, FUNCTION_NAMES_ENGINEERING.OCT2BIN],+ [Oct2dec, FUNCTION_NAMES_ENGINEERING.OCT2DEC],+ [Oct2hex, FUNCTION_NAMES_ENGINEERING.OCT2HEX],+];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.tsnew file mode 100644index 0000000000..2f15c66401--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/hex2bin/__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 { Hex2bin } 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 hex2bin function', () => {+ const testFunction = new Hex2bin(FUNCTION_NAMES_ENGINEERING.HEX2BIN);++ describe('Hex2bin', () => {+ it('Value is normal number', () => {+ const number = StringValueObject.create('F');+ const places = NumberValueObject.create(8);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('00001111');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(8);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(8);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(8);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(8);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(8);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('00000000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(8);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(8);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/hex2bin/index.ts b/packages/engine-formula/src/functions/engineering/hex2bin/index.tsnew file mode 100644index 0000000000..0dcacc0155--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/hex2bin/index.ts@@ -0,0 +1,102 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean, isValidHexadecimalNumber } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Hex2bin extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not hexadecimal or contains more than ten characters (10 digits)+ if (!isValidHexadecimalNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ // Check if number is negative+ const negative = !!(numberValue.length === 10 && numberValue.substring(0, 1).toLocaleUpperCase() === 'F');++ // Convert hexadecimal number to decimal+ const decimal = negative ? Number.parseInt(numberValue, 16) - 1099511627776 : Number.parseInt(numberValue, 16);++ // Return error if number is lower than -512 or greater than 511+ if (decimal < -512 || decimal > 511) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (negative) {+ const toStr = (512 + decimal).toString(2);++ result = `1${'0'.repeat(9 - toStr.length)}${toStr}`;+ } else {+ result = decimal.toString(2);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + result;+ }+ }++ return StringValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..5371ada73c--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/hex2dec/__tests__/index.spec.ts@@ -0,0 +1,83 @@+/**+ * 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 { Hex2dec } from '../index';+import { BooleanValueObject, NullValueObject, 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 hex2dec function', () => {+ const testFunction = new Hex2dec(FUNCTION_NAMES_ENGINEERING.HEX2DEC);++ describe('Hex2dec', () => {+ it('Value is normal number', () => {+ const number = StringValueObject.create('A5');+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(165);+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const number = NullValueObject.create();+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(0);+ });++ 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/hex2dec/index.ts b/packages/engine-formula/src/functions/engineering/hex2dec/index.tsnew file mode 100644index 0000000000..126e8cb115--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/hex2dec/index.ts@@ -0,0 +1,52 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean, isValidHexadecimalNumber } from '../../../basics/engineering';+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';++export class Hex2dec extends BaseFunction {+ override minParams = 1;++ override maxParams = 1;++ override calculate(number: BaseValueObject) {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not hexadecimal or contains more than ten characters (10 digits)+ if (!isValidHexadecimalNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result = Number.parseInt(numberValue, 16);++ if (result >= 549755813888) {+ result -= 1099511627776;+ }++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..b8c7fed236--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/hex2oct/__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 { Hex2oct } 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 hex2oct function', () => {+ const testFunction = new Hex2oct(FUNCTION_NAMES_ENGINEERING.HEX2OCT);++ describe('Hex2oct', () => {+ it('Value is normal number', () => {+ const number = StringValueObject.create('F');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('017');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/hex2oct/index.ts b/packages/engine-formula/src/functions/engineering/hex2oct/index.tsnew file mode 100644index 0000000000..44765be434--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/hex2oct/index.ts@@ -0,0 +1,97 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean, isValidHexadecimalNumber } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Hex2oct extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not hexadecimal or contains more than ten characters (10 digits)+ if (!isValidHexadecimalNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ // Convert hexadecimal number to decimal+ const decimal = Number.parseInt(numberValue, 16);++ // Return error if number is positive and greater than 0x1fffffff (536870911)+ if (decimal > 536870911 && decimal < 1098974756864) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (decimal >= 1098974756864) {+ result = (decimal - 1098437885952).toString(8);+ } else {+ result = decimal.toString(8);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + 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.tsnew file mode 100644index 0000000000..c1bdd941a7--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/oct2bin/__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 { Oct2bin } 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 oct2bin function', () => {+ const testFunction = new Oct2bin(FUNCTION_NAMES_ENGINEERING.OCT2BIN);++ describe('Oct2bin', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(3);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('011');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(3);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/oct2bin/index.ts b/packages/engine-formula/src/functions/engineering/oct2bin/index.tsnew file mode 100644index 0000000000..950592778c--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/oct2bin/index.ts@@ -0,0 +1,102 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean, isValidOctalNumber } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Oct2bin extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not octal or contains more than ten characters (10 digits)+ if (!isValidOctalNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ // Check if number is negative+ const negative = !!(numberValue.length === 10 && numberValue.substring(0, 1) === '7');++ // Convert octal number to decimal+ const decimal = negative ? Number.parseInt(numberValue, 8) - 1073741824 : Number.parseInt(numberValue, 8);++ // Return error if number is lower than -512 or greater than 511+ if (decimal < -512 || decimal > 511) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result;++ if (negative) {+ const toStr = (512 + decimal).toString(2);++ result = `1${'0'.repeat(9 - toStr.length)}${toStr}`;+ } else {+ result = decimal.toString(2);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + result;+ }+ }++ return StringValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..9d6939ccde--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/oct2dec/__tests__/index.spec.ts@@ -0,0 +1,83 @@+/**+ * 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 { Oct2dec } 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 oct2dec function', () => {+ const testFunction = new Oct2dec(FUNCTION_NAMES_ENGINEERING.OCT2DEC);++ describe('Oct2dec', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(54);+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(44);+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is blank cell', () => {+ const number = NullValueObject.create();+ const result = testFunction.calculate(number);+ expect(result.getValue()).toBe(0);+ });++ 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/oct2dec/index.ts b/packages/engine-formula/src/functions/engineering/oct2dec/index.tsnew file mode 100644index 0000000000..a3ebb42e24--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/oct2dec/index.ts@@ -0,0 +1,52 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean, isValidOctalNumber } from '../../../basics/engineering';+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';++export class Oct2dec extends BaseFunction {+ override minParams = 1;++ override maxParams = 1;++ override calculate(number: BaseValueObject) {+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not octal or contains more than ten characters (10 digits)+ if (!isValidOctalNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ let result = Number.parseInt(numberValue, 8);++ if (result >= 536870912) {+ result -= 1073741824;+ }++ return NumberValueObject.create(result);+ }+}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.tsnew file mode 100644index 0000000000..715f2e50d1--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/oct2hex/__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 { Oct2hex } 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 oct2hex function', () => {+ const testFunction = new Oct2hex(FUNCTION_NAMES_ENGINEERING.OCT2HEX);++ describe('Oct2hex', () => {+ it('Value is normal number', () => {+ const number = NumberValueObject.create(100);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('0040');+ });++ it('Value is number string', () => {+ const number = StringValueObject.create('-0.5');+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is normal string', () => {+ const number = StringValueObject.create('test');+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.NUM);+ });++ it('Value is boolean', () => {+ const number = BooleanValueObject.create(true);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe(ErrorType.VALUE);+ });++ it('Value is null', () => {+ const number = NullValueObject.create();+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toBe('0000');+ });++ it('Value is error', () => {+ const number = ErrorValueObject.create(ErrorType.NAME);+ const places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ 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 places = NumberValueObject.create(4);+ const result = testFunction.calculate(number, places);+ expect(result.getValue()).toStrictEqual(ErrorType.VALUE);+ });+ });+});diff --git a/packages/engine-formula/src/functions/engineering/oct2hex/index.ts b/packages/engine-formula/src/functions/engineering/oct2hex/index.tsnew file mode 100644index 0000000000..990f978738--- /dev/null+++ b/packages/engine-formula/src/functions/engineering/oct2hex/index.ts@@ -0,0 +1,92 @@+/**+ * 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 { checkVariantsErrorIsArrayOrBoolean, isValidOctalNumber } from '../../../basics/engineering';+import { ErrorType } from '../../../basics/error-type';+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';+import { BaseFunction } from '../../base-function';+import { StringValueObject } from '../../../engine/value-object/primitive-object';++export class Oct2hex extends BaseFunction {+ override minParams = 1;++ override maxParams = 2;++ override calculate(number: BaseValueObject, places?: BaseValueObject) {+ if (number.isNull()) {+ return ErrorValueObject.create(ErrorType.NA);+ }++ let placesValue = 0;++ if (places) {+ // If places exists, it is prioritized.+ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(places);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [placesObject] = variants as BaseValueObject[];++ placesValue = Math.floor(+placesObject.getValue());++ if (Number.isNaN(placesValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }++ if (placesValue < 0 || placesValue > 10) {+ return ErrorValueObject.create(ErrorType.NUM);+ }+ }++ const { isError, errorObject, variants } = checkVariantsErrorIsArrayOrBoolean(number);++ if (isError) {+ return errorObject as ErrorValueObject;+ }++ const [numberObject] = variants as BaseValueObject[];++ const numberValue = `${numberObject.getValue()}`;++ // Return error if number is not octal or contains more than ten characters (10 digits)+ if (!isValidOctalNumber(numberValue)) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ // Convert octal number to decimal+ const decimal = Number.parseInt(numberValue, 8);++ let result;++ if (decimal >= 536870912) {+ result = `ff${(decimal + 3221225472).toString(16)}`;+ } else {+ result = decimal.toString(16);++ if (places) {+ if (placesValue < result.length) {+ return ErrorValueObject.create(ErrorType.NUM);+ }++ result = '0'.repeat(placesValue - result.length) + result;+ }+ }++ return StringValueObject.create(result.toLocaleUpperCase());+ }+}diff --git a/packages/engine-formula/src/functions/logical/function-map.ts b/packages/engine-formula/src/functions/logical/function-map.tsindex ab5a73f83a..a6575e1c0f 100644--- a/packages/engine-formula/src/functions/logical/function-map.ts+++ b/packages/engine-formula/src/functions/logical/function-map.ts@@ -22,6 +22,7 @@ import { Iferror } from './iferror';import { Ifna } from './ifna';import { Ifs } from './ifs';import { Lambda } from './lambda';+import { Let } from './let';import { Makearray } from './makearray';import { Not } from './not';import { Or } from './or';@@ -37,6 +38,7 @@ export const functionLogical = [[Ifna, FUNCTION_NAMES_LOGICAL.IFNA],[Ifs, FUNCTION_NAMES_LOGICAL.IFS],[Lambda, FUNCTION_NAMES_LOGICAL.LAMBDA],+ [Let, FUNCTION_NAMES_LOGICAL.LET],[Makearray, FUNCTION_NAMES_LOGICAL.MAKEARRAY],[Not, FUNCTION_NAMES_LOGICAL.NOT],[Or, FUNCTION_NAMES_LOGICAL.OR],diff --git a/packages/engine-formula/src/functions/logical/let/index.ts b/packages/engine-formula/src/functions/logical/let/index.tsnew file mode 100644index 0000000000..9e107ba940--- /dev/null+++ b/packages/engine-formula/src/functions/logical/let/index.ts@@ -0,0 +1,32 @@+/**+ * 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';++/**+ * Please refer to the _changeLetToLambda function; here, it serves the purpose of a placeholder for the formula.+ */+export class Let extends BaseFunction {+ override minParams = 3;++ override maxParams = 255;++ override calculate(...variants: BaseValueObject[]) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }+}diff --git a/packages/engine-formula/src/functions/logical/makearray/index.ts b/packages/engine-formula/src/functions/logical/makearray/index.tsindex a14c5838b1..510440ab77 100644--- a/packages/engine-formula/src/functions/logical/makearray/index.ts+++ b/packages/engine-formula/src/functions/logical/makearray/index.ts@@ -17,6 +17,7 @@import { ErrorType } from '../../../basics/error-type';import type { AsyncObject } from '../../../engine/reference-object/base-reference-object';import { AsyncArrayObject } from '../../../engine/reference-object/base-reference-object';+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';import type { LambdaValueObjectObject } from '../../../engine/value-object/lambda-value-object';import { NumberValueObject } from '../../../engine/value-object/primitive-object';@@ -53,7 +54,11 @@ export class Makearray extends BaseFunction {result[r] = [];}for (let c = 0; c < column; c++) {- const value = lambda.execute(NumberValueObject.create(r + 1), NumberValueObject.create(c + 1));+ let value = lambda.execute(NumberValueObject.create(r + 1), NumberValueObject.create(c + 1));++ if (value.isArray()) {+ value = (value as ArrayValueObject).get(0, 0) as BaseValueObject;+ }result[r][c] = value;}diff --git a/packages/engine-formula/src/functions/lookup/indirect/index.ts b/packages/engine-formula/src/functions/lookup/indirect/index.tsindex 540433a790..5e808de115 100644--- a/packages/engine-formula/src/functions/lookup/indirect/index.ts+++ b/packages/engine-formula/src/functions/lookup/indirect/index.ts@@ -59,7 +59,7 @@ export class Indirect extends BaseFunction {const columnCount = (refText as ArrayValueObject).getColumnCount();if (rowCount > 1 || columnCount > 1) {- // TO DO...+ // TODOreturn refText.map(() => {return ErrorValueObject.create(ErrorType.VALUE);});@@ -108,7 +108,7 @@ export class Indirect extends BaseFunction {const { range, sheetName, unitId } = gridRange;- if (Number.isNaN(range.startRow)) {+ if (Number.isNaN(range.startRow) || range.endRow + 1 > 1048576 || Number.isNaN(range.startColumn) || range.endColumn + 1 > 16384) {return ErrorValueObject.create(ErrorType.REF);}diff --git a/packages/sheets-formula/src/controllers/__tests__/update-formula.controller.spec.ts b/packages/sheets-formula/src/controllers/__tests__/update-formula.controller.spec.tsindex c56f2fdc15..c7f881b5a2 100644--- a/packages/sheets-formula/src/controllers/__tests__/update-formula.controller.spec.ts+++ b/packages/sheets-formula/src/controllers/__tests__/update-formula.controller.spec.ts@@ -947,7 +947,6 @@ describe('Test insert function operation', () => {t: 2,}, {f: '=OFFSET(#REF!,1,1)',- si: 'id2',v: 1,t: 2,}, {@@ -981,7 +980,6 @@ describe('Test insert function operation', () => {t: 2,}, {f: '=OFFSET(#REF!,1,1)',- si: 'id2',v: 1,t: 2,}, {diff --git a/packages/sheets-formula/src/controllers/update-formula.controller.ts b/packages/sheets-formula/src/controllers/update-formula.controller.tsindex 2801eaeec5..5fd4b2265d 100644--- a/packages/sheets-formula/src/controllers/update-formula.controller.ts+++ b/packages/sheets-formula/src/controllers/update-formula.controller.ts@@ -843,17 +843,9 @@ export class UpdateFormulaController extends Disposable {const newSequenceNodes = this._updateRefOffset(sequenceNodes, refChangeIds, x, y);- // The formula f that originally depended on si has been actually calculated and does not require si and x,y.- if ((x !== undefined && (x > 0)) || (y !== undefined && (y > 0))) {- newFormulaDataItem.setValue(row, column, {- f: `=${generateStringWithSequence(newSequenceNodes)}`,- });- } else {- newFormulaDataItem.setValue(row, column, {- f: `=${generateStringWithSequence(newSequenceNodes)}`,- si,- });- }+ newFormulaDataItem.setValue(row, column, {+ f: `=${generateStringWithSequence(newSequenceNodes)}`,+ });});if (newFormulaData[unitId]) {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 8c857a88d7..450187ecbb 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@@ -25,8 +25,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: 'The value at which to evaluate the function.' },+ n: { name: 'N', detail: 'The order of the Bessel function. If n is not an integer, it is truncated.' },},},BESSELJ: {@@ -39,8 +39,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: 'The value at which to evaluate the function.' },+ n: { name: 'N', detail: 'The order of the Bessel function. If n is not an integer, it is truncated.' },},},BESSELK: {@@ -53,8 +53,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: 'The value at which to evaluate the function.' },+ n: { name: 'N', detail: 'The order of the Bessel function. If n is not an integer, it is truncated.' },},},BESSELY: {@@ -67,8 +67,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: 'The value at which to evaluate the function.' },+ n: { name: 'N', detail: 'The order of the Bessel function. If n is not an integer, it is truncated.' },},},BIN2DEC: {@@ -81,8 +81,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The binary number you want to convert.' },},},BIN2HEX: {@@ -95,8 +94,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The binary number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},BIN2OCT: {@@ -109,8 +108,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The binary number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},BITAND: {@@ -123,8 +122,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: 'number1', detail: 'Must be in decimal form and greater than or equal to 0.' },+ number2: { name: 'number2', detail: 'Must be in decimal form and greater than or equal to 0.' },},},BITLSHIFT: {@@ -137,8 +136,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'Number must be an integer greater than or equal to 0.' },+ shiftAmount: { name: 'shift_amount', detail: 'Shift_amount must be an integer.' },},},BITOR: {@@ -151,8 +150,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: 'number1', detail: 'Must be in decimal form and greater than or equal to 0.' },+ number2: { name: 'number2', detail: 'Must be in decimal form and greater than or equal to 0.' },},},BITRSHIFT: {@@ -165,8 +164,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'Number must be an integer greater than or equal to 0.' },+ shiftAmount: { name: 'shift_amount', detail: 'Shift_amount must be an integer.' },},},BITXOR: {@@ -179,8 +178,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: 'number1', detail: 'Must be in decimal form and greater than or equal to 0.' },+ number2: { name: 'number2', detail: 'Must be in decimal form and greater than or equal to 0.' },},},COMPLEX: {@@ -193,8 +192,9 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ realNum: { name: 'real_num', detail: 'The real coefficient of the complex number.' },+ iNum: { name: 'i_num', detail: 'The imaginary coefficient of the complex number.' },+ suffix: { name: 'suffix', detail: 'The suffix for the imaginary component of the complex number. If omitted, suffix is assumed to be "i".' },},},CONVERT: {@@ -207,8 +207,9 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'is the value in from_units to convert.' },+ fromUnit: { name: 'from_unit', detail: 'is the units for number.' },+ toUnit: { name: 'to_unit', detail: 'is the units for the result.' },},},DEC2BIN: {@@ -221,8 +222,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The decimal number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},DEC2HEX: {@@ -235,8 +236,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The decimal number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},DEC2OCT: {@@ -249,8 +250,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The decimal number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},DELTA: {@@ -263,8 +264,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: 'number1', detail: 'The first number.' },+ number2: { name: 'number2', detail: 'The second number. If omitted, number2 is assumed to be zero.' },},},ERF: {@@ -277,8 +278,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ lowerLimit: { name: 'lower_limit', detail: 'The lower bound for integrating ERF.' },+ upperLimit: { name: 'upper_limit', detail: 'The upper bound for integrating ERF. If omitted, ERF integrates between zero and lower_limit.' },},},ERF_PRECISE: {@@ -291,8 +292,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'x', detail: 'The lower bound for integrating ERF.PRECISE.' },},},ERFC: {@@ -305,8 +305,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'x', detail: 'The lower bound for integrating ERFC.' },},},ERFC_PRECISE: {@@ -319,8 +318,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'x', detail: 'The lower bound for integrating ERFC.PRECISE.' },},},GESTEP: {@@ -347,8 +345,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The hexadecimal number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},HEX2DEC: {@@ -361,8 +359,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The hexadecimal number you want to convert.' },},},HEX2OCT: {@@ -375,8 +372,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The hexadecimal number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},IMABS: {@@ -739,8 +736,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The octal number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},OCT2DEC: {@@ -753,8 +750,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The octal number you want to convert.' },},},OCT2HEX: {@@ -767,8 +763,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: 'number', detail: 'The octal number you want to convert.' },+ places: { name: 'places', detail: 'The number of characters to use.' },},},};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 d9caf24276..bb3aa69dad 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@@ -25,8 +25,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '関数に代入する値を指定します。' },+ n: { name: 'N', detail: 'ベッセル関数の次数を指定します。n に整数以外の値を指定すると、小数点以下が切り捨てられます。' },},},BESSELJ: {@@ -39,8 +39,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '関数に代入する値を指定します。' },+ n: { name: 'N', detail: 'ベッセル関数の次数を指定します。n に整数以外の値を指定すると、小数点以下が切り捨てられます。' },},},BESSELK: {@@ -53,8 +53,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '関数に代入する値を指定します。' },+ n: { name: 'N', detail: 'ベッセル関数の次数を指定します。n に整数以外の値を指定すると、小数点以下が切り捨てられます。' },},},BESSELY: {@@ -67,8 +67,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '関数に代入する値を指定します。' },+ n: { name: 'N', detail: 'ベッセル関数の次数を指定します。n に整数以外の値を指定すると、小数点以下が切り捨てられます。' },},},BIN2DEC: {@@ -81,8 +81,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '2 進数', detail: '変換する 2 進数を指定します。' },},},BIN2HEX: {@@ -95,8 +94,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '2 進数', detail: '変換する 2 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},BIN2OCT: {@@ -109,8 +108,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '2 進数', detail: '変換する 2 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},BITAND: {@@ -123,8 +122,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '数値1', detail: '小数点の表示形式になっている必要があります。 0 以上の数値を指定します。' },+ number2: { name: '数値2', detail: '小数点の表示形式になっている必要があります。 0 以上の数値を指定します。' },},},BITLSHIFT: {@@ -137,8 +136,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '数値', detail: '数値は、0 以上の整数である必要があります。' },+ shiftAmount: { name: 'シフト量', detail: 'は整数である必要があります。' },},},BITOR: {@@ -151,8 +150,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '数値1', detail: '小数点の表示形式になっている必要があります。 0 以上の数値を指定します。' },+ number2: { name: '数値2', detail: '小数点の表示形式になっている必要があります。 0 以上の数値を指定します。' },},},BITRSHIFT: {@@ -165,8 +164,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '数値', detail: '数値は、0 以上の整数である必要があります。' },+ shiftAmount: { name: 'シフト量', detail: 'は整数である必要があります。' },},},BITXOR: {@@ -179,8 +178,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '数値1', detail: '小数点の表示形式になっている必要があります。 0 以上の数値を指定します。' },+ number2: { name: '数値2', detail: '小数点の表示形式になっている必要があります。 0 以上の数値を指定します。' },},},COMPLEX: {@@ -193,8 +192,9 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ realNum: { name: '実数', detail: '複素数の実数係数を指定します。' },+ iNum: { name: '虚数', detail: '複素数の虚数係数を指定します。' },+ suffix: { name: '虚数単位', detail: '複素数の虚数部分の単位を指定します。省略すると、"i" を指定したと見なされます。' },},},CONVERT: {@@ -207,8 +207,9 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '数値', detail: '変換する値を指定します。' },+ fromUnit: { name: '変換前単位', detail: '数値の単位を指定します。' },+ toUnit: { name: '変換後単位', detail: '結果の単位を指定します。' },},},DEC2BIN: {@@ -221,8 +222,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '10 進数', detail: '変換する 10 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},DEC2HEX: {@@ -235,8 +236,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '10 進数', detail: '変換する 10 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},DEC2OCT: {@@ -249,8 +250,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '10 進数', detail: '変換する 10 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},DELTA: {@@ -263,8 +264,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '数値1', detail: '一方の数値を指定します。' },+ number2: { name: '数値2', detail: 'もう一方の数値を指定します。数値 2 を省略すると、0 を指定したと見なされます。' },},},ERF: {@@ -277,8 +278,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ lowerLimit: { name: '下限', detail: '誤差関数を積分するときの下限値を指定します。' },+ upperLimit: { name: '上限', detail: '誤差関数を積分するときの上限値を指定します。上限を省略すると、0 ~下限の範囲で積分が行われます。' },},},ERF_PRECISE: {@@ -291,8 +292,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: '誤差関数を積分するときの下限値を指定します。' },},},ERFC: {@@ -305,8 +305,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: '相補誤差関数を積分するときの下限値を指定します。' },},},ERFC_PRECISE: {@@ -319,8 +318,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: '相補誤差関数を積分するときの下限値を指定します。' },},},GESTEP: {@@ -347,8 +345,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '16 進数', detail: '変換する 16 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},HEX2DEC: {@@ -361,8 +359,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '16 進数', detail: '変換する 16 進数を指定します。' },},},HEX2OCT: {@@ -375,8 +372,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '16 進数', detail: '変換する 16 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},IMABS: {@@ -739,8 +736,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '8 進数', detail: '変換する 8 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},OCT2DEC: {@@ -753,8 +750,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '8 進数', detail: '変換する 8 進数を指定します。' },},},OCT2HEX: {@@ -767,8 +763,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '8 進数', detail: '変換する 8 進数を指定します。' },+ places: { name: '桁数', detail: '使用する文字数を指定します。' },},},};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 bdba026e1b..8c6099a1c6 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@@ -25,14 +25,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ x: { name: 'X', detail: 'Giá trị để đánh giá hàm.' },+ n: { name: 'N', detail: 'Bậc của hàm Bessel. Nếu n không phải là số nguyên thì nó bị cắt cụt.' },},},BESSELJ: {@@ -45,14 +39,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ x: { name: 'X', detail: 'Giá trị để đánh giá hàm.' },+ n: { name: 'N', detail: 'Bậc của hàm Bessel. Nếu n không phải là số nguyên thì nó bị cắt cụt.' },},},BESSELK: {@@ -65,14 +53,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ x: { name: 'X', detail: 'Giá trị để đánh giá hàm.' },+ n: { name: 'N', detail: 'Bậc của hàm Bessel. Nếu n không phải là số nguyên thì nó bị cắt cụt.' },},},BESSELY: {@@ -85,14 +67,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ x: { name: 'X', detail: 'Giá trị để đánh giá hàm.' },+ n: { name: 'N', detail: 'Bậc của hàm Bessel. Nếu n không phải là số nguyên thì nó bị cắt cụt.' },},},BIN2DEC: {@@ -105,14 +81,7 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'Số nhị phân', detail: 'Số nhị phân mà bạn muốn chuyển đổi.' },},},BIN2HEX: {@@ -125,14 +94,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'Số nhị phân', detail: 'Số nhị phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},BIN2OCT: {@@ -145,14 +108,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'Số nhị phân', detail: 'Số nhị phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},BITAND: {@@ -165,14 +122,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number1: { name: 'Giá trị 1', detail: 'Phải là dạng thập phân và lớn hơn hoặc bằng 0.' },+ number2: { name: 'Giá trị 2', detail: 'Phải là dạng thập phân và lớn hơn hoặc bằng 0.' },},},@@ -186,14 +137,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'giá trị số', detail: 'phải là số nguyên lớn hơn hoặc bằng 0.' },+ shiftAmount: { name: 'Số tiền ca', detail: 'phải là số nguyên.' },},},BITOR: {@@ -206,14 +151,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number1: { name: 'Giá trị 1', detail: 'Phải là dạng thập phân và lớn hơn hoặc bằng 0.' },+ number2: { name: 'Giá trị 2', detail: 'Phải là dạng thập phân và lớn hơn hoặc bằng 0.' },},},BITRSHIFT: {@@ -226,14 +165,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'giá trị số', detail: 'phải là số nguyên lớn hơn hoặc bằng 0.' },+ shiftAmount: { name: 'Số tiền ca', detail: 'phải là số nguyên.' },},},BITXOR: {@@ -246,14 +179,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number1: { name: 'Giá trị 1', detail: 'Phải là dạng thập phân và lớn hơn hoặc bằng 0.' },+ number2: { name: 'Giá trị 2', detail: 'Phải là dạng thập phân và lớn hơn hoặc bằng 0.' },},},COMPLEX: {@@ -266,14 +193,9 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ realNum: { name: 'hệ số thực', detail: 'Hệ số thực của số phức.' },+ iNum: { name: 'hệ số ảo', detail: 'Hệ số ảo của số phức.' },+ suffix: { name: 'hậu tố', detail: 'Hậu tố cho thành phần ảo của số phức. Nếu bị bỏ qua, hậu tố được giả định là "i".' },},},CONVERT: {@@ -286,14 +208,9 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'giá trị số', detail: 'Giá trị cần chuyển đổi.' },+ fromUnit: { name: 'Đơn vị trước khi chuyển đổi', detail: 'là đơn vị của giá trị số.' },+ toUnit: { name: 'Đơn vị chuyển đổi', detail: 'là đơn vị của kết quả.' },},},DEC2BIN: {@@ -306,14 +223,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'Số thập phân', detail: 'Số nguyên thập phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},DEC2HEX: {@@ -326,14 +237,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'Số thập phân', detail: 'Số nguyên thập phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},DEC2OCT: {@@ -346,14 +251,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'Số thập phân', detail: 'Số nguyên thập phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},DELTA: {@@ -366,14 +265,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number1: { name: 'giá trị số 1', detail: 'Số thứ nhất.' },+ number2: { name: 'giá trị số 2', detail: 'Số thứ hai. Nếu bị bỏ qua, number2 được cho là bằng không.' },},},ERF: {@@ -386,14 +279,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ lowerLimit: { name: 'Giơi hạn dươi', detail: 'Giới hạn dưới để lấy tích phân hàm ERF.' },+ upperLimit: { name: 'giới hạn trên', detail: 'Giới hạn trên để lấy tích phân hàm ERF. Nếu bị bỏ qua, hàm ERF lấy tích phân giữa số không và lower_limit.' },},},ERF_PRECISE: {@@ -406,14 +293,7 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ x: { name: 'Giơi hạn dươi', detail: 'Giới hạn dưới để lấy tích phân hàm ERF.PRECISE.' },},},ERFC: {@@ -426,14 +306,7 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ x: { name: 'Giơi hạn dươi', detail: 'Giới hạn dưới để lấy tích phân hàm ERFC.' },},},ERFC_PRECISE: {@@ -446,14 +319,7 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ x: { name: 'Giơi hạn dươi', detail: 'Giới hạn dưới để lấy tích phân hàm ERFC.PRECISE.' },},},GESTEP: {@@ -486,14 +352,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'số thập lục phân', detail: 'Số thập lục phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},HEX2DEC: {@@ -506,14 +366,7 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'số thập lục phân', detail: 'Số thập lục phân mà bạn muốn chuyển đổi.' },},},HEX2OCT: {@@ -526,14 +379,8 @@ export default {},],functionParameter: {- number1: {- name: 'number1',- detail: 'đầu tiên',- },- number2: {- name: 'number2',- detail: 'thứ hai',- },+ number: { name: 'số thập lục phân', detail: 'Số thập lục phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},IMABS: {@@ -981,8 +828,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'đầu tiên' },- number2: { name: 'number2', detail: 'thứ hai' },+ number: { name: 'Số bát phân', detail: 'Số bát phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},OCT2DEC: {@@ -995,8 +842,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'đầu tiên' },- number2: { name: 'number2', detail: 'thứ hai' },+ number: { name: 'Số bát phân', detail: 'Số bát phân mà bạn muốn chuyển đổi.' },},},OCT2HEX: {@@ -1009,8 +855,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'đầu tiên' },- number2: { name: 'number2', detail: 'thứ hai' },+ number: { name: 'Số bát phân', detail: 'Số bát phân mà bạn muốn chuyển đổi.' },+ places: { name: 'Số ký tự', detail: 'Số ký tự sử dụng.' },},},};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 cf6d1ac700..f83e61a3ab 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@@ -25,8 +25,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '用来计算函数的值。' },+ n: { name: 'N', detail: '贝赛耳函数的阶数。如果n不是整数,将被截尾取整。' },},},BESSELJ: {@@ -39,8 +39,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '用来计算函数的值。' },+ n: { name: 'N', detail: '贝赛耳函数的阶数。如果n不是整数,将被截尾取整。' },},},BESSELK: {@@ -53,8 +53,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '用来计算函数的值。' },+ n: { name: 'N', detail: '贝赛耳函数的阶数。如果n不是整数,将被截尾取整。' },},},BESSELY: {@@ -67,8 +67,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '用来计算函数的值。' },+ n: { name: 'N', detail: '贝赛耳函数的阶数。如果n不是整数,将被截尾取整。' },},},BIN2DEC: {@@ -81,8 +81,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '二进制数', detail: '要转换的二进制数。' },},},BIN2HEX: {@@ -95,8 +94,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '二进制数', detail: '要转换的二进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},BIN2OCT: {@@ -109,8 +108,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '二进制数', detail: '要转换的二进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},BITAND: {@@ -123,8 +122,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '数值1', detail: '必须为十进制格式且大于等于 0。' },+ number2: { name: '数值2', detail: '必须为十进制格式且大于等于 0。' },},},BITLSHIFT: {@@ -137,8 +136,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '数值', detail: '必须是大于或等于 0 的整数。' },+ shiftAmount: { name: '移位量', detail: '必须为整数。' },},},BITOR: {@@ -151,8 +150,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '数值1', detail: '必须为十进制格式且大于等于 0。' },+ number2: { name: '数值2', detail: '必须为十进制格式且大于等于 0。' },},},BITRSHIFT: {@@ -165,8 +164,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '数值', detail: '必须是大于或等于 0 的整数。' },+ shiftAmount: { name: '移位量', detail: '必须为整数。' },},},BITXOR: {@@ -179,8 +178,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '数值1', detail: '必须为十进制格式且大于等于 0。' },+ number2: { name: '数值2', detail: '必须为十进制格式且大于等于 0。' },},},COMPLEX: {@@ -193,8 +192,9 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ realNum: { name: '实系数', detail: '复数的实系数。' },+ iNum: { name: '虚系数', detail: '复数的虚系数。' },+ suffix: { name: '后缀', detail: '复数中虚系数的后缀。如果省略,则认为它是“i”。' },},},CONVERT: {@@ -207,8 +207,9 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '数值', detail: '需要进行转换的数值。' },+ fromUnit: { name: '转换前单位', detail: '是数值的单位。' },+ toUnit: { name: '转换后单位', detail: '是结果的单位。' },},},DEC2BIN: {@@ -221,8 +222,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十进制数', detail: '要转换的十进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},DEC2HEX: {@@ -235,8 +236,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十进制数', detail: '要转换的十进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},DEC2OCT: {@@ -249,8 +250,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十进制数', detail: '要转换的十进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},DELTA: {@@ -263,8 +264,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '数值1', detail: '第一个数值。' },+ number2: { name: '数值2', detail: '第二个数值。如果省略,则假设数值2为零。' },},},ERF: {@@ -277,8 +278,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ lowerLimit: { name: '下限', detail: 'ERF函数的积分下限。' },+ upperLimit: { name: '上限', detail: 'ERF函数的积分上限。如果省略,ERF积分将在零到下限之间。' },},},ERF_PRECISE: {@@ -291,8 +292,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: 'ERF.PRECISE函数的积分下限。' },},},ERFC: {@@ -305,8 +305,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: 'ERFC函数的积分下限。' },},},ERFC_PRECISE: {@@ -319,8 +318,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: 'ERFC.PRECISE函数的积分下限。' },},},GESTEP: {@@ -347,8 +345,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十六进制数', detail: '要转换的十六进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},HEX2DEC: {@@ -361,8 +359,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十六进制数', detail: '要转换的十六进制数。' },},},HEX2OCT: {@@ -375,8 +372,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十六进制数', detail: '要转换的十六进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},IMABS: {@@ -739,8 +736,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '八进制数', detail: '要转换的八进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},OCT2DEC: {@@ -753,8 +750,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '八进制数', detail: '要转换的八进制数。' },},},OCT2HEX: {@@ -767,8 +763,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '八进制数', detail: '要转换的八进制数。' },+ places: { name: '字符数', detail: '要使用的字符数。' },},},};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 d4503f5e49..872cda9d3c 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@@ -25,8 +25,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '這是用於評估函數的值。' },+ n: { name: 'N', detail: '這是Bessel函數的順序。如果n不是整數,則會取至整數。' },},},BESSELJ: {@@ -39,8 +39,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '這是用於評估函數的值。' },+ n: { name: 'N', detail: '這是Bessel函數的順序。如果n不是整數,則會取至整數。' },},},BESSELK: {@@ -53,8 +53,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '這是用於評估函數的值。' },+ n: { name: 'N', detail: '這是Bessel函數的順序。如果n不是整數,則會取至整數。' },},},BESSELY: {@@ -67,8 +67,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: 'X', detail: '這是用於評估函數的值。' },+ n: { name: 'N', detail: '這是Bessel函數的順序。如果n不是整數,則會取至整數。' },},},BIN2DEC: {@@ -81,8 +81,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '二進制數', detail: '您要轉換的二進制數。' },},},BIN2HEX: {@@ -95,8 +94,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '二進制數', detail: '您要轉換的二進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},BIN2OCT: {@@ -109,8 +108,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '二進制數', detail: '您要轉換的二進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},BITAND: {@@ -123,8 +122,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '數值1', detail: '必須是十進位格式,且大於或等於 0。' },+ number2: { name: '數值2', detail: '必須是十進位格式,且大於或等於 0。' },},},BITLSHIFT: {@@ -137,8 +136,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '數值', detail: '必須是大於或等於 0 的整數。' },+ shiftAmount: { name: '移位量', detail: '必須是整數。' },},},BITOR: {@@ -151,8 +150,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '數值1', detail: '必須是十進位格式,且大於或等於 0。' },+ number2: { name: '數值2', detail: '必須是十進位格式,且大於或等於 0。' },},},BITRSHIFT: {@@ -165,8 +164,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '數值', detail: '必須是大於或等於 0 的整數。' },+ shiftAmount: { name: '移位量', detail: '必須是整數。' },},},BITXOR: {@@ -179,8 +178,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '數值1', detail: '必須是十進位格式,且大於或等於 0。' },+ number2: { name: '數值2', detail: '必須是十進位格式,且大於或等於 0。' },},},COMPLEX: {@@ -193,8 +192,9 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ realNum: { name: '實係數', detail: '這是複數的實係數。' },+ iNum: { name: '虛係數', detail: '這是複數的虛係數。' },+ suffix: { name: '字尾', detail: '這是複數虛數元件的字尾。如果省略,會將字尾假設為 "i"。' },},},CONVERT: {@@ -207,8 +207,9 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '數值', detail: '要轉換的值。' },+ fromUnit: { name: '轉換前單位', detail: '這是數值的單位。' },+ toUnit: { name: '轉換后單位', detail: '這是結果的單位。' },},},DEC2BIN: {@@ -221,8 +222,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十進制數', detail: '您要轉換的十進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},DEC2HEX: {@@ -235,8 +236,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十進制數', detail: '您要轉換的十進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},DEC2OCT: {@@ -249,8 +250,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十進制數', detail: '您要轉換的十進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},DELTA: {@@ -263,8 +264,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number1: { name: '數值1', detail: '這是第一個數值。' },+ number2: { name: '數值2', detail: '這是第二個數值。如果省略,會將數值2假設為零。' },},},ERF: {@@ -277,8 +278,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ lowerLimit: { name: '下限', detail: '這是整合ERF的下限。' },+ upperLimit: { name: '上限', detail: '這是整合ERF的上限。如果省略,ERF會在零和下限之間整合。' },},},ERF_PRECISE: {@@ -291,8 +292,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: '這是整合ERF.PRECISE的下限。' },},},ERFC: {@@ -305,8 +305,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: '這是整合ERFC的下限。' },},},ERFC_PRECISE: {@@ -319,8 +318,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ x: { name: '下限', detail: '這是整合ERFC.PRECISE的下限。' },},},GESTEP: {@@ -347,8 +345,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十六進制數', detail: '您要轉換的十六進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},HEX2DEC: {@@ -361,8 +359,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十六進制數', detail: '您要轉換的十六進制數。' },},},HEX2OCT: {@@ -375,8 +372,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '十六進制數', detail: '您要轉換的十六進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},IMABS: {@@ -739,8 +736,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '八進制數', detail: '您要轉換的八進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},OCT2DEC: {@@ -753,8 +750,7 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '八進制數', detail: '您要轉換的八進制數。' },},},OCT2HEX: {@@ -767,8 +763,8 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ number: { name: '八進制數', detail: '您要轉換的八進制數。' },+ places: { name: '字元數', detail: '這是要使用的字元數。' },},},};diff --git a/packages/sheets-formula/src/locale/function-list/logical/en-US.ts b/packages/sheets-formula/src/locale/function-list/logical/en-US.tsindex b1e0ab8306..5511906c07 100644--- a/packages/sheets-formula/src/locale/function-list/logical/en-US.ts+++ b/packages/sheets-formula/src/locale/function-list/logical/en-US.ts@@ -163,8 +163,11 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ name1: { name: 'name1', detail: 'The first name to assign. Must start with a letter. Cannot be the output of a formula or conflict with range syntax.' },+ nameValue1: { name: 'name_value1', detail: 'The value that is assigned to name1.' },+ calculationOrName2: { name: 'calculation_or_name2', detail: 'One of the following:\n1.A calculation that uses all names within the LET function. This must be the last argument in the LET function.\n2.A second name to assign to a second name_value. If a name is specified, name_value2 and calculation_or_name3 become required.' },+ nameValue2: { name: 'name_value2', detail: 'The value that is assigned to calculation_or_name2.' },+ calculationOrName3: { name: 'calculation_or_name3', detail: 'One of the following:\n1.A calculation that uses all names within the LET function. The last argument in the LET function must be a calculation.\n2.A third name to assign to a third name_value. If a name is specified, name_value3 and calculation_or_name4 become required.' },},},MAKEARRAY: {diff --git a/packages/sheets-formula/src/locale/function-list/logical/ja-JP.ts b/packages/sheets-formula/src/locale/function-list/logical/ja-JP.tsindex 3245fa71ca..83487f2608 100644--- a/packages/sheets-formula/src/locale/function-list/logical/ja-JP.ts+++ b/packages/sheets-formula/src/locale/function-list/logical/ja-JP.ts@@ -157,8 +157,11 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ name1: { name: '名前1', detail: '最初に割り当てる名前。文字で始まる必要があります。数式の出力であったり、範囲の構文と競合していたりしてはなりません。' },+ nameValue1: { name: '値1', detail: 'name1 に割り当てられている値。' },+ calculationOrName2: { name: '計算または名前2', detail: '以下のいずれかになります。\n1.LET 関数内のすべての名前を使用する計算。LET 関数の最後の引数でなければなりません。\n2.2 番目の name_value に割り当てる 2 番目の名前。名前が指定されている場合、name_value2 と calculation_or_name3 が必須です。' },+ nameValue2: { name: '値2', detail: 'calculation_or_name2 に割り当てられている値。' },+ calculationOrName3: { name: '計算または名前3', detail: '以下のいずれかになります。\n1.LET 関数内のすべての名前を使用する計算。LET 関数の最後の引数は計算でなければなりません。\n2.3 番目の name_value に割り当てる 3 番目の名前。名前が指定されている場合、name_value3 と calculation_or_name4 が必須です。' },},},MAKEARRAY: {diff --git a/packages/sheets-formula/src/locale/function-list/logical/vi-VN.ts b/packages/sheets-formula/src/locale/function-list/logical/vi-VN.tsindex 7fd13bb40a..aec8fab940 100644--- a/packages/sheets-formula/src/locale/function-list/logical/vi-VN.ts+++ b/packages/sheets-formula/src/locale/function-list/logical/vi-VN.ts@@ -158,8 +158,11 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'đầu tiên' },- number2: { name: 'number2', detail: 'thứ hai' },+ name1: { name: 'tên 1', detail: 'Tên đầu tiên cần phải gán. Phải bắt đầu bằng một chữ cái. Không thể là kết quả của công thức hoặc xung đột với cú pháp dải ô.' },+ nameValue1: { name: 'giá trị 1', detail: 'Giá trị gán cho name1.' },+ calculationOrName2: { name: 'tính toán hoặc tên 2', detail: 'Một trong những điều sau:\n1.Phép tính sử dụng tất cả các tên trong hàm LET. Đây phải là đối số cuối cùng trong hàm LET.\n2.Tên thứ hai cần gán cho name_value thứ hai. Nếu tên đã được xác định, name_value2 và calculation_or_name3 sẽ trở thành bắt buộc.' },+ nameValue2: { name: 'giá trị 2', detail: 'Giá trị gán cho calculation_or_name2.' },+ calculationOrName3: { name: 'tính toán hoặc tên 3', detail: 'Một trong những điều sau:\n1.Phép tính sử dụng tất cả các tên trong hàm LET. Đối số cuối cùng trong hàm LET phải là một phép tính.\n2.Tên thứ ba cần gán cho name_value thứ ba. Nếu tên đã được xác định, name_value3 và calculation_or_name4 sẽ trở thành bắt buộc.' },},},MAKEARRAY: {diff --git a/packages/sheets-formula/src/locale/function-list/logical/zh-CN.ts b/packages/sheets-formula/src/locale/function-list/logical/zh-CN.tsindex cd7dce8b52..f239077b5d 100644--- a/packages/sheets-formula/src/locale/function-list/logical/zh-CN.ts+++ b/packages/sheets-formula/src/locale/function-list/logical/zh-CN.ts@@ -158,8 +158,11 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ name1: { name: '名称1', detail: '要分配的第一个名称。必须以字母开头。不能是公式的输出,也不能与范围语法冲突。' },+ nameValue1: { name: '值1', detail: '分配给 name1 的值。' },+ calculationOrName2: { name: '计算或名称2', detail: '下列任一项:\n1.使用 LET 函数中的所有名称的计算。这必须是 LET 函数中的最后一个参数。\n2.分配给第二个 name_value 的第二个名称。如果指定了名称,则 name_value2 和 calculation_or_name3 是必需的。' },+ nameValue2: { name: '值2', detail: '分配给 calculation_or_name2 的值。' },+ calculationOrName3: { name: '计算或名称3', detail: '下列任一项:\n1.使用 LET 函数中的所有名称的计算。LET 函数中的最后一个参数必须是一个计算。\n2.分配给第三个 name_value 的第三个名称。如果指定了名称,则 name_value3 和 calculation_or_name4 是必需的。' },},},MAKEARRAY: {diff --git a/packages/sheets-formula/src/locale/function-list/logical/zh-TW.ts b/packages/sheets-formula/src/locale/function-list/logical/zh-TW.tsindex 4dd7464944..df1bf37685 100644--- a/packages/sheets-formula/src/locale/function-list/logical/zh-TW.ts+++ b/packages/sheets-formula/src/locale/function-list/logical/zh-TW.ts@@ -159,8 +159,11 @@ export default {},],functionParameter: {- number1: { name: 'number1', detail: 'first' },- number2: { name: 'number2', detail: 'second' },+ name1: { name: '名稱1', detail: '第一個指派的名稱。必須以字母開頭。不能是公式的輸出結果,或與範圍語法衝突。' },+ nameValue1: { name: '值1', detail: '指派給名稱1(name 1)的值。' },+ calculationOrName2: { name: '計算或名稱2', detail: '下列其中一項:\n1.使用 LET 函數中所有名稱的計算。這必須是 LET 函數中的最後一個引數。\n2.指派給第二個 name_value 的第二個名稱。若有指定名稱,則必須要有 name_value2 和 calculation_ 或 _name3。' },+ nameValue2: { name: '值2', detail: '指派給 calculation_or_name2 的值。' },+ calculationOrName3: { name: '計算或名稱3', detail: '下列其中一項:\n1.使用 LET 函數中所有名稱的計算。LET 函數中的最後一個引數必須是計算。\n2.指派給第三個 name_value 的第三個名稱。若有指定名稱,則必須要有 name_value3 和 calculation_ 或 _name4。' },},},MAKEARRAY: {diff --git a/packages/sheets-formula/src/services/function-list/engineering.ts b/packages/sheets-formula/src/services/function-list/engineering.tsindex acdc09a5c7..ed7244374f 100644--- a/packages/sheets-formula/src/services/function-list/engineering.ts+++ b/packages/sheets-formula/src/services/function-list/engineering.ts@@ -24,16 +24,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BESSELI.abstract',functionParameter: [{- name: 'formula.functionList.BESSELI.functionParameter.number1.name',- detail: 'formula.functionList.BESSELI.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.BESSELI.functionParameter.x.name',+ detail: 'formula.functionList.BESSELI.functionParameter.x.detail',+ example: '1.5',require: 1,repeat: 0,},{- name: 'formula.functionList.BESSELI.functionParameter.number2.name',- detail: 'formula.functionList.BESSELI.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.BESSELI.functionParameter.n.name',+ detail: 'formula.functionList.BESSELI.functionParameter.n.detail',+ example: '1',require: 1,repeat: 0,},@@ -46,16 +46,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BESSELJ.abstract',functionParameter: [{- name: 'formula.functionList.BESSELJ.functionParameter.number1.name',- detail: 'formula.functionList.BESSELJ.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.BESSELJ.functionParameter.x.name',+ detail: 'formula.functionList.BESSELJ.functionParameter.x.detail',+ example: '1.5',require: 1,repeat: 0,},{- name: 'formula.functionList.BESSELJ.functionParameter.number2.name',- detail: 'formula.functionList.BESSELJ.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.BESSELJ.functionParameter.n.name',+ detail: 'formula.functionList.BESSELJ.functionParameter.n.detail',+ example: '1',require: 1,repeat: 0,},@@ -68,16 +68,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BESSELK.abstract',functionParameter: [{- name: 'formula.functionList.BESSELK.functionParameter.number1.name',- detail: 'formula.functionList.BESSELK.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.BESSELK.functionParameter.x.name',+ detail: 'formula.functionList.BESSELK.functionParameter.x.detail',+ example: '1.5',require: 1,repeat: 0,},{- name: 'formula.functionList.BESSELK.functionParameter.number2.name',- detail: 'formula.functionList.BESSELK.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.BESSELK.functionParameter.n.name',+ detail: 'formula.functionList.BESSELK.functionParameter.n.detail',+ example: '1',require: 1,repeat: 0,},@@ -90,16 +90,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BESSELY.abstract',functionParameter: [{- name: 'formula.functionList.BESSELY.functionParameter.number1.name',- detail: 'formula.functionList.BESSELY.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.BESSELY.functionParameter.x.name',+ detail: 'formula.functionList.BESSELY.functionParameter.x.detail',+ example: '1.5',require: 1,repeat: 0,},{- name: 'formula.functionList.BESSELY.functionParameter.number2.name',- detail: 'formula.functionList.BESSELY.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.BESSELY.functionParameter.n.name',+ detail: 'formula.functionList.BESSELY.functionParameter.n.detail',+ example: '1',require: 1,repeat: 0,},@@ -112,16 +112,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BIN2DEC.abstract',functionParameter: [{- name: 'formula.functionList.BIN2DEC.functionParameter.number1.name',- detail: 'formula.functionList.BIN2DEC.functionParameter.number1.detail',- example: 'A1:A20',- require: 1,- repeat: 0,- },- {- name: 'formula.functionList.BIN2DEC.functionParameter.number2.name',- detail: 'formula.functionList.BIN2DEC.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.BIN2DEC.functionParameter.number.name',+ detail: 'formula.functionList.BIN2DEC.functionParameter.number.detail',+ example: '1100100',require: 1,repeat: 0,},@@ -134,17 +127,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BIN2HEX.abstract',functionParameter: [{- name: 'formula.functionList.BIN2HEX.functionParameter.number1.name',- detail: 'formula.functionList.BIN2HEX.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.BIN2HEX.functionParameter.number.name',+ detail: 'formula.functionList.BIN2HEX.functionParameter.number.detail',+ example: '11111011',require: 1,repeat: 0,},{- name: 'formula.functionList.BIN2HEX.functionParameter.number2.name',- detail: 'formula.functionList.BIN2HEX.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.BIN2HEX.functionParameter.places.name',+ detail: 'formula.functionList.BIN2HEX.functionParameter.places.detail',+ example: '4',+ require: 0,repeat: 0,},],@@ -156,17 +149,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BIN2OCT.abstract',functionParameter: [{- name: 'formula.functionList.BIN2OCT.functionParameter.number1.name',- detail: 'formula.functionList.BIN2OCT.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.BIN2OCT.functionParameter.number.name',+ detail: 'formula.functionList.BIN2OCT.functionParameter.number.detail',+ example: '1001',require: 1,repeat: 0,},{- name: 'formula.functionList.BIN2OCT.functionParameter.number2.name',- detail: 'formula.functionList.BIN2OCT.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.BIN2OCT.functionParameter.places.name',+ detail: 'formula.functionList.BIN2OCT.functionParameter.places.detail',+ example: '3',+ require: 0,repeat: 0,},],@@ -180,14 +173,14 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [{name: 'formula.functionList.BITAND.functionParameter.number1.name',detail: 'formula.functionList.BITAND.functionParameter.number1.detail',- example: 'A1:A20',+ example: '13',require: 1,repeat: 0,},{name: 'formula.functionList.BITAND.functionParameter.number2.name',detail: 'formula.functionList.BITAND.functionParameter.number2.detail',- example: 'A1:A20',+ example: '25',require: 1,repeat: 0,},@@ -200,16 +193,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BITLSHIFT.abstract',functionParameter: [{- name: 'formula.functionList.BITLSHIFT.functionParameter.number1.name',- detail: 'formula.functionList.BITLSHIFT.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.BITLSHIFT.functionParameter.number.name',+ detail: 'formula.functionList.BITLSHIFT.functionParameter.number.detail',+ example: '4',require: 1,repeat: 0,},{- name: 'formula.functionList.BITLSHIFT.functionParameter.number2.name',- detail: 'formula.functionList.BITLSHIFT.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.BITLSHIFT.functionParameter.shiftAmount.name',+ detail: 'formula.functionList.BITLSHIFT.functionParameter.shiftAmount.detail',+ example: '2',require: 1,repeat: 0,},@@ -224,14 +217,14 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [{name: 'formula.functionList.BITOR.functionParameter.number1.name',detail: 'formula.functionList.BITOR.functionParameter.number1.detail',- example: 'A1:A20',+ example: '23',require: 1,repeat: 0,},{name: 'formula.functionList.BITOR.functionParameter.number2.name',detail: 'formula.functionList.BITOR.functionParameter.number2.detail',- example: 'A1:A20',+ example: '10',require: 1,repeat: 0,},@@ -244,16 +237,16 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.BITRSHIFT.abstract',functionParameter: [{- name: 'formula.functionList.BITRSHIFT.functionParameter.number1.name',- detail: 'formula.functionList.BITRSHIFT.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.BITRSHIFT.functionParameter.number.name',+ detail: 'formula.functionList.BITRSHIFT.functionParameter.number.detail',+ example: '13',require: 1,repeat: 0,},{- name: 'formula.functionList.BITRSHIFT.functionParameter.number2.name',- detail: 'formula.functionList.BITRSHIFT.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.BITRSHIFT.functionParameter.shiftAmount.name',+ detail: 'formula.functionList.BITRSHIFT.functionParameter.shiftAmount.detail',+ example: '2',require: 1,repeat: 0,},@@ -268,14 +261,14 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [{name: 'formula.functionList.BITXOR.functionParameter.number1.name',detail: 'formula.functionList.BITXOR.functionParameter.number1.detail',- example: 'A1:A20',+ example: '5',require: 1,repeat: 0,},{name: 'formula.functionList.BITXOR.functionParameter.number2.name',detail: 'formula.functionList.BITXOR.functionParameter.number2.detail',- example: 'A1:A20',+ example: '3',require: 1,repeat: 0,},@@ -288,19 +281,26 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.COMPLEX.abstract',functionParameter: [{- name: 'formula.functionList.COMPLEX.functionParameter.number1.name',- detail: 'formula.functionList.COMPLEX.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.COMPLEX.functionParameter.realNum.name',+ detail: 'formula.functionList.COMPLEX.functionParameter.realNum.detail',+ example: '3',require: 1,repeat: 0,},{- name: 'formula.functionList.COMPLEX.functionParameter.number2.name',- detail: 'formula.functionList.COMPLEX.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.COMPLEX.functionParameter.iNum.name',+ detail: 'formula.functionList.COMPLEX.functionParameter.iNum.detail',+ example: '4',require: 1,repeat: 0,},+ {+ name: 'formula.functionList.COMPLEX.functionParameter.suffix.name',+ detail: 'formula.functionList.COMPLEX.functionParameter.suffix.detail',+ example: '"i"',+ require: 0,+ repeat: 0,+ },],},{@@ -310,16 +310,23 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.CONVERT.abstract',functionParameter: [{- name: 'formula.functionList.CONVERT.functionParameter.number1.name',- detail: 'formula.functionList.CONVERT.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.CONVERT.functionParameter.number.name',+ detail: 'formula.functionList.CONVERT.functionParameter.number.detail',+ example: '1',require: 1,repeat: 0,},{- name: 'formula.functionList.CONVERT.functionParameter.number2.name',- detail: 'formula.functionList.CONVERT.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.CONVERT.functionParameter.fromUnit.name',+ detail: 'formula.functionList.CONVERT.functionParameter.fromUnit.detail',+ example: '"lbm"',+ require: 1,+ repeat: 0,+ },+ {+ name: 'formula.functionList.CONVERT.functionParameter.toUnit.name',+ detail: 'formula.functionList.CONVERT.functionParameter.toUnit.detail',+ example: '"kg"',require: 1,repeat: 0,},@@ -332,17 +339,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.DEC2BIN.abstract',functionParameter: [{- name: 'formula.functionList.DEC2BIN.functionParameter.number1.name',- detail: 'formula.functionList.DEC2BIN.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.DEC2BIN.functionParameter.number.name',+ detail: 'formula.functionList.DEC2BIN.functionParameter.number.detail',+ example: '9',require: 1,repeat: 0,},{- name: 'formula.functionList.DEC2BIN.functionParameter.number2.name',- detail: 'formula.functionList.DEC2BIN.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.DEC2BIN.functionParameter.places.name',+ detail: 'formula.functionList.DEC2BIN.functionParameter.places.detail',+ example: '4',+ require: 0,repeat: 0,},],@@ -354,17 +361,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.DEC2HEX.abstract',functionParameter: [{- name: 'formula.functionList.DEC2HEX.functionParameter.number1.name',- detail: 'formula.functionList.DEC2HEX.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.DEC2HEX.functionParameter.number.name',+ detail: 'formula.functionList.DEC2HEX.functionParameter.number.detail',+ example: '100',require: 1,repeat: 0,},{- name: 'formula.functionList.DEC2HEX.functionParameter.number2.name',- detail: 'formula.functionList.DEC2HEX.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.DEC2HEX.functionParameter.places.name',+ detail: 'formula.functionList.DEC2HEX.functionParameter.places.detail',+ example: '4',+ require: 0,repeat: 0,},],@@ -376,17 +383,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.DEC2OCT.abstract',functionParameter: [{- name: 'formula.functionList.DEC2OCT.functionParameter.number1.name',- detail: 'formula.functionList.DEC2OCT.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.DEC2OCT.functionParameter.number.name',+ detail: 'formula.functionList.DEC2OCT.functionParameter.number.detail',+ example: '58',require: 1,repeat: 0,},{- name: 'formula.functionList.DEC2OCT.functionParameter.number2.name',- detail: 'formula.functionList.DEC2OCT.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.DEC2OCT.functionParameter.places.name',+ detail: 'formula.functionList.DEC2OCT.functionParameter.places.detail',+ example: '3',+ require: 0,repeat: 0,},],@@ -400,15 +407,15 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [{name: 'formula.functionList.DELTA.functionParameter.number1.name',detail: 'formula.functionList.DELTA.functionParameter.number1.detail',- example: 'A1:A20',+ example: '5',require: 1,repeat: 0,},{name: 'formula.functionList.DELTA.functionParameter.number2.name',detail: 'formula.functionList.DELTA.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ example: '4',+ require: 0,repeat: 0,},],@@ -420,17 +427,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.ERF.abstract',functionParameter: [{- name: 'formula.functionList.ERF.functionParameter.number1.name',- detail: 'formula.functionList.ERF.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.ERF.functionParameter.lowerLimit.name',+ detail: 'formula.functionList.ERF.functionParameter.lowerLimit.detail',+ example: '0.745',require: 1,repeat: 0,},{- name: 'formula.functionList.ERF.functionParameter.number2.name',- detail: 'formula.functionList.ERF.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.ERF.functionParameter.upperLimit.name',+ detail: 'formula.functionList.ERF.functionParameter.upperLimit.detail',+ example: '2',+ require: 0,repeat: 0,},],@@ -442,16 +449,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.ERF_PRECISE.abstract',functionParameter: [{- name: 'formula.functionList.ERF_PRECISE.functionParameter.number1.name',- detail: 'formula.functionList.ERF_PRECISE.functionParameter.number1.detail',- example: 'A1:A20',- require: 1,- repeat: 0,- },- {- name: 'formula.functionList.ERF_PRECISE.functionParameter.number2.name',- detail: 'formula.functionList.ERF_PRECISE.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.ERF_PRECISE.functionParameter.x.name',+ detail: 'formula.functionList.ERF_PRECISE.functionParameter.x.detail',+ example: '1',require: 1,repeat: 0,},@@ -464,16 +464,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.ERFC.abstract',functionParameter: [{- name: 'formula.functionList.ERFC.functionParameter.number1.name',- detail: 'formula.functionList.ERFC.functionParameter.number1.detail',- example: 'A1:A20',- require: 1,- repeat: 0,- },- {- name: 'formula.functionList.ERFC.functionParameter.number2.name',- detail: 'formula.functionList.ERFC.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.ERFC.functionParameter.x.name',+ detail: 'formula.functionList.ERFC.functionParameter.x.detail',+ example: '1',require: 1,repeat: 0,},@@ -486,16 +479,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.ERFC_PRECISE.abstract',functionParameter: [{- name: 'formula.functionList.ERFC_PRECISE.functionParameter.number1.name',- detail: 'formula.functionList.ERFC_PRECISE.functionParameter.number1.detail',- example: 'A1:A20',- require: 1,- repeat: 0,- },- {- name: 'formula.functionList.ERFC_PRECISE.functionParameter.number2.name',- detail: 'formula.functionList.ERFC_PRECISE.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.ERFC_PRECISE.functionParameter.x.name',+ detail: 'formula.functionList.ERFC_PRECISE.functionParameter.x.detail',+ example: '1',require: 1,repeat: 0,},@@ -530,17 +516,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.HEX2BIN.abstract',functionParameter: [{- name: 'formula.functionList.HEX2BIN.functionParameter.number1.name',- detail: 'formula.functionList.HEX2BIN.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.HEX2BIN.functionParameter.number.name',+ detail: 'formula.functionList.HEX2BIN.functionParameter.number.detail',+ example: '"F"',require: 1,repeat: 0,},{- name: 'formula.functionList.HEX2BIN.functionParameter.number2.name',- detail: 'formula.functionList.HEX2BIN.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.HEX2BIN.functionParameter.places.name',+ detail: 'formula.functionList.HEX2BIN.functionParameter.places.detail',+ example: '8',+ require: 0,repeat: 0,},],@@ -552,16 +538,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.HEX2DEC.abstract',functionParameter: [{- name: 'formula.functionList.HEX2DEC.functionParameter.number1.name',- detail: 'formula.functionList.HEX2DEC.functionParameter.number1.detail',- example: 'A1:A20',- require: 1,- repeat: 0,- },- {- name: 'formula.functionList.HEX2DEC.functionParameter.number2.name',- detail: 'formula.functionList.HEX2DEC.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.HEX2DEC.functionParameter.number.name',+ detail: 'formula.functionList.HEX2DEC.functionParameter.number.detail',+ example: '"A5"',require: 1,repeat: 0,},@@ -574,17 +553,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.HEX2OCT.abstract',functionParameter: [{- name: 'formula.functionList.HEX2OCT.functionParameter.number1.name',- detail: 'formula.functionList.HEX2OCT.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.HEX2OCT.functionParameter.number.name',+ detail: 'formula.functionList.HEX2OCT.functionParameter.number.detail',+ example: '"F"',require: 1,repeat: 0,},{- name: 'formula.functionList.HEX2OCT.functionParameter.number2.name',- detail: 'formula.functionList.HEX2OCT.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.HEX2OCT.functionParameter.places.name',+ detail: 'formula.functionList.HEX2OCT.functionParameter.places.detail',+ example: '3',+ require: 0,repeat: 0,},],@@ -1146,17 +1125,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.OCT2BIN.abstract',functionParameter: [{- name: 'formula.functionList.OCT2BIN.functionParameter.number1.name',- detail: 'formula.functionList.OCT2BIN.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.OCT2BIN.functionParameter.number.name',+ detail: 'formula.functionList.OCT2BIN.functionParameter.number.detail',+ example: '3',require: 1,repeat: 0,},{- name: 'formula.functionList.OCT2BIN.functionParameter.number2.name',- detail: 'formula.functionList.OCT2BIN.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.OCT2BIN.functionParameter.places.name',+ detail: 'formula.functionList.OCT2BIN.functionParameter.places.detail',+ example: '3',+ require: 0,repeat: 0,},],@@ -1168,16 +1147,9 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.OCT2DEC.abstract',functionParameter: [{- name: 'formula.functionList.OCT2DEC.functionParameter.number1.name',- detail: 'formula.functionList.OCT2DEC.functionParameter.number1.detail',- example: 'A1:A20',- require: 1,- repeat: 0,- },- {- name: 'formula.functionList.OCT2DEC.functionParameter.number2.name',- detail: 'formula.functionList.OCT2DEC.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.OCT2DEC.functionParameter.number.name',+ detail: 'formula.functionList.OCT2DEC.functionParameter.number.detail',+ example: '54',require: 1,repeat: 0,},@@ -1190,17 +1162,17 @@ export const FUNCTION_LIST_ENGINEERING: IFunctionInfo[] = [abstract: 'formula.functionList.OCT2HEX.abstract',functionParameter: [{- name: 'formula.functionList.OCT2HEX.functionParameter.number1.name',- detail: 'formula.functionList.OCT2HEX.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.OCT2HEX.functionParameter.number.name',+ detail: 'formula.functionList.OCT2HEX.functionParameter.number.detail',+ example: '100',require: 1,repeat: 0,},{- name: 'formula.functionList.OCT2HEX.functionParameter.number2.name',- detail: 'formula.functionList.OCT2HEX.functionParameter.number2.detail',- example: 'A1:A20',- require: 1,+ name: 'formula.functionList.OCT2HEX.functionParameter.places.name',+ detail: 'formula.functionList.OCT2HEX.functionParameter.places.detail',+ example: '4',+ require: 0,repeat: 0,},],diff --git a/packages/sheets-formula/src/services/function-list/logical.ts b/packages/sheets-formula/src/services/function-list/logical.tsindex 55a83c54d1..35c641d91c 100644--- a/packages/sheets-formula/src/services/function-list/logical.ts+++ b/packages/sheets-formula/src/services/function-list/logical.ts@@ -229,19 +229,40 @@ export const FUNCTION_LIST_LOGICAL: IFunctionInfo[] = [abstract: 'formula.functionList.LET.abstract',functionParameter: [{- name: 'formula.functionList.LET.functionParameter.number1.name',- detail: 'formula.functionList.LET.functionParameter.number1.detail',- example: 'A1:A20',+ name: 'formula.functionList.LET.functionParameter.name1.name',+ detail: 'formula.functionList.LET.functionParameter.name1.detail',+ example: 'x',require: 1,repeat: 0,},{- name: 'formula.functionList.LET.functionParameter.number2.name',- detail: 'formula.functionList.LET.functionParameter.number2.detail',- example: 'A1:A20',+ name: 'formula.functionList.LET.functionParameter.nameValue1.name',+ detail: 'formula.functionList.LET.functionParameter.nameValue1.detail',+ example: '5',require: 1,repeat: 0,},+ {+ name: 'formula.functionList.LET.functionParameter.calculationOrName2.name',+ detail: 'formula.functionList.LET.functionParameter.calculationOrName2.detail',+ example: 'y',+ require: 1,+ repeat: 0,+ },+ {+ name: 'formula.functionList.LET.functionParameter.nameValue2.name',+ detail: 'formula.functionList.LET.functionParameter.nameValue2.detail',+ example: '6',+ require: 0,+ repeat: 1,+ },+ {+ name: 'formula.functionList.LET.functionParameter.calculationOrName3.name',+ detail: 'formula.functionList.LET.functionParameter.calculationOrName3.detail',+ example: 'SUM(x,y)',+ require: 0,+ repeat: 1,+ },],},{