Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

feat(formula): add some engineering function (#2893)

wpxp1234569386c6bbd093
diff --git a/packages/engine-formula/src/basics/engineering.ts b/packages/engine-formula/src/basics/engineering.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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...
+ // TODO
return 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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,
+ },
],
},
{