From f5875e571598acc6a48f0afa9d5212100e939c48 Mon Sep 17 00:00:00 2001 From: wpxp123456 Date: Wed, 9 Oct 2024 21:20:45 +0800 Subject: [PATCH] feat(formula): add t.test/trimmean/weibull.dist/z.test function --- .../functions/compatibility/function-map.ts | 6 + .../src/functions/statistical/function-map.ts | 8 + .../t-test/__tests__/index.spec.ts | 265 ++++++++++ .../src/functions/statistical/t-test/index.ts | 344 +++++++++++++ .../trimmean/__tests__/index.spec.ts | 126 +++++ .../functions/statistical/trimmean/index.ts | 110 ++++ .../weibull-dist/__tests__/index.spec.ts | 168 +++++++ .../statistical/weibull-dist/index.ts | 125 +++++ .../z-test/__tests__/index.spec.ts | 151 ++++++ .../src/functions/statistical/z-test/index.ts | 169 +++++++ .../function-list/compatibility/en-US.ts | 17 +- .../function-list/compatibility/ja-JP.ts | 17 +- .../function-list/compatibility/vi-VN.ts | 29 +- .../function-list/compatibility/zh-CN.ts | 17 +- .../function-list/compatibility/zh-TW.ts | 109 ++-- .../src/locale/function-list/date/zh-TW.ts | 42 +- .../locale/function-list/engineering/zh-TW.ts | 142 +++--- .../locale/function-list/financial/zh-CN.ts | 10 +- .../locale/function-list/financial/zh-TW.ts | 468 +++++++++--------- .../locale/function-list/information/zh-TW.ts | 10 +- .../src/locale/function-list/logical/zh-CN.ts | 14 +- .../src/locale/function-list/logical/zh-TW.ts | 10 +- .../src/locale/function-list/lookup/zh-CN.ts | 2 +- .../src/locale/function-list/lookup/zh-TW.ts | 2 +- .../src/locale/function-list/math/zh-TW.ts | 156 +++--- .../locale/function-list/statistical/en-US.ts | 21 +- .../locale/function-list/statistical/ja-JP.ts | 21 +- .../locale/function-list/statistical/vi-VN.ts | 61 +++ .../locale/function-list/statistical/zh-CN.ts | 21 +- .../locale/function-list/statistical/zh-TW.ts | 197 ++++---- .../src/locale/function-list/text/zh-TW.ts | 14 +- .../services/function-list/compatibility.ts | 91 ++-- .../src/services/function-list/financial.ts | 16 +- .../src/services/function-list/lookup.ts | 4 +- .../src/services/function-list/math.ts | 6 +- .../src/services/function-list/statistical.ts | 157 +++--- .../src/services/function-list/text.ts | 2 +- 37 files changed, 2388 insertions(+), 740 deletions(-) create mode 100644 packages/engine-formula/src/functions/statistical/t-test/__tests__/index.spec.ts create mode 100644 packages/engine-formula/src/functions/statistical/t-test/index.ts create mode 100644 packages/engine-formula/src/functions/statistical/trimmean/__tests__/index.spec.ts create mode 100644 packages/engine-formula/src/functions/statistical/trimmean/index.ts create mode 100644 packages/engine-formula/src/functions/statistical/weibull-dist/__tests__/index.spec.ts create mode 100644 packages/engine-formula/src/functions/statistical/weibull-dist/index.ts create mode 100644 packages/engine-formula/src/functions/statistical/z-test/__tests__/index.spec.ts create mode 100644 packages/engine-formula/src/functions/statistical/z-test/index.ts diff --git a/packages/engine-formula/src/functions/compatibility/function-map.ts b/packages/engine-formula/src/functions/compatibility/function-map.ts index ddbac835611a..8eb24ae026e8 100644 --- a/packages/engine-formula/src/functions/compatibility/function-map.ts +++ b/packages/engine-formula/src/functions/compatibility/function-map.ts @@ -40,8 +40,11 @@ import { QuartileInc } from '../statistical/quartile-inc'; import { StdevP } from '../statistical/stdev-p'; import { StdevS } from '../statistical/stdev-s'; import { TInv2t } from '../statistical/t-inv-2t'; +import { TTest } from '../statistical/t-test'; import { VarP } from '../statistical/var-p'; import { VarS } from '../statistical/var-s'; +import { WeibullDist } from '../statistical/weibull-dist'; +import { ZTest } from '../statistical/z-test'; import { Betadist } from './betadist'; import { FUNCTION_NAMES_COMPATIBILITY } from './function-names'; import { Hypgeomdist } from './hypgeomdist'; @@ -85,6 +88,9 @@ export const functionCompatibility = [ [StdevP, FUNCTION_NAMES_COMPATIBILITY.STDEVP], [Tdist, FUNCTION_NAMES_COMPATIBILITY.TDIST], [TInv2t, FUNCTION_NAMES_COMPATIBILITY.TINV], + [TTest, FUNCTION_NAMES_COMPATIBILITY.TTEST], [VarS, FUNCTION_NAMES_COMPATIBILITY.VAR], [VarP, FUNCTION_NAMES_COMPATIBILITY.VARP], + [WeibullDist, FUNCTION_NAMES_COMPATIBILITY.WEIBULL], + [ZTest, FUNCTION_NAMES_COMPATIBILITY.ZTEST], ]; diff --git a/packages/engine-formula/src/functions/statistical/function-map.ts b/packages/engine-formula/src/functions/statistical/function-map.ts index ce9e44667d25..0144e40745ae 100644 --- a/packages/engine-formula/src/functions/statistical/function-map.ts +++ b/packages/engine-formula/src/functions/statistical/function-map.ts @@ -109,10 +109,14 @@ import { TDist2t } from './t-dist-2t'; import { TDistRt } from './t-dist-rt'; import { TInv } from './t-inv'; import { TInv2t } from './t-inv-2t'; +import { TTest } from './t-test'; +import { Trimmean } from './trimmean'; import { VarP } from './var-p'; import { VarS } from './var-s'; import { Vara } from './vara'; import { Varpa } from './varpa'; +import { WeibullDist } from './weibull-dist'; +import { ZTest } from './z-test'; export const functionStatistical = [ [Avedev, FUNCTION_NAMES_STATISTICAL.AVEDEV], @@ -211,8 +215,12 @@ export const functionStatistical = [ [TDistRt, FUNCTION_NAMES_STATISTICAL.T_DIST_RT], [TInv, FUNCTION_NAMES_STATISTICAL.T_INV], [TInv2t, FUNCTION_NAMES_STATISTICAL.T_INV_2T], + [TTest, FUNCTION_NAMES_STATISTICAL.T_TEST], + [Trimmean, FUNCTION_NAMES_STATISTICAL.TRIMMEAN], [VarP, FUNCTION_NAMES_STATISTICAL.VAR_P], [VarS, FUNCTION_NAMES_STATISTICAL.VAR_S], [Vara, FUNCTION_NAMES_STATISTICAL.VARA], [Varpa, FUNCTION_NAMES_STATISTICAL.VARPA], + [WeibullDist, FUNCTION_NAMES_STATISTICAL.WEIBULL_DIST], + [ZTest, FUNCTION_NAMES_STATISTICAL.Z_TEST], ]; diff --git a/packages/engine-formula/src/functions/statistical/t-test/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/t-test/__tests__/index.spec.ts new file mode 100644 index 000000000000..991d0d2fcb83 --- /dev/null +++ b/packages/engine-formula/src/functions/statistical/t-test/__tests__/index.spec.ts @@ -0,0 +1,265 @@ +/** + * 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 { ErrorType } from '../../../../basics/error-type'; +import { ArrayValueObject, transformToValueObject } from '../../../../engine/value-object/array-value-object'; +import { ErrorValueObject } from '../../../../engine/value-object/base-value-object'; +import { NumberValueObject } from '../../../../engine/value-object/primitive-object'; +import { getObjectValue } from '../../../__tests__/create-function-test-bed'; +import { FUNCTION_NAMES_STATISTICAL } from '../../function-names'; +import { TTest } from '../index'; + +describe('Test tTest function', () => { + const testFunction = new TTest(FUNCTION_NAMES_STATISTICAL.T_TEST); + + describe('TTest', () => { + it('Value is normal', () => { + const array1 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [3, 4, 5, 8, 9, 1, 2, 4, 5], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const array2 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [6, 19, 3, 2, 14, 4, 5, 17, 1], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const tails = NumberValueObject.create(2); + const type = NumberValueObject.create(1); + const result = testFunction.calculate(array1, array2, tails, type); + expect(getObjectValue(result)).toBe(0.19601578492529903); + }); + + it('Array1 and array2 value test', () => { + let array1 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [0, 1, 2, 3, null], + ]), + rowCount: 1, + columnCount: 5, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + let array2 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [0.2, 0.3, 0.1, 0.4], + ]), + rowCount: 1, + columnCount: 4, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const tails = NumberValueObject.create(2); + const type = NumberValueObject.create(1); + let result = testFunction.calculate(array1, array2, tails, type); + expect(getObjectValue(result)).toBe(ErrorType.NA); + + array1 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [null], + ]), + rowCount: 1, + columnCount: 1, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + array2 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [null], + ]), + rowCount: 1, + columnCount: 1, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + result = testFunction.calculate(array1, array2, tails, type); + expect(getObjectValue(result)).toBe(ErrorType.VALUE); + + array1 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [null, true, false, 'test'], + ]), + rowCount: 1, + columnCount: 4, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + array2 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [0.2, 0.3, 0.1, 0.4], + ]), + rowCount: 1, + columnCount: 4, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + result = testFunction.calculate(array1, array2, tails, type); + expect(getObjectValue(result)).toBe(ErrorType.DIV_BY_ZERO); + + array1 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [ErrorType.NAME, 1, 2, 3], + ]), + rowCount: 1, + columnCount: 4, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + result = testFunction.calculate(array1, array2, tails, type); + expect(getObjectValue(result)).toBe(ErrorType.NAME); + + const array3 = ErrorValueObject.create(ErrorType.NAME); + const array4 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [0.2, 0.3, 0.1, 0.4], + ]), + rowCount: 1, + columnCount: 4, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const result2 = testFunction.calculate(array3, array4, tails, type); + expect(getObjectValue(result2)).toBe(ErrorType.NAME); + + const array5 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [0, 1, 2, 3], + ]), + rowCount: 1, + columnCount: 4, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const array6 = ErrorValueObject.create(ErrorType.NAME); + const result3 = testFunction.calculate(array5, array6, tails, type); + expect(getObjectValue(result3)).toBe(ErrorType.NAME); + }); + + it('Tails value test', () => { + const array1 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [3, 4, 5, 8, 9, 1, 2, 4, 5], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const array2 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [6, 19, 3, 2, 14, 4, 5, 17, 1], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const tails = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [-1, 0, 1, 2, 3, true, false, null, 'test', ErrorType.NAME], + ]), + rowCount: 1, + columnCount: 10, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const type = NumberValueObject.create(1); + const result = testFunction.calculate(array1, array2, tails, type); + expect(getObjectValue(result)).toStrictEqual([ + [ErrorType.NUM, ErrorType.NUM, 0.09800789246264952, 0.19601578492529903, ErrorType.NUM, 0.09800789246264952, ErrorType.NUM, ErrorType.NUM, ErrorType.VALUE, ErrorType.NAME], + ]); + }); + + it('Type Value is normal', () => { + const array1 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [3, 4, 5, 8, 9, 1, 2, 4, 5], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const array2 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [6, 19, 3, 2, 14, 4, 5, 17, 1], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const tails = NumberValueObject.create(2); + const type = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [-1, 0, 1, 2, 3, true, false, null, 'test', ErrorType.NAME], + ]), + rowCount: 1, + columnCount: 10, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const result = testFunction.calculate(array1, array2, tails, type); + expect(getObjectValue(result)).toStrictEqual([ + [ErrorType.NUM, ErrorType.NUM, 0.19601578492529903, 0.1919958867535514, 0.20229392337016794, 0.19601578492529903, ErrorType.NUM, ErrorType.NUM, ErrorType.VALUE, ErrorType.NAME], + ]); + }); + }); +}); diff --git a/packages/engine-formula/src/functions/statistical/t-test/index.ts b/packages/engine-formula/src/functions/statistical/t-test/index.ts new file mode 100644 index 000000000000..fc3ad78e1768 --- /dev/null +++ b/packages/engine-formula/src/functions/statistical/t-test/index.ts @@ -0,0 +1,344 @@ +/** + * 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 { getTwoArrayNumberValues, studentTCDF } from '../../../basics/statistical'; +import { expandArrayValueObject } from '../../../engine/utils/array-object'; +import { checkVariantsErrorIsStringToNumber } from '../../../engine/utils/check-variant-error'; +import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object'; +import { NumberValueObject } from '../../../engine/value-object/primitive-object'; +import { BaseFunction } from '../../base-function'; +import type { ArrayValueObject } from '../../../engine/value-object/array-value-object'; + +export class TTest extends BaseFunction { + override minParams = 4; + + override maxParams = 4; + + override calculate(array1: BaseValueObject, array2: BaseValueObject, tails: BaseValueObject, type: BaseValueObject): BaseValueObject { + const { isError, errorObject, array1Values, array2Values } = this._handleArray1AndArray2(array1, array2); + + const maxRowLength = Math.max( + tails.isArray() ? (tails as ArrayValueObject).getRowCount() : 1, + type.isArray() ? (type as ArrayValueObject).getRowCount() : 1 + ); + + const maxColumnLength = Math.max( + tails.isArray() ? (tails as ArrayValueObject).getColumnCount() : 1, + type.isArray() ? (type as ArrayValueObject).getColumnCount() : 1 + ); + + const tailsArray = expandArrayValueObject(maxRowLength, maxColumnLength, tails, ErrorValueObject.create(ErrorType.NA)); + const typeArray = expandArrayValueObject(maxRowLength, maxColumnLength, type, ErrorValueObject.create(ErrorType.NA)); + + const resultArray = tailsArray.mapValue((tailsObject, rowIndex, columnIndex) => { + const typeObject = typeArray.get(rowIndex, columnIndex) as BaseValueObject; + + if (array1.isError()) { + return array1; + } + + if (array2.isError()) { + return array2; + } + + if (tailsObject.isError()) { + return tailsObject; + } + + if (typeObject.isError()) { + return typeObject; + } + + if (isError) { + return errorObject as ErrorValueObject; + } + + return this._handleSignleObject(array1Values as number[], array2Values as number[], tailsObject, typeObject); + }); + + if (maxRowLength === 1 && maxColumnLength === 1) { + return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject; + } + + return resultArray; + } + + private _handleSignleObject( + array1Values: number[], + array2Values: number[], + tails: BaseValueObject, + type: BaseValueObject + ): BaseValueObject { + const { isError, errorObject, variants } = checkVariantsErrorIsStringToNumber(tails, type); + + if (isError) { + return errorObject as ErrorValueObject; + } + + const [tailsObject, typeObject] = variants as BaseValueObject[]; + + const tailsValue = Math.floor(+tailsObject.getValue()); + const typeValue = Math.floor(+typeObject.getValue()); + + const { isError: _isError, errorObject: _errorObject, x, degFreedom } = this._getTDistParamByArrayValues(array1Values, array2Values, typeValue); + + if (_isError) { + return _errorObject as ErrorValueObject; + } + + if (![1, 2].includes(tailsValue) || ![1, 2, 3].includes(typeValue)) { + return ErrorValueObject.create(ErrorType.NUM); + } + + let result = 1 - studentTCDF(x, degFreedom); + + if (tailsValue === 2) { + result *= 2; + } + + if (Number.isNaN(result) || !Number.isFinite(result)) { + return ErrorValueObject.create(ErrorType.NUM); + } + + return NumberValueObject.create(result); + } + + // eslint-disable-next-line + private _handleArray1AndArray2(array1: BaseValueObject, array2: BaseValueObject) { + const array1RowCount = array1.isArray() ? (array1 as ArrayValueObject).getRowCount() : 1; + const array1ColumnCount = array1.isArray() ? (array1 as ArrayValueObject).getColumnCount() : 1; + + const array2RowCount = array2.isArray() ? (array2 as ArrayValueObject).getRowCount() : 1; + const array2ColumnCount = array2.isArray() ? (array2 as ArrayValueObject).getColumnCount() : 1; + + let _array1 = array1; + + if (array1.isArray() && array1RowCount === 1 && array1ColumnCount === 1) { + _array1 = (array1 as ArrayValueObject).get(0, 0) as BaseValueObject; + } + + if (_array1.isError()) { + return { + isError: true, + errorObject: _array1 as ErrorValueObject, + array1Values: [], + array2Values: [], + }; + } + + let _array2 = array2; + + if (array2.isArray() && array2RowCount === 1 && array2ColumnCount === 1) { + _array2 = (array2 as ArrayValueObject).get(0, 0) as BaseValueObject; + } + + if (_array2.isError()) { + return { + isError: true, + errorObject: _array2 as ErrorValueObject, + array1Values: [], + array2Values: [], + }; + } + + if (array1RowCount * array1ColumnCount === 1 || array2RowCount * array2ColumnCount === 1) { + if (_array1.isNull() || _array2.isNull()) { + return { + isError: true, + errorObject: ErrorValueObject.create(ErrorType.VALUE), + array1Values: [], + array2Values: [], + }; + } + } + + if (array1RowCount * array1ColumnCount !== array2RowCount * array2ColumnCount) { + return { + isError: true, + errorObject: ErrorValueObject.create(ErrorType.NA), + array1Values: [], + array2Values: [], + }; + } + + const { + isError, + errorObject, + array1Values, + array2Values, + noCalculate, + } = getTwoArrayNumberValues( + array1, + array2, + array1RowCount * array1ColumnCount, + array1ColumnCount, + array2ColumnCount + ); + + if (isError) { + return { + isError: true, + errorObject, + array1Values: [], + array2Values: [], + }; + } + + if (noCalculate || array1Values.length < 2) { + return { + isError: true, + errorObject: ErrorValueObject.create(ErrorType.DIV_BY_ZERO), + array1Values: [], + array2Values: [], + }; + } + + return { + isError: false, + errorObject: null, + array1Values, + array2Values, + }; + } + + private _getTDistParamByArrayValues(array1Values: number[], array2Values: number[], type: number) { + if (type === 1) { + return this._getTDistParamByType1(array1Values, array2Values); + } else if (type === 2) { + return this._getTDistParamByType2(array1Values, array2Values); + } else { + return this._getTDistParamByType3(array1Values, array2Values); + } + }; + + private _getTDistParamByType1(array1Values: number[], array2Values: number[]) { + const n = array1Values.length; + + let sum1 = 0; + let sum2 = 0; + let sumSquareDiff = 0; + + for (let i = 0; i < n; i++) { + sum1 += array1Values[i]; + sum2 += array2Values[i]; + sumSquareDiff += (array1Values[i] - array2Values[i]) ** 2; + } + + const sumDiff = sum1 - sum2; + const den = n * sumSquareDiff - sumDiff ** 2; + const degFreedom = n - 1; + + if (den === 0) { + return { + isError: true, + errorObject: ErrorValueObject.create(ErrorType.DIV_BY_ZERO), + x: 0, + degFreedom, + }; + } + + const x = Math.abs(sumDiff) * Math.sqrt(degFreedom / den); + + return { + isError: false, + errorObject: null, + x, + degFreedom, + }; + } + + private _getTDistParamByType2(array1Values: number[], array2Values: number[]) { + const n = array1Values.length; + + let sum1 = 0; + let sum2 = 0; + let sumSquare1 = 0; + let sumSquare2 = 0; + + for (let i = 0; i < n; i++) { + sum1 += array1Values[i]; + sum2 += array2Values[i]; + sumSquare1 += array1Values[i] ** 2; + sumSquare2 += array2Values[i] ** 2; + } + + const degFreedom = n - 1; + + const temp1 = (sumSquare1 - sum1 ** 2 / n) / degFreedom; + const temp2 = (sumSquare2 - sum2 ** 2 / n) / degFreedom; + + const den = Math.sqrt((temp1 + temp2) * degFreedom); + + if (den === 0) { + return { + isError: true, + errorObject: ErrorValueObject.create(ErrorType.DIV_BY_ZERO), + x: 0, + degFreedom, + }; + } + + const x = Math.abs((sum1 - sum2) / n) / den * Math.sqrt(n * degFreedom); + + return { + isError: false, + errorObject: null, + x, + degFreedom: degFreedom * 2, + }; + } + + private _getTDistParamByType3(array1Values: number[], array2Values: number[]) { + const n = array1Values.length; + + let sum1 = 0; + let sum2 = 0; + let sumSquare1 = 0; + let sumSquare2 = 0; + + for (let i = 0; i < n; i++) { + sum1 += array1Values[i]; + sum2 += array2Values[i]; + sumSquare1 += array1Values[i] ** 2; + sumSquare2 += array2Values[i] ** 2; + } + + const temp1 = (sumSquare1 - sum1 ** 2 / n) / ((n - 1) * n); + const temp2 = (sumSquare2 - sum2 ** 2 / n) / ((n - 1) * n); + + if (temp1 + temp2 === 0) { + return { + isError: true, + errorObject: ErrorValueObject.create(ErrorType.DIV_BY_ZERO), + x: 0, + degFreedom: 0, + }; + } + + const temp3 = temp1 / (temp1 + temp2); + + const x = Math.abs((sum1 - sum2) / n) / Math.sqrt(temp1 + temp2); + const degFreedom = 1 / ((temp3 ** 2 + (1 - temp3) ** 2) / (n - 1)); + + return { + isError: false, + errorObject: null, + x, + degFreedom, + }; + } +} diff --git a/packages/engine-formula/src/functions/statistical/trimmean/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/trimmean/__tests__/index.spec.ts new file mode 100644 index 000000000000..1675d2b58fa4 --- /dev/null +++ b/packages/engine-formula/src/functions/statistical/trimmean/__tests__/index.spec.ts @@ -0,0 +1,126 @@ +/** + * Copyright 2023-present DreamNum Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { describe, expect, it } from 'vitest'; + +import { ErrorType } from '../../../../basics/error-type'; +import { ArrayValueObject, transformToValueObject } from '../../../../engine/value-object/array-value-object'; +import { ErrorValueObject } from '../../../../engine/value-object/base-value-object'; +import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object'; +import { getObjectValue } from '../../../__tests__/create-function-test-bed'; +import { FUNCTION_NAMES_STATISTICAL } from '../../function-names'; +import { Trimmean } from '../index'; + +describe('Test trimmean function', () => { + const testFunction = new Trimmean(FUNCTION_NAMES_STATISTICAL.TRIMMEAN); + + describe('Trimmean', () => { + it('Value is normal', () => { + const array = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [11, 2, 3, 4, 5, 6, 7, 8, 9], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const percent = NumberValueObject.create(0.3); + const result = testFunction.calculate(array, percent); + expect(getObjectValue(result)).toStrictEqual(6); + }); + + it('Array value test', () => { + const array = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [1, null, true, false, 'test', 6, 7, 8, ErrorType.NAME], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const percent = NumberValueObject.create(0.3); + const result = testFunction.calculate(array, percent); + expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME); + + const array2 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [null, true, false, 'test'], + ]), + rowCount: 1, + columnCount: 4, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const result2 = testFunction.calculate(array2, percent); + expect(getObjectValue(result2)).toStrictEqual(ErrorType.NUM); + }); + + it('Percent value test', () => { + const array = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [11, 2, 3, 4, 5, 6, 7, 8, 9], + ]), + rowCount: 1, + columnCount: 9, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const percent = NumberValueObject.create(0.1); + const result = testFunction.calculate(array, percent); + expect(getObjectValue(result)).toStrictEqual(6.111111111111111); + + const percent2 = NumberValueObject.create(11); + const result2 = testFunction.calculate(array, percent2); + expect(getObjectValue(result2)).toStrictEqual(ErrorType.NUM); + + const percent3 = BooleanValueObject.create(true); + const result3 = testFunction.calculate(array, percent3); + expect(getObjectValue(result3)).toStrictEqual(ErrorType.NUM); + + const percent4 = NullValueObject.create(); + const result4 = testFunction.calculate(array, percent4); + expect(getObjectValue(result4)).toStrictEqual(6.111111111111111); + + const percent5 = StringValueObject.create('test'); + const result5 = testFunction.calculate(array, percent5); + expect(getObjectValue(result5)).toStrictEqual(ErrorType.VALUE); + + const percent6 = ErrorValueObject.create(ErrorType.NAME); + const result6 = testFunction.calculate(array, percent6); + expect(getObjectValue(result6)).toStrictEqual(ErrorType.NAME); + + const percent7 = ArrayValueObject.create('{0.1,0.2,0.3}'); + const result7 = testFunction.calculate(array, percent7); + expect(getObjectValue(result7)).toStrictEqual([ + [6.111111111111111, 6.111111111111111, 6], + ]); + + const percent8 = ArrayValueObject.create('{0.9}'); + const result8 = testFunction.calculate(array, percent8); + expect(getObjectValue(result8)).toStrictEqual(6); + }); + }); +}); diff --git a/packages/engine-formula/src/functions/statistical/trimmean/index.ts b/packages/engine-formula/src/functions/statistical/trimmean/index.ts new file mode 100644 index 000000000000..d1239988b5ca --- /dev/null +++ b/packages/engine-formula/src/functions/statistical/trimmean/index.ts @@ -0,0 +1,110 @@ +/** + * Copyright 2023-present DreamNum Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { isRealNum } from '@univerjs/core'; +import { ErrorType } from '../../../basics/error-type'; +import { checkVariantsErrorIsStringToNumber } from '../../../engine/utils/check-variant-error'; +import { floor } from '../../../engine/utils/math-kit'; +import { ErrorValueObject } from '../../../engine/value-object/base-value-object'; +import { NumberValueObject } from '../../../engine/value-object/primitive-object'; +import { BaseFunction } from '../../base-function'; +import type { ArrayValueObject } from '../../../engine/value-object/array-value-object'; +import type { BaseValueObject } from '../../../engine/value-object/base-value-object'; + +export class Trimmean extends BaseFunction { + override minParams = 2; + + override maxParams = 2; + + override calculate(array: BaseValueObject, percent: BaseValueObject): BaseValueObject { + const arrayValues = this._getValues(array); + + if (percent.isArray()) { + const resultArray = (percent as ArrayValueObject).mapValue((percentObject) => this._handleSingleObject(arrayValues, percentObject)); + + if ((resultArray as ArrayValueObject).getRowCount() === 1 && (resultArray as ArrayValueObject).getColumnCount() === 1) { + return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject; + } + + return resultArray; + } + + return this._handleSingleObject(arrayValues, percent); + } + + private _handleSingleObject(array: number[] | ErrorValueObject, percent: BaseValueObject): BaseValueObject { + if (array instanceof ErrorValueObject) { + return array; + } + + const { isError, errorObject, variants } = checkVariantsErrorIsStringToNumber(percent); + + if (isError) { + return errorObject as ErrorValueObject; + } + + const [percentObject] = variants as BaseValueObject[]; + + const percentValue = +percentObject.getValue(); + + if (percentValue < 0 || percentValue >= 1) { + return ErrorValueObject.create(ErrorType.NUM); + } + + const count = floor(array.length * percentValue / 2, 0) * 2; + + const newArray = array.slice(count / 2, array.length - count / 2); + + const result = newArray.reduce((acc, cur) => acc + cur, 0) / newArray.length; + + return NumberValueObject.create(result); + } + + private _getValues(array: BaseValueObject): number[] | ErrorValueObject { + const rowCount = array.isArray() ? (array as ArrayValueObject).getRowCount() : 1; + const columnCount = array.isArray() ? (array as ArrayValueObject).getColumnCount() : 1; + + const values: number[] = []; + + for (let r = 0; r < rowCount; r++) { + for (let c = 0; c < columnCount; c++) { + const valueObject = array.isArray() ? (array as ArrayValueObject).get(r, c) as BaseValueObject : array; + + if (valueObject.isError()) { + return valueObject as ErrorValueObject; + } + + if (valueObject.isNull() || valueObject.isBoolean()) { + continue; + } + + const value = valueObject.getValue(); + + if (!isRealNum(value)) { + continue; + } + + values.push(+value); + } + } + + if (values.length === 0) { + return ErrorValueObject.create(ErrorType.NUM); + } + + return values.sort((a, b) => a - b); + } +} diff --git a/packages/engine-formula/src/functions/statistical/weibull-dist/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/weibull-dist/__tests__/index.spec.ts new file mode 100644 index 000000000000..b271def51013 --- /dev/null +++ b/packages/engine-formula/src/functions/statistical/weibull-dist/__tests__/index.spec.ts @@ -0,0 +1,168 @@ +/** + * 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 { ErrorType } from '../../../../basics/error-type'; +import { ArrayValueObject, transformToValueObject } from '../../../../engine/value-object/array-value-object'; +import { ErrorValueObject } from '../../../../engine/value-object/base-value-object'; +import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object'; +import { getObjectValue } from '../../../__tests__/create-function-test-bed'; +import { FUNCTION_NAMES_STATISTICAL } from '../../function-names'; +import { WeibullDist } from '../index'; + +describe('Test weibullDist function', () => { + const testFunction = new WeibullDist(FUNCTION_NAMES_STATISTICAL.WEIBULL_DIST); + + describe('WeibullDist', () => { + it('Value is normal', () => { + const x = NumberValueObject.create(10); + const alpha = NumberValueObject.create(8); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(true); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).toBe(1); + }); + + it('Alpha and beta value test', () => { + const x = NumberValueObject.create(10); + const alpha = NumberValueObject.create(0); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(true); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).toBe(ErrorType.NUM); + + const alpha2 = NumberValueObject.create(8); + const beta2 = NumberValueObject.create(0); + const result2 = testFunction.calculate(x, alpha2, beta2, cumulative); + expect(getObjectValue(result2)).toBe(ErrorType.NUM); + + const alpha3 = NumberValueObject.create(1); + const beta3 = NumberValueObject.create(1); + const result3 = testFunction.calculate(x, alpha3, beta3, cumulative); + expect(getObjectValue(result3)).toBe(0.9999546000702375); + + const alpha4 = NumberValueObject.create(5); + const result4 = testFunction.calculate(x, alpha4, beta, cumulative); + expect(getObjectValue(result4)).toBe(1); + }); + + it('X value test', () => { + const x = NumberValueObject.create(0); + const alpha = NumberValueObject.create(8); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(true); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).toBe(0); + + const x2 = NumberValueObject.create(-1); + const result2 = testFunction.calculate(x2, alpha, beta, cumulative); + expect(getObjectValue(result2)).toBe(ErrorType.NUM); + }); + + it('Cumulative value is normal', () => { + const x = NumberValueObject.create(10); + const alpha = NumberValueObject.create(8); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(false); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).toBe(0); + + const alpha2 = NumberValueObject.create(1); + const beta2 = NumberValueObject.create(1); + const result2 = testFunction.calculate(x, alpha2, beta2, cumulative); + expect(getObjectValue(result2)).toBe(0.00004539992976248485); + + const x2 = NumberValueObject.create(3); + const result3 = testFunction.calculate(x2, alpha2, beta2, cumulative); + expect(getObjectValue(result3)).toBe(0.049787068367863944); + + const alpha3 = NumberValueObject.create(520); + const beta3 = NumberValueObject.create(520); + const result4 = testFunction.calculate(x, alpha3, beta3, cumulative); + expect(getObjectValue(result4)).toBe(ErrorType.NUM); + + const alpha4 = NumberValueObject.create(350); + const beta4 = NumberValueObject.create(350); + const result5 = testFunction.calculate(x, alpha4, beta4, cumulative); + expect(getObjectValue(result5)).toBe(ErrorType.NUM); + + const alpha5 = NumberValueObject.create(0.1); + const beta5 = NumberValueObject.create(0.1); + const result6 = testFunction.calculate(x, alpha5, beta5, cumulative); + expect(getObjectValue(result6)).toBe(0.003248550572370161); + }); + + it('Value is normal string', () => { + const x = StringValueObject.create('test'); + const alpha = NumberValueObject.create(8); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(true); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).toBe(ErrorType.VALUE); + }); + + it('Value is boolean', () => { + const x = BooleanValueObject.create(true); + const alpha = NumberValueObject.create(8); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(true); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).toBe(0.0038986305298824853); + }); + + it('Value is null', () => { + const x = NullValueObject.create(); + const alpha = NumberValueObject.create(8); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(true); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).toBe(0); + }); + + it('Value is error', () => { + const x = ErrorValueObject.create(ErrorType.NAME); + const alpha = NumberValueObject.create(8); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(true); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).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 alpha = NumberValueObject.create(8); + const beta = NumberValueObject.create(2); + const cumulative = BooleanValueObject.create(true); + const result = testFunction.calculate(x, alpha, beta, cumulative); + expect(getObjectValue(result)).toStrictEqual([ + [0.0038986305298824853, ErrorType.VALUE, 0.02025651346279278, 0.0038986305298824853, 0, 0], + [0, 1, 0.9701465024693557, ErrorType.VALUE, ErrorType.NUM, ErrorType.NAME], + ]); + }); + }); +}); diff --git a/packages/engine-formula/src/functions/statistical/weibull-dist/index.ts b/packages/engine-formula/src/functions/statistical/weibull-dist/index.ts new file mode 100644 index 000000000000..83e93060d620 --- /dev/null +++ b/packages/engine-formula/src/functions/statistical/weibull-dist/index.ts @@ -0,0 +1,125 @@ +/** + * 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 { expandArrayValueObject } from '../../../engine/utils/array-object'; +import { checkVariantsErrorIsStringToNumber } from '../../../engine/utils/check-variant-error'; +import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object'; +import { NumberValueObject } from '../../../engine/value-object/primitive-object'; +import { BaseFunction } from '../../base-function'; +import type { ArrayValueObject } from '../../../engine/value-object/array-value-object'; + +export class WeibullDist extends BaseFunction { + override minParams = 4; + + override maxParams = 4; + + override calculate( + x: BaseValueObject, + alpha: BaseValueObject, + beta: BaseValueObject, + cumulative: BaseValueObject + ): BaseValueObject { + const maxRowLength = Math.max( + x.isArray() ? (x as ArrayValueObject).getRowCount() : 1, + alpha.isArray() ? (alpha as ArrayValueObject).getRowCount() : 1, + beta.isArray() ? (beta as ArrayValueObject).getRowCount() : 1, + cumulative.isArray() ? (cumulative as ArrayValueObject).getRowCount() : 1 + ); + + const maxColumnLength = Math.max( + x.isArray() ? (x as ArrayValueObject).getColumnCount() : 1, + alpha.isArray() ? (alpha as ArrayValueObject).getColumnCount() : 1, + beta.isArray() ? (beta as ArrayValueObject).getColumnCount() : 1, + cumulative.isArray() ? (cumulative as ArrayValueObject).getColumnCount() : 1 + ); + + const xArray = expandArrayValueObject(maxRowLength, maxColumnLength, x, ErrorValueObject.create(ErrorType.NA)); + const alphaArray = expandArrayValueObject(maxRowLength, maxColumnLength, alpha, ErrorValueObject.create(ErrorType.NA)); + const betaArray = expandArrayValueObject(maxRowLength, maxColumnLength, beta, ErrorValueObject.create(ErrorType.NA)); + const cumulativeArray = expandArrayValueObject(maxRowLength, maxColumnLength, cumulative, ErrorValueObject.create(ErrorType.NA)); + + const resultArray = xArray.mapValue((xObject, rowIndex, columnIndex) => { + const alphaObject = alphaArray.get(rowIndex, columnIndex) as BaseValueObject; + const betaObject = betaArray.get(rowIndex, columnIndex) as BaseValueObject; + const cumulativeObject = cumulativeArray.get(rowIndex, columnIndex) as BaseValueObject; + + if (xObject.isError()) { + return xObject; + } + + if (alphaObject.isError()) { + return alphaObject; + } + + if (betaObject.isError()) { + return betaObject; + } + + if (cumulativeObject.isError()) { + return cumulativeObject; + } + + return this._handleSignleObject(xObject, alphaObject, betaObject, cumulativeObject); + }); + + if (maxRowLength === 1 && maxColumnLength === 1) { + return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject; + } + + return resultArray; + } + + private _handleSignleObject( + xObject: BaseValueObject, + alphaObject: BaseValueObject, + betaObject: BaseValueObject, + cumulativeObject: BaseValueObject + ): BaseValueObject { + const { isError, errorObject, variants } = checkVariantsErrorIsStringToNumber(xObject, alphaObject, betaObject, cumulativeObject); + + if (isError) { + return errorObject as ErrorValueObject; + } + + const [_xObject, _alphaObject, _betaObject, _cumulativeObject] = variants as BaseValueObject[]; + + const xValue = +_xObject.getValue(); + const alphaValue = +_alphaObject.getValue(); + const betaValue = +_betaObject.getValue(); + const cumulativeValue = +_cumulativeObject.getValue(); + + if (xValue < 0 || alphaValue <= 0 || betaValue <= 0) { + return ErrorValueObject.create(ErrorType.NUM); + } + + const exp = Math.exp(-((xValue / betaValue) ** alphaValue)); + + let result; + + if (cumulativeValue) { + result = 1 - exp; + } else { + result = alphaValue / (betaValue ** alphaValue) * (xValue ** (alphaValue - 1)) * exp; + } + + if (Number.isNaN(result) || !Number.isFinite(result)) { + return ErrorValueObject.create(ErrorType.NUM); + } + + return NumberValueObject.create(result); + } +} diff --git a/packages/engine-formula/src/functions/statistical/z-test/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/z-test/__tests__/index.spec.ts new file mode 100644 index 000000000000..4e0f9abdc361 --- /dev/null +++ b/packages/engine-formula/src/functions/statistical/z-test/__tests__/index.spec.ts @@ -0,0 +1,151 @@ +/** + * 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 { ErrorType } from '../../../../basics/error-type'; +import { ArrayValueObject, transformToValueObject } from '../../../../engine/value-object/array-value-object'; +import { NumberValueObject } from '../../../../engine/value-object/primitive-object'; +import { getObjectValue } from '../../../__tests__/create-function-test-bed'; +import { FUNCTION_NAMES_STATISTICAL } from '../../function-names'; +import { ZTest } from '../index'; + +describe('Test zTest function', () => { + const testFunction = new ZTest(FUNCTION_NAMES_STATISTICAL.Z_TEST); + + describe('ZTest', () => { + it('Value is normal', () => { + const array = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [3, 6, 7, 8, 6, 5, 4, 2, 1, 9], + ]), + rowCount: 1, + columnCount: 10, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const x = NumberValueObject.create(4); + const result = testFunction.calculate(array, x); + expect(getObjectValue(result)).toBe(0.09057419685136392); + }); + + it('Array value test', () => { + const array = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [null], + ]), + rowCount: 1, + columnCount: 1, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const x = NumberValueObject.create(4); + const result = testFunction.calculate(array, x); + expect(getObjectValue(result)).toBe(ErrorType.NA); + + const array2 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [3], + ]), + rowCount: 1, + columnCount: 1, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const result2 = testFunction.calculate(array2, x); + expect(getObjectValue(result2)).toBe(ErrorType.DIV_BY_ZERO); + + const array3 = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [3, true, false, null, 'test', 5, 4, 2, 1, ErrorType.NAME], + ]), + rowCount: 1, + columnCount: 10, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const result3 = testFunction.calculate(array3, x); + expect(getObjectValue(result3)).toStrictEqual(ErrorType.NAME); + }); + + it('X value test', () => { + const array = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [3, 6, 7, 8, 6, 5, 4, 2, 1, 9], + ]), + rowCount: 1, + columnCount: 10, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const x = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [-4, 100, 2.34, true, false, null, 'test', ErrorType.NAME], + ]), + rowCount: 1, + columnCount: 8, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const result = testFunction.calculate(array, x); + expect(getObjectValue(result)).toStrictEqual([ + [0, 1, 0.00039650182754802366, 3.1107494757876e-7, 2.8254398820592996e-10, 2.8254398820592996e-10, ErrorType.VALUE, ErrorType.NAME], + ]); + }); + + it('Sigma value test', () => { + const array = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [3, 6, 7, 8, 6, 5, 4, 2, 1, 9], + ]), + rowCount: 1, + columnCount: 10, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const x = NumberValueObject.create(4); + const sigma = ArrayValueObject.create({ + calculateValueList: transformToValueObject([ + [-4, 100, 2.34, true, false, null, 'test', ErrorType.NAME], + ]), + rowCount: 1, + columnCount: 8, + unitId: '', + sheetId: '', + row: 0, + column: 0, + }); + const result = testFunction.calculate(array, x, sigma); + expect(getObjectValue(result)).toStrictEqual([ + [ErrorType.NUM, 0.48612556919551, 0.06856806925633085, 0.00025210911472450803, ErrorType.NUM, ErrorType.NUM, ErrorType.VALUE, ErrorType.NAME], + ]); + }); + }); +}); diff --git a/packages/engine-formula/src/functions/statistical/z-test/index.ts b/packages/engine-formula/src/functions/statistical/z-test/index.ts new file mode 100644 index 000000000000..6cb894534782 --- /dev/null +++ b/packages/engine-formula/src/functions/statistical/z-test/index.ts @@ -0,0 +1,169 @@ +/** + * Copyright 2023-present DreamNum Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { isRealNum } from '@univerjs/core'; +import { ErrorType } from '../../../basics/error-type'; +import { normalCDF } from '../../../basics/statistical'; +import { expandArrayValueObject } from '../../../engine/utils/array-object'; +import { checkVariantsErrorIsStringToNumber } from '../../../engine/utils/check-variant-error'; +import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object'; +import { NumberValueObject } from '../../../engine/value-object/primitive-object'; +import { BaseFunction } from '../../base-function'; +import type { ArrayValueObject } from '../../../engine/value-object/array-value-object'; + +export class ZTest extends BaseFunction { + override minParams = 2; + + override maxParams = 3; + + override calculate(array: BaseValueObject, x: BaseValueObject, sigma?: BaseValueObject): BaseValueObject { + const arrayValues = this._getArrayValues(array); + + const maxRowLength = Math.max( + x.isArray() ? (x as ArrayValueObject).getRowCount() : 1, + sigma?.isArray() ? (sigma as ArrayValueObject).getRowCount() : 1 + ); + + const maxColumnLength = Math.max( + x.isArray() ? (x as ArrayValueObject).getColumnCount() : 1, + sigma?.isArray() ? (sigma as ArrayValueObject).getColumnCount() : 1 + ); + + const xArray = expandArrayValueObject(maxRowLength, maxColumnLength, x, ErrorValueObject.create(ErrorType.NA)); + const sigmaArray = sigma ? expandArrayValueObject(maxRowLength, maxColumnLength, sigma, ErrorValueObject.create(ErrorType.NA)) : undefined; + + const resultArray = xArray.mapValue((xObject, rowIndex, columnIndex) => { + if (arrayValues instanceof ErrorValueObject) { + return arrayValues; + } + + if (xObject.isError()) { + return xObject; + } + + const sigmaObject = sigma ? (sigmaArray as ArrayValueObject).get(rowIndex, columnIndex) as BaseValueObject : undefined; + + if (sigmaObject?.isError()) { + return sigmaObject; + } + + if (arrayValues.length === 0) { + return ErrorValueObject.create(ErrorType.NA); + } + + if (arrayValues.length === 1) { + return ErrorValueObject.create(ErrorType.DIV_BY_ZERO); + } + + return this._handleSignleObject(arrayValues as number[], xObject, sigmaObject); + }); + + if (maxRowLength === 1 && maxColumnLength === 1) { + return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject; + } + + return resultArray; + } + + private _handleSignleObject( + arrayValues: number[], + x: BaseValueObject, + sigma: BaseValueObject | undefined + ): BaseValueObject { + const { isError, errorObject, variants } = checkVariantsErrorIsStringToNumber(x); + + if (isError) { + return errorObject as ErrorValueObject; + } + + const [xObject] = variants as BaseValueObject[]; + + const xValue = +xObject.getValue(); + + const n = arrayValues.length; + + let sum = 0; + let sumSquare = 0; + + for (let i = 0; i < n; i++) { + sum += arrayValues[i]; + sumSquare += arrayValues[i] ** 2; + } + + let sigmaValue = 0; + + if (sigma !== undefined) { + const { isError: _isError, errorObject: _errorObject, variants: _variants } = checkVariantsErrorIsStringToNumber(sigma); + + if (_isError) { + return _errorObject as ErrorValueObject; + } + + const [sigmaObject] = _variants as BaseValueObject[]; + + sigmaValue = +sigmaObject.getValue(); + } else { + const mean = sum / n; + + sigmaValue = Math.sqrt((sumSquare - 2 * mean * sum + n * mean ** 2) / (n - 1)); + } + + if (sigmaValue <= 0) { + return ErrorValueObject.create(ErrorType.NUM); + } + + const z = (sum / n - xValue) / (sigmaValue / Math.sqrt(n)); + + const result = 1 - normalCDF(z, 0, 1); + + if (Number.isNaN(result) || !Number.isFinite(result)) { + return ErrorValueObject.create(ErrorType.NUM); + } + + return NumberValueObject.create(result); + } + + private _getArrayValues(array: BaseValueObject): number[] | ErrorValueObject { + const values: number[] = []; + + const arrayRowCount = array.isArray() ? (array as ArrayValueObject).getRowCount() : 1; + const arrayColumnCount = array.isArray() ? (array as ArrayValueObject).getColumnCount() : 1; + + for (let r = 0; r < arrayRowCount; r++) { + for (let c = 0; c < arrayColumnCount; c++) { + const valueObject = array.isArray() ? (array as ArrayValueObject).get(r, c) as BaseValueObject : array; + + if (valueObject.isError()) { + return valueObject as ErrorValueObject; + } + + if (valueObject.isNull() || valueObject.isBoolean()) { + continue; + } + + const value = valueObject.getValue(); + + if (!isRealNum(value)) { + continue; + } + + values.push(+value); + } + } + + return values; + } +} diff --git a/packages/sheets-formula-ui/src/locale/function-list/compatibility/en-US.ts b/packages/sheets-formula-ui/src/locale/function-list/compatibility/en-US.ts index 88455094b08b..923af1e0be1a 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/compatibility/en-US.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/compatibility/en-US.ts @@ -516,8 +516,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array1: { name: 'array1', detail: 'The first array or range of data.' }, + array2: { name: 'array2', detail: 'The second array or range of data.' }, + tails: { name: 'tails', detail: 'Specifies the number of distribution tails. If tails = 1, TTEST uses the one-tailed distribution. If tails = 2, TTEST uses the two-tailed distribution.' }, + type: { name: 'type', detail: 'The kind of t-Test to perform.' }, }, }, VAR: { @@ -558,8 +560,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + x: { name: 'x', detail: 'The value for which you want the distribution.' }, + alpha: { name: 'alpha', detail: 'A parameter of the distribution.' }, + beta: { name: 'beta', detail: 'A parameter of the distribution.' }, + cumulative: { name: 'cumulative', detail: 'A logical value that determines the form of the function. If cumulative is TRUE, WEIBULL returns the cumulative distribution function; if FALSE, it returns the probability density function.' }, }, }, ZTEST: { @@ -572,8 +576,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: 'array', detail: 'The array or range of data against which to test x.' }, + x: { name: 'x', detail: 'The value to test.' }, + sigma: { name: 'sigma', detail: 'The population (known) standard deviation. If omitted, the sample standard deviation is used.' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/compatibility/ja-JP.ts b/packages/sheets-formula-ui/src/locale/function-list/compatibility/ja-JP.ts index 8df2c20628e0..51cdeefb54d0 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/compatibility/ja-JP.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/compatibility/ja-JP.ts @@ -516,8 +516,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array1: { name: '配列1', detail: '比較対象となる一方のデータを含む配列またはセル範囲を指定します。' }, + array2: { name: '配列2', detail: '比較対象となるもう一方のデータを含む配列またはセル範囲を指定します。' }, + tails: { name: '尾部の特性', detail: '片側分布を計算するか、両側分布を計算するかを、数値で指定します。 尾部に 1 を指定すると片側分布の値が計算されます。 尾部に 2 を指定すると両側分布の値が計算されます。' }, + type: { name: '検定の種類', detail: '実行する t 検定の種類を数値で指定します。' }, }, }, VAR: { @@ -558,8 +560,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + x: { name: 'x', detail: '関数に代入する値を指定します。' }, + alpha: { name: 'alpha', detail: '分布の最初のパラメータ。' }, + beta: { name: 'beta', detail: '分布の 2 番目のパラメーター。' }, + cumulative: { name: '累積', detail: '計算に使用する関数の形式を論理値で指定します。 関数形式に TRUE を指定すると累積分布関数の値が計算され、FALSE を指定すると確率密度関数の値が計算されます。' }, }, }, ZTEST: { @@ -572,8 +576,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '配列', detail: 'x の検定対象となるデータを含む数値配列またはセル範囲を指定します。' }, + x: { name: 'x', detail: '検定する値を指定します。' }, + sigma: { name: '標準偏差', detail: '母集団全体に基づく標準偏差を指定します。 省略すると、標本に基づく標準偏差が使用されます。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/compatibility/vi-VN.ts b/packages/sheets-formula-ui/src/locale/function-list/compatibility/vi-VN.ts index bddb4bba6d42..e495dce1a5e9 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/compatibility/vi-VN.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/compatibility/vi-VN.ts @@ -508,8 +508,8 @@ export default { }, }, TTEST: { - description: 'Trả về xác suất liên quan đến kiểm định t-Student', - abstract: 'Trả về xác suất liên quan đến kiểm định t-Student', + description: 'Trả về xác suất kết hợp với Phép thử t-Student.', + abstract: 'Trả về xác suất kết hợp với Phép thử t-Student.', links: [ { title: 'Hướng dẫn', @@ -517,8 +517,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'tham số thứ nhất' }, - number2: { name: 'number2', detail: 'tham số thứ hai' }, + array1: { name: 'mảng 1', detail: 'Mảng thứ nhất của phạm vi dữ liệu.' }, + array2: { name: 'mảng 2', detail: 'Mảng thứ hai của phạm vi dữ liệu.' }, + tails: { name: 'đặc điểm đuôi', detail: 'Xác định số đuôi của phân phối. Nếu đuôi = 1, TTEST sử dụng phân phối một phía. Nếu đuôi = 2, TTEST sử dụng phân phối hai phía.' }, + type: { name: 'loại Phép thử', detail: 'Loại Phép thử t cần thực hiện.' }, }, }, VAR: { @@ -550,8 +552,8 @@ export default { }, }, WEIBULL: { - description: 'Trả về phân phối Weibull', - abstract: 'Trả về phân phối Weibull', + description: 'Trả về phân bố Weibull.', + abstract: 'Trả về phân bố Weibull.', links: [ { title: 'Hướng dẫn', @@ -559,13 +561,15 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'tham số thứ nhất' }, - number2: { name: 'number2', detail: 'tham số thứ hai' }, + x: { name: 'x', detail: 'Giá trị mà bạn muốn có phân bố của nó.' }, + alpha: { name: 'alpha', detail: 'Tham số đầu tiên của phân phối.' }, + beta: { name: 'beta', detail: 'Tham số thứ hai của phân phối.' }, + cumulative: { name: 'tích lũy', detail: 'Một giá trị lô-gic quyết định dạng thức của hàm. Nếu tích lũy là TRUE, hàm WEIBULL trả về hàm phân bố tích lũy; nếu FALSE, nó trả về hàm mật độ xác suất.' }, }, }, ZTEST: { - description: 'Trả về giá trị xác suất đuôi đơn của kiểm định z', - abstract: 'Trả về giá trị xác suất đuôi đơn của kiểm định z', + description: 'Trả về giá trị xác suất một phía của kiểm tra z.', + abstract: 'Trả về giá trị xác suất một phía của kiểm tra z.', links: [ { title: 'Hướng dẫn', @@ -573,8 +577,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'tham số thứ nhất' }, - number2: { name: 'number2', detail: 'tham số thứ hai' }, + array: { name: 'mảng', detail: 'Mảng hay khoảng dữ liệu để kiểm tra x.' }, + x: { name: 'x', detail: 'Giá trị cần kiểm tra.' }, + sigma: { name: 'Độ lệch chuẩn', detail: 'Độ lệch chuẩn tổng thể (đã biết). Nếu bỏ qua, độ lệch chuẩn mẫu sẽ được dùng.' }, }, }, diff --git a/packages/sheets-formula-ui/src/locale/function-list/compatibility/zh-CN.ts b/packages/sheets-formula-ui/src/locale/function-list/compatibility/zh-CN.ts index 5ce1cea4a6c4..35788c44cb32 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/compatibility/zh-CN.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/compatibility/zh-CN.ts @@ -516,8 +516,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array1: { name: '数组1', detail: '第一个数据数组或数据范围。' }, + array2: { name: '数组2', detail: '第二个数据数组或数据范围。' }, + tails: { name: '尾部特性', detail: '指定分布尾数。 如果 tails = 1，则 TTEST 使用单尾分布。 如果 tails = 2，则 TTEST 使用双尾分布。' }, + type: { name: '检验类型', detail: '要执行的 t 检验的类型。' }, }, }, VAR: { @@ -558,8 +560,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + x: { name: 'x', detail: '需要计算其分布的数值。' }, + alpha: { name: 'alpha', detail: '分布的第一个参数。' }, + beta: { name: 'beta', detail: '分布的第二个参数。' }, + cumulative: { name: '累积', detail: '决定函数形式的逻辑值。如果为TRUE，则 WEIBULL 返回累积分布函数；如果为 FALSE，则返回概率密度函数。' }, }, }, ZTEST: { @@ -572,8 +576,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '数组', detail: '用来检验 x 的数组或数据区域。' }, + x: { name: 'x', detail: '要测试的值。' }, + sigma: { name: '标准偏差', detail: '总体（已知）标准偏差。 如果省略，则使用样本标准偏差。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/compatibility/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/compatibility/zh-TW.ts index a742da3601d6..7e9ed04ace45 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/compatibility/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/compatibility/zh-TW.ts @@ -42,7 +42,7 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是 beta 分佈的相關機率。' }, + probability: { name: '機率', detail: 'beta 分佈的相關機率。' }, alpha: { name: 'alpha', detail: '分佈的第一個參數。' }, beta: { name: 'beta', detail: '分佈的第二個參數。' }, A: { name: '下限', detail: '函數的下限，預設值為 0。' }, @@ -75,8 +75,8 @@ export default { }, ], functionParameter: { - x: { name: '值', detail: '這是用來評估分佈的值。' }, - degFreedom: { name: '自由度', detail: '這是自由度。' }, + x: { name: '值', detail: '用來評估分佈的值。' }, + degFreedom: { name: '自由度', detail: '自由度。' }, }, }, CHIINV: { @@ -89,8 +89,8 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是與 χ2 分佈相關聯的機率。' }, - degFreedom: { name: '自由度', detail: '這是自由度。' }, + probability: { name: '機率', detail: '與 χ2 分佈相關聯的機率。' }, + degFreedom: { name: '自由度', detail: '自由度。' }, }, }, CHITEST: { @@ -103,8 +103,8 @@ export default { }, ], functionParameter: { - actualRange: { name: '觀察範圍', detail: '這是觀察值範圍，用來檢定預期值。' }, - expectedRange: { name: '預期範圍', detail: '這是資料範圍，其內容為各欄總和乘各列總和後的值，再除以全部值總和的比率。' }, + actualRange: { name: '觀察範圍', detail: '觀察值範圍，用來檢定預期值。' }, + expectedRange: { name: '預期範圍', detail: '資料範圍，其內容為各欄總和乘各列總和後的值，再除以全部值總和的比率。' }, }, }, CONFIDENCE: { @@ -119,7 +119,7 @@ export default { functionParameter: { alpha: { name: 'alpha', detail: '用於計算置信水準的顯著水準。置信水準等於 100*(1 - alpha)%，換句話說，alpha 0.05 表示信賴水準為 95%。' }, standardDev: { name: '總體標準差', detail: '假設資料範圍的總體標準差已知。' }, - size: { name: '樣本大小', detail: '這是樣本大小。' }, + size: { name: '樣本大小', detail: '樣本大小。' }, }, }, COVAR: { @@ -148,7 +148,7 @@ export default { functionParameter: { trials: { name: '實驗次數', detail: '伯努利實驗的次數。' }, probabilityS: { name: '成功機率', detail: '每一次實驗的成功機率。' }, - alpha: { name: '目標機率', detail: '這是臨界值。' }, + alpha: { name: '目標機率', detail: '臨界值。' }, }, }, EXPONDIST: { @@ -161,9 +161,9 @@ export default { }, ], functionParameter: { - x: { name: '值', detail: '這是用來評估分佈的值。' }, - lambda: { name: 'lambda', detail: '這是參數值。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，EXPONDIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: '值', detail: '用來評估分佈的值。' }, + lambda: { name: 'lambda', detail: '參數值。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，EXPONDIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, FDIST: { @@ -176,9 +176,9 @@ export default { }, ], functionParameter: { - x: { name: '值', detail: '這是用於評估函數的值。' }, - degFreedom1: { name: '分子自由度', detail: '這是分子的自由度。' }, - degFreedom2: { name: '分母自由度', detail: '這是分母的自由度。' }, + x: { name: '值', detail: '用於評估函數的值。' }, + degFreedom1: { name: '分子自由度', detail: '分子的自由度。' }, + degFreedom2: { name: '分母自由度', detail: '分母的自由度。' }, }, }, FINV: { @@ -192,8 +192,8 @@ export default { ], functionParameter: { probability: { name: '機率', detail: 'F 累積分佈相關的機率' }, - degFreedom1: { name: '分子自由度', detail: '這是分子的自由度。' }, - degFreedom2: { name: '分母自由度', detail: '這是分母的自由度。' }, + degFreedom1: { name: '分子自由度', detail: '分子的自由度。' }, + degFreedom2: { name: '分母自由度', detail: '分母的自由度。' }, }, }, FTEST: { @@ -206,8 +206,8 @@ export default { }, ], functionParameter: { - array1: { name: '陣列1', detail: '這是第一個陣列或資料範圍。' }, - array2: { name: '陣列2', detail: '這是第一個陣列或資料範圍。' }, + array1: { name: '陣列1', detail: '第一個陣列或資料範圍。' }, + array2: { name: '陣列2', detail: '第二個陣列或資料範圍。' }, }, }, GAMMADIST: { @@ -220,7 +220,7 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出分佈的數值。' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, alpha: { name: 'alpha', detail: '分佈的第一個參數。' }, beta: { name: 'beta', detail: '分佈的第二個參數。' }, cumulative: { name: '累積', detail: '決定函數形式的邏輯值。如果為 TRUE，則 GAMMADIST 傳回累積分佈函數；如果為 FALSE，則傳回機率密度函數。' }, @@ -236,7 +236,7 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是與伽瑪分佈的相關機率。' }, + probability: { name: '機率', detail: '與伽瑪分佈的相關機率。' }, alpha: { name: 'alpha', detail: '分佈的第一個參數。' }, beta: { name: 'beta', detail: '分佈的第二個參數。' }, }, @@ -268,9 +268,9 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是對應到對數常態分佈的機率。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, + probability: { name: '機率', detail: '對應到對數常態分佈的機率。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, }, }, LOGNORMDIST: { @@ -283,10 +283,10 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出分佈的數值。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，LOGNORMDIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，LOGNORMDIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, MODE: { @@ -313,10 +313,10 @@ export default { }, ], functionParameter: { - numberF: { name: '失敗次數', detail: '這是失敗的次數。' }, - numberS: { name: '成功次數', detail: '這是成功的閥值數目。' }, - probabilityS: { name: '成功機率', detail: '這是成功的機率。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，NEGBINOMDIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + numberF: { name: '失敗次數', detail: '失敗的次數。' }, + numberS: { name: '成功次數', detail: '成功的閥值數目。' }, + probabilityS: { name: '成功機率', detail: '成功的機率。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，NEGBINOMDIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, NORMDIST: { @@ -329,10 +329,10 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出分佈的數值。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，NORMDIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，NORMDIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, NORMINV: { @@ -344,9 +344,9 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是對應到常態分佈的機率。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, + probability: { name: '機率', detail: '對應到常態分佈的機率。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, }, }, NORMSDIST: { @@ -359,7 +359,7 @@ export default { }, ], functionParameter: { - z: { name: 'z', detail: '這是您要找出分佈的數值。' }, + z: { name: 'z', detail: '要找出分佈的數值。' }, }, }, NORMSINV: { @@ -372,7 +372,7 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是對應到常態分佈的機率。' }, + probability: { name: '機率', detail: '對應到常態分佈的機率。' }, }, }, PERCENTILE: { @@ -414,9 +414,9 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出分佈的數值。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，POISSON 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，POISSON 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, QUARTILE: { @@ -443,9 +443,9 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要找出其排名的數字。' }, + number: { name: '數值', detail: '要找出其排名的數字。' }, ref: { name: '數位清單', detail: '數位清單的參照。會忽略 ref 中的非數值。' }, - order: { name: '排列方式', detail: '這是指定排列數值方式的數字。0 或省略為遞減順序排序，非 0 為遞增順序排序。' }, + order: { name: '排列方式', detail: '指定排列數值方式的數字。0 或省略為遞減順序排序，非 0 為遞增順序排序。' }, }, }, STDEV: { @@ -515,8 +515,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array1: { name: '陣列1', detail: '第一個陣列或資料範圍。' }, + array2: { name: '陣列2', detail: '第二個陣列或資料範圍。' }, + tails: { name: '尾部特性', detail: '指定分佈的尾數。 如果 tails = 1，TTEST 會使用單尾分佈。 如果 tails = 2，TTEST 會使用雙尾分佈。' }, + type: { name: '檢定類型', detail: '要執行的 t 檢定類型。' }, }, }, VAR: { @@ -557,8 +559,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, + alpha: { name: 'alpha', detail: '分佈的第一個參數。' }, + beta: { name: 'beta', detail: '分佈的第二個參數。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。如果為 TRUE，則 WEIBULL 傳回累積分佈函數；如果為 FALSE，則傳回機率密度函數。' }, }, }, ZTEST: { @@ -571,8 +575,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '陣列', detail: '用來檢定 x 的陣列或資料範圍。' }, + x: { name: 'x', detail: '要檢定的值。' }, + sigma: { name: '標準差', detail: '總體（已知）標準差。如果省略，則使用樣本標準差。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/date/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/date/zh-TW.ts index d3f3d322311a..ed209cef3899 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/date/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/date/zh-TW.ts @@ -42,7 +42,7 @@ export default { functionParameter: { startDate: { name: '開始日期', detail: '代表指定期間的第一個或開始日期的日期。' }, endDate: { name: '結束日期', detail: '代表期間最後一個或結束日期的日期。' }, - method: { name: '資訊類型', detail: '您要傳回的資訊類型' }, + method: { name: '資訊類型', detail: '要傳回的資訊類型' }, }, }, DATEVALUE: { @@ -190,9 +190,9 @@ export default { }, ], functionParameter: { - startDate: { name: '開始日期', detail: '這是代表開始日期的日期。' }, - endDate: { name: '結束日期', detail: '這是代表結束日期的日期。' }, - holidays: { name: '假日', detail: '這是要從工作行事曆中排除之一個或多個日期的選擇性範圍。' }, + startDate: { name: '開始日期', detail: '代表開始日期的日期。' }, + endDate: { name: '結束日期', detail: '代表結束日期的日期。' }, + holidays: { name: '假日', detail: '要從工作行事曆中排除之一個或多個日期的選擇性範圍。' }, }, }, NETWORKDAYS_INTL: { @@ -205,10 +205,10 @@ export default { }, ], functionParameter: { - startDate: { name: '開始日期', detail: '這是代表開始日期的日期。' }, - endDate: { name: '結束日期', detail: '這是代表結束日期的日期。' }, + startDate: { name: '開始日期', detail: '代表開始日期的日期。' }, + endDate: { name: '結束日期', detail: '代表結束日期的日期。' }, weekend: { name: '週末', detail: '是指定何時是週末的數字或字串。' }, - holidays: { name: '假日', detail: '這是要從工作行事曆中排除之一個或多個日期的選擇性範圍。' }, + holidays: { name: '假日', detail: '要從工作行事曆中排除之一個或多個日期的選擇性範圍。' }, }, }, NOW: { @@ -261,7 +261,7 @@ export default { }, ], functionParameter: { - timeText: { name: '時間文字', detail: '這是以任何一種時間格式表示的文字字串；例如，"6:45 PM" 和 "18:45"，引號中的文字字串表示時間。' }, + timeText: { name: '時間文字', detail: '以任何一種時間格式表示的文字字串；例如，"6:45 PM" 和 "18:45"，引號中的文字字串表示時間。' }, }, }, TODAY: { @@ -285,8 +285,8 @@ export default { }, ], functionParameter: { - serialNumber: { name: '日期序列值', detail: '這是代表要尋找之該天日期的序列值。' }, - returnType: { name: '傳回值類型', detail: '這是決定傳回值類型的數字。' }, + serialNumber: { name: '日期序列值', detail: '代表要尋找之該天日期的序列值。' }, + returnType: { name: '傳回值類型', detail: '決定傳回值類型的數字。' }, }, }, WEEKNUM: { @@ -299,8 +299,8 @@ export default { }, ], functionParameter: { - serialNumber: { name: '日期序列值', detail: '這是一週中的日期。' }, - returnType: { name: '傳回值類型', detail: '這是決定一週從星期幾開始的數字。 預設值為 1。' }, + serialNumber: { name: '日期序列值', detail: '一週中的日期。' }, + returnType: { name: '傳回值類型', detail: '決定一週從星期幾開始的數字。 預設值為 1。' }, }, }, WORKDAY: { @@ -313,9 +313,9 @@ export default { }, ], functionParameter: { - startDate: { name: '開始日期', detail: '這是代表開始日期的日期。' }, - days: { name: '天數', detail: '這是開始日期之前或之後的非週末和非假日的天數。正值代表未來的日期；負值代表過去的日期。' }, - holidays: { name: '假日', detail: '這是要從工作行事曆中排除之一個或多個日期的選擇性範圍。' }, + startDate: { name: '開始日期', detail: '代表開始日期的日期。' }, + days: { name: '天數', detail: '開始日期之前或之後的非週末和非假日的天數。正值代表未來的日期；負值代表過去的日期。' }, + holidays: { name: '假日', detail: '要從工作行事曆中排除之一個或多個日期的選擇性範圍。' }, }, }, WORKDAY_INTL: { @@ -328,10 +328,10 @@ export default { }, ], functionParameter: { - startDate: { name: '開始日期', detail: '這是代表開始日期的日期。' }, - days: { name: '天數', detail: '這是開始日期之前或之後的非週末和非假日的天數。正值代表未來的日期；負值代表過去的日期。' }, + startDate: { name: '開始日期', detail: '代表開始日期的日期。' }, + days: { name: '天數', detail: '開始日期之前或之後的非週末和非假日的天數。正值代表未來的日期；負值代表過去的日期。' }, weekend: { name: '週末', detail: '是指定何時是週末的數字或字串。' }, - holidays: { name: '假日', detail: '這是要從工作行事曆中排除之一個或多個日期的選擇性範圍。' }, + holidays: { name: '假日', detail: '要從工作行事曆中排除之一個或多個日期的選擇性範圍。' }, }, }, YEAR: { @@ -357,9 +357,9 @@ export default { }, ], functionParameter: { - startDate: { name: '开始日期', detail: '這是代表開始日期的日期。' }, - endDate: { name: '结束日期', detail: '這是代表結束日期的日期。' }, - basis: { name: '基礎類型', detail: '這是要使用的日計數基礎類型。' }, + startDate: { name: '开始日期', detail: '代表開始日期的日期。' }, + endDate: { name: '结束日期', detail: '代表結束日期的日期。' }, + basis: { name: '基礎類型', detail: '要使用的日計數基礎類型。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/engineering/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/engineering/zh-TW.ts index e3702ef82e4e..a51c965a35c2 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/engineering/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/engineering/zh-TW.ts @@ -25,8 +25,8 @@ export default { }, ], functionParameter: { - x: { name: 'X', detail: '這是用於評估函數的值。' }, - n: { name: 'N', detail: '這是Bessel函數的順序。如果n不是整數，則會取至整數。' }, + x: { name: 'X', detail: '用於評估函數的值。' }, + n: { name: 'N', detail: 'Bessel函數的順序。如果n不是整數，則會取至整數。' }, }, }, BESSELJ: { @@ -39,8 +39,8 @@ export default { }, ], functionParameter: { - x: { name: 'X', detail: '這是用於評估函數的值。' }, - n: { name: 'N', detail: '這是Bessel函數的順序。如果n不是整數，則會取至整數。' }, + x: { name: 'X', detail: '用於評估函數的值。' }, + n: { name: 'N', detail: 'Bessel函數的順序。如果n不是整數，則會取至整數。' }, }, }, BESSELK: { @@ -53,8 +53,8 @@ export default { }, ], functionParameter: { - x: { name: 'X', detail: '這是用於評估函數的值。' }, - n: { name: 'N', detail: '這是Bessel函數的順序。如果n不是整數，則會取至整數。' }, + x: { name: 'X', detail: '用於評估函數的值。' }, + n: { name: 'N', detail: 'Bessel函數的順序。如果n不是整數，則會取至整數。' }, }, }, BESSELY: { @@ -67,8 +67,8 @@ export default { }, ], functionParameter: { - x: { name: 'X', detail: '這是用於評估函數的值。' }, - n: { name: 'N', detail: '這是Bessel函數的順序。如果n不是整數，則會取至整數。' }, + x: { name: 'X', detail: '用於評估函數的值。' }, + n: { name: 'N', detail: 'Bessel函數的順序。如果n不是整數，則會取至整數。' }, }, }, BIN2DEC: { @@ -81,7 +81,7 @@ export default { }, ], functionParameter: { - number: { name: '二進制數', detail: '您要轉換的二進制數。' }, + number: { name: '二進制數', detail: '要轉換的二進制數。' }, }, }, BIN2HEX: { @@ -94,8 +94,8 @@ export default { }, ], functionParameter: { - number: { name: '二進制數', detail: '您要轉換的二進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '二進制數', detail: '要轉換的二進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, BIN2OCT: { @@ -108,8 +108,8 @@ export default { }, ], functionParameter: { - number: { name: '二進制數', detail: '您要轉換的二進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '二進制數', detail: '要轉換的二進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, BITAND: { @@ -192,9 +192,9 @@ export default { }, ], functionParameter: { - realNum: { name: '實係數', detail: '這是複數的實係數。' }, - iNum: { name: '虛係數', detail: '這是複數的虛係數。' }, - suffix: { name: '字尾', detail: '這是複數虛數元件的字尾。如果省略，會將字尾假設為 "i"。' }, + realNum: { name: '實係數', detail: '複數的實係數。' }, + iNum: { name: '虛係數', detail: '複數的虛係數。' }, + suffix: { name: '字尾', detail: '複數虛數元件的字尾。如果省略，會將字尾假設為 "i"。' }, }, }, CONVERT: { @@ -208,8 +208,8 @@ export default { ], functionParameter: { number: { name: '數值', detail: '要轉換的值。' }, - fromUnit: { name: '轉換前單位', detail: '這是數值的單位。' }, - toUnit: { name: '轉換后單位', detail: '這是結果的單位。' }, + fromUnit: { name: '轉換前單位', detail: '數值的單位。' }, + toUnit: { name: '轉換后單位', detail: '結果的單位。' }, }, }, DEC2BIN: { @@ -222,8 +222,8 @@ export default { }, ], functionParameter: { - number: { name: '十進制數', detail: '您要轉換的十進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '十進制數', detail: '要轉換的十進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, DEC2HEX: { @@ -236,8 +236,8 @@ export default { }, ], functionParameter: { - number: { name: '十進制數', detail: '您要轉換的十進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '十進制數', detail: '要轉換的十進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, DEC2OCT: { @@ -250,8 +250,8 @@ export default { }, ], functionParameter: { - number: { name: '十進制數', detail: '您要轉換的十進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '十進制數', detail: '要轉換的十進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, DELTA: { @@ -264,8 +264,8 @@ export default { }, ], functionParameter: { - number1: { name: '數值1', detail: '這是第一個數值。' }, - number2: { name: '數值2', detail: '這是第二個數值。如果省略，會將數值2假設為零。' }, + number1: { name: '數值1', detail: '第一個數值。' }, + number2: { name: '數值2', detail: '第二個數值。如果省略，會將數值2假設為零。' }, }, }, ERF: { @@ -278,8 +278,8 @@ export default { }, ], functionParameter: { - lowerLimit: { name: '下限', detail: '這是整合ERF的下限。' }, - upperLimit: { name: '上限', detail: '這是整合ERF的上限。如果省略，ERF會在零和下限之間整合。' }, + lowerLimit: { name: '下限', detail: '整合ERF的下限。' }, + upperLimit: { name: '上限', detail: '整合ERF的上限。如果省略，ERF會在零和下限之間整合。' }, }, }, ERF_PRECISE: { @@ -292,7 +292,7 @@ export default { }, ], functionParameter: { - x: { name: '下限', detail: '這是整合ERF.PRECISE的下限。' }, + x: { name: '下限', detail: '整合ERF.PRECISE的下限。' }, }, }, ERFC: { @@ -305,7 +305,7 @@ export default { }, ], functionParameter: { - x: { name: '下限', detail: '這是整合ERFC的下限。' }, + x: { name: '下限', detail: '整合ERFC的下限。' }, }, }, ERFC_PRECISE: { @@ -318,7 +318,7 @@ export default { }, ], functionParameter: { - x: { name: '下限', detail: '這是整合ERFC.PRECISE的下限。' }, + x: { name: '下限', detail: '整合ERFC.PRECISE的下限。' }, }, }, GESTEP: { @@ -331,8 +331,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要檢定閾值的值。' }, - step: { name: '閾值', detail: '這是閾值。如果您省略閾值的值，GESTEP 會使用零。' }, + number: { name: '數值', detail: '要檢定閾值的值。' }, + step: { name: '閾值', detail: '閾值。如果省略閾值的值，GESTEP 會使用零。' }, }, }, HEX2BIN: { @@ -345,8 +345,8 @@ export default { }, ], functionParameter: { - number: { name: '十六進制數', detail: '您要轉換的十六進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '十六進制數', detail: '要轉換的十六進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, HEX2DEC: { @@ -359,7 +359,7 @@ export default { }, ], functionParameter: { - number: { name: '十六進制數', detail: '您要轉換的十六進制數。' }, + number: { name: '十六進制數', detail: '要轉換的十六進制數。' }, }, }, HEX2OCT: { @@ -372,8 +372,8 @@ export default { }, ], functionParameter: { - number: { name: '十六進制數', detail: '您要轉換的十六進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '十六進制數', detail: '要轉換的十六進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, IMABS: { @@ -386,7 +386,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得絕對值的複數。' }, + inumber: { name: '複數', detail: '要求得絕對值的複數。' }, }, }, IMAGINARY: { @@ -399,7 +399,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得虛係數的複數。' }, + inumber: { name: '複數', detail: '要求得虛係數的複數。' }, }, }, IMARGUMENT: { @@ -412,7 +412,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求自變數 theta 的複數。' }, + inumber: { name: '複數', detail: '要求自變數 theta 的複數。' }, }, }, IMCONJUGATE: { @@ -425,7 +425,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得共軛的複數。' }, + inumber: { name: '複數', detail: '要求得共軛的複數。' }, }, }, IMCOS: { @@ -438,7 +438,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得餘弦值的複數。' }, + inumber: { name: '複數', detail: '要求得餘弦值的複數。' }, }, }, IMCOSH: { @@ -451,7 +451,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得雙曲餘弦值的複數。' }, + inumber: { name: '複數', detail: '要求得雙曲餘弦值的複數。' }, }, }, IMCOT: { @@ -464,7 +464,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得餘切值的複數。' }, + inumber: { name: '複數', detail: '要求得餘切值的複數。' }, }, }, IMCSC: { @@ -477,7 +477,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得餘割值的複數。' }, + inumber: { name: '複數', detail: '要求得餘割值的複數。' }, }, }, IMCSCH: { @@ -490,7 +490,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得雙曲餘割值的複數。' }, + inumber: { name: '複數', detail: '要求得雙曲餘割值的複數。' }, }, }, IMDIV: { @@ -503,8 +503,8 @@ export default { }, ], functionParameter: { - inumber1: { name: '複數分子', detail: '這是複數分子或被除數。' }, - inumber2: { name: '複數分母', detail: '這是複數分母或除數。' }, + inumber1: { name: '複數分子', detail: '複數分子或被除數。' }, + inumber2: { name: '複數分母', detail: '複數分母或除數。' }, }, }, IMEXP: { @@ -517,7 +517,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得指數的複數。' }, + inumber: { name: '複數', detail: '要求得指數的複數。' }, }, }, IMLN: { @@ -530,7 +530,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得自然對數的複數。' }, + inumber: { name: '複數', detail: '要求得自然對數的複數。' }, }, }, IMLOG10: { @@ -543,7 +543,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得常用對數的複數。' }, + inumber: { name: '複數', detail: '要求得常用對數的複數。' }, }, }, IMLOG2: { @@ -556,7 +556,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得底數為 2 之對數的複數。' }, + inumber: { name: '複數', detail: '要求得底數為 2 之對數的複數。' }, }, }, IMPOWER: { @@ -569,8 +569,8 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要遞增至乘冪的複數。' }, - number: { name: '數值', detail: '這是要遞增至複數的乘冪。' }, + inumber: { name: '複數', detail: '要遞增至乘冪的複數。' }, + number: { name: '數值', detail: '要遞增至複數的乘冪。' }, }, }, IMPRODUCT: { @@ -583,8 +583,8 @@ export default { }, ], functionParameter: { - inumber1: { name: '複數1', detail: '這是 1 到 255 個要乘以的複數。' }, - inumber2: { name: '複數2', detail: '這是 1 到 255 個要乘以的複數。' }, + inumber1: { name: '複數1', detail: '1 到 255 個要乘以的複數。' }, + inumber2: { name: '複數2', detail: '1 到 255 個要乘以的複數。' }, }, }, IMREAL: { @@ -597,7 +597,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得實係數的複數。' }, + inumber: { name: '複數', detail: '要求得實係數的複數。' }, }, }, IMSEC: { @@ -610,7 +610,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得正割值的複數。' }, + inumber: { name: '複數', detail: '要求得正割值的複數。' }, }, }, IMSECH: { @@ -623,7 +623,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得雙曲正割值的複數。' }, + inumber: { name: '複數', detail: '要求得雙曲正割值的複數。' }, }, }, IMSIN: { @@ -636,7 +636,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得正弦值的複數。' }, + inumber: { name: '複數', detail: '要求得正弦值的複數。' }, }, }, IMSINH: { @@ -649,7 +649,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得雙曲正弦值的複數。' }, + inumber: { name: '複數', detail: '要求得雙曲正弦值的複數。' }, }, }, IMSQRT: { @@ -662,7 +662,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得平方根的複數。' }, + inumber: { name: '複數', detail: '要求得平方根的複數。' }, }, }, IMSUB: { @@ -689,8 +689,8 @@ export default { }, ], functionParameter: { - inumber1: { name: '複數1', detail: '這是 1 到 255 個要相加的複數。' }, - inumber2: { name: '複數2', detail: '這是 1 到 255 個要相加的複數。' }, + inumber1: { name: '複數1', detail: '1 到 255 個要相加的複數。' }, + inumber2: { name: '複數2', detail: '1 到 255 個要相加的複數。' }, }, }, IMTAN: { @@ -703,7 +703,7 @@ export default { }, ], functionParameter: { - inumber: { name: '複數', detail: '這是要求得正切值的複數。' }, + inumber: { name: '複數', detail: '要求得正切值的複數。' }, }, }, OCT2BIN: { @@ -716,8 +716,8 @@ export default { }, ], functionParameter: { - number: { name: '八進制數', detail: '您要轉換的八進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '八進制數', detail: '要轉換的八進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, OCT2DEC: { @@ -730,7 +730,7 @@ export default { }, ], functionParameter: { - number: { name: '八進制數', detail: '您要轉換的八進制數。' }, + number: { name: '八進制數', detail: '要轉換的八進制數。' }, }, }, OCT2HEX: { @@ -743,8 +743,8 @@ export default { }, ], functionParameter: { - number: { name: '八進制數', detail: '您要轉換的八進制數。' }, - places: { name: '字元數', detail: '這是要使用的字元數。' }, + number: { name: '八進制數', detail: '要轉換的八進制數。' }, + places: { name: '字元數', detail: '要使用的字元數。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/financial/zh-CN.ts b/packages/sheets-formula-ui/src/locale/function-list/financial/zh-CN.ts index 520d833cb4e1..48ef75352593 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/financial/zh-CN.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/financial/zh-CN.ts @@ -230,7 +230,7 @@ export default { cost: { name: '成本', detail: '资产原值。' }, salvage: { name: '残值', detail: '折旧末尾时的值（有时也称为资产残值）。' }, life: { name: '使用寿命', detail: '资产的折旧期数（有时也称作资产的使用寿命）。' }, - period: { name: '期间', detail: '您要计算折旧的时期。' }, + period: { name: '期间', detail: '要计算折旧的时期。' }, month: { name: '月份', detail: '第一年的月份数。如果省略月份，则假定其值为12。' }, }, }, @@ -247,7 +247,7 @@ export default { cost: { name: '成本', detail: '资产原值。' }, salvage: { name: '残值', detail: '折旧末尾时的值（有时也称为资产残值）。' }, life: { name: '使用寿命', detail: '资产的折旧期数（有时也称作资产的使用寿命）。' }, - period: { name: '期间', detail: '您要计算折旧的时期。' }, + period: { name: '期间', detail: '要计算折旧的时期。' }, factor: { name: '速率', detail: '余额递减速率。如果省略影响因素，则假定为2（双倍余额递减法）。' }, }, }, @@ -404,7 +404,7 @@ export default { }, ], functionParameter: { - values: { name: '现金流', detail: '数组或单元格的引用，这些单元格包含用来计算内部收益率的数字。\n1.Values 必须包含至少一个正值和一个负值，以计算返回的内部收益率。\n2.IRR 使用值的顺序来说明现金流的顺序。 一定要按您需要的顺序输入支出值和收益值。\n3.如果数组或引用包含文本、逻辑值或空白单元格，这些数值将被忽略。' }, + values: { name: '现金流', detail: '数组或单元格的引用，这些单元格包含用来计算内部收益率的数字。\n1.Values 必须包含至少一个正值和一个负值，以计算返回的内部收益率。\n2.IRR 使用值的顺序来说明现金流的顺序。 一定要按需要的顺序输入支出值和收益值。\n3.如果数组或引用包含文本、逻辑值或空白单元格，这些数值将被忽略。' }, guess: { name: '估计值', detail: '对函数 IRR 计算结果的估计值。' }, }, }, @@ -845,8 +845,8 @@ export default { cost: { name: '成本', detail: '资产原值。' }, salvage: { name: '残值', detail: '折旧末尾时的值（有时也称为资产残值）。' }, life: { name: '使用寿命', detail: '资产的折旧期数（有时也称作资产的使用寿命）。' }, - startPeriod: { name: '起始时期', detail: '您要计算折旧的起始时期。' }, - endPeriod: { name: '终止时期', detail: '您要计算折旧的终止时期。' }, + startPeriod: { name: '起始时期', detail: '要计算折旧的起始时期。' }, + endPeriod: { name: '终止时期', detail: '要计算折旧的终止时期。' }, factor: { name: '速率', detail: '余额递减速率。如果省略影响因素，则假定为2（双倍余额递减法）。' }, noSwitch: { name: '不切换', detail: '逻辑值，指定当折旧值大于余额递减计算值时，是否转用直线折旧法。' }, }, diff --git a/packages/sheets-formula-ui/src/locale/function-list/financial/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/financial/zh-TW.ts index d8c74b6873ae..f8922466e65d 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/financial/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/financial/zh-TW.ts @@ -25,13 +25,13 @@ export default { }, ], functionParameter: { - issue: { name: '發行日', detail: '這是證券的發行日期。' }, - firstInterest: { name: '首次計息日', detail: '這是證券的第一個利率日期。' }, - settlement: { name: '到期日', detail: '這是證券的到期日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - par: { name: '面值', detail: '這是證券的票面價值。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + issue: { name: '發行日', detail: '證券的發行日期。' }, + firstInterest: { name: '首次計息日', detail: '證券的第一個利率日期。' }, + settlement: { name: '到期日', detail: '證券的到期日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + par: { name: '面值', detail: '證券的票面價值。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, calcMethod: { name: '計算方法', detail: '是一個邏輯值：從發行日期開始的應計利息 = TRUE 或忽略；從最後票據支付日期開始計算 = FALSE。' }, }, }, @@ -45,11 +45,11 @@ export default { }, ], functionParameter: { - issue: { name: '發行日', detail: '這是證券的發行日期。' }, - settlement: { name: '到期日', detail: '這是證券的到期日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - par: { name: '面值', detail: '這是證券的票面價值。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + issue: { name: '發行日', detail: '證券的發行日期。' }, + settlement: { name: '到期日', detail: '證券的到期日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + par: { name: '面值', detail: '證券的票面價值。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, AMORDEGRC: { @@ -76,13 +76,13 @@ export default { }, ], functionParameter: { - cost: { name: '成本', detail: '這是資產的成本。' }, - datePurchased: { name: '購買日期', detail: '這是資產的購買日期。' }, - firstPeriod: { name: '首個週期', detail: '這是第一個週期結束的日期。' }, + cost: { name: '成本', detail: '資產的成本。' }, + datePurchased: { name: '購買日期', detail: '資產的購買日期。' }, + firstPeriod: { name: '首個週期', detail: '第一個週期結束的日期。' }, salvage: { name: '殘值', detail: '資產耐用年限終了時的殘餘價值。' }, - period: { name: '週期', detail: '這是週期。' }, - rate: { name: '折舊率', detail: '這是折舊率。' }, - basis: { name: '基礎', detail: '這是要使用的年計數基礎。' }, + period: { name: '週期', detail: '週期。' }, + rate: { name: '折舊率', detail: '折舊率。' }, + basis: { name: '基礎', detail: '要使用的年計數基礎。' }, }, }, COUPDAYBS: { @@ -95,10 +95,10 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, COUPDAYS: { @@ -111,10 +111,10 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, COUPDAYSNC: { @@ -127,10 +127,10 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, COUPNCD: { @@ -143,10 +143,10 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, COUPNUM: { @@ -159,10 +159,10 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, COUPPCD: { @@ -175,10 +175,10 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, CUMIPMT: { @@ -191,12 +191,12 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是利率。' }, - nper: { name: '總期數', detail: '這是總付款期數。' }, - pv: { name: '現值', detail: '這是現值。' }, - startPeriod: { name: '首期', detail: '這是計算中的第一個週期。付款週期的編號由1開始。' }, - endPeriod: { name: '末期', detail: '這是計算中的最後一個週期。' }, - type: { name: '類型', detail: '這是付款的時機。' }, + rate: { name: '利率', detail: '利率。' }, + nper: { name: '總期數', detail: '總付款期數。' }, + pv: { name: '現值', detail: '現值。' }, + startPeriod: { name: '首期', detail: '計算中的第一個週期。付款週期的編號由1開始。' }, + endPeriod: { name: '末期', detail: '計算中的最後一個週期。' }, + type: { name: '類型', detail: '付款的時機。' }, }, }, CUMPRINC: { @@ -209,12 +209,12 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是利率。' }, - nper: { name: '總期數', detail: '這是總付款期數。' }, - pv: { name: '現值', detail: '這是現值。' }, - startPeriod: { name: '首期', detail: '這是計算中的第一個週期。付款週期的編號由1開始。' }, - endPeriod: { name: '末期', detail: '這是計算中的最後一個週期。' }, - type: { name: '類型', detail: '這是付款的時機。' }, + rate: { name: '利率', detail: '利率。' }, + nper: { name: '總期數', detail: '總付款期數。' }, + pv: { name: '現值', detail: '現值。' }, + startPeriod: { name: '首期', detail: '計算中的第一個週期。付款週期的編號由1開始。' }, + endPeriod: { name: '末期', detail: '計算中的最後一個週期。' }, + type: { name: '類型', detail: '付款的時機。' }, }, }, DB: { @@ -227,10 +227,10 @@ export default { }, ], functionParameter: { - cost: { name: '成本', detail: '這是資產的原始成本。' }, - salvage: { name: '殘值', detail: '這是折舊最後的值 (有時稱為資產的殘餘價值)。' }, - life: { name: '使用年限', detail: '這是資產折舊的期數 (有時稱為資產的使用年限)。' }, - period: { name: '期間', detail: '這是要計算折舊的期間。' }, + cost: { name: '成本', detail: '資產的原始成本。' }, + salvage: { name: '殘值', detail: '折舊最後的值 (有時稱為資產的殘餘價值)。' }, + life: { name: '使用年限', detail: '資產折舊的期數 (有時稱為資產的使用年限)。' }, + period: { name: '期間', detail: '要計算折舊的期間。' }, month: { name: '月份', detail: '第一年的月份數。如果省略 month，則假設其值為12。' }, }, }, @@ -244,11 +244,11 @@ export default { }, ], functionParameter: { - cost: { name: '成本', detail: '這是資產的原始成本。' }, - salvage: { name: '殘值', detail: '這是折舊最後的值 (有時稱為資產的殘餘價值)。' }, - life: { name: '使用年限', detail: '這是資產折舊的期數 (有時稱為資產的使用年限)。' }, - period: { name: '期間', detail: '這是要計算折舊的期間。' }, - factor: { name: '速率', detail: '這是餘額遞減的速率。如果省略factor，將假設其值為2(倍率遞減法)。' }, + cost: { name: '成本', detail: '資產的原始成本。' }, + salvage: { name: '殘值', detail: '折舊最後的值 (有時稱為資產的殘餘價值)。' }, + life: { name: '使用年限', detail: '資產折舊的期數 (有時稱為資產的使用年限)。' }, + period: { name: '期間', detail: '要計算折舊的期間。' }, + factor: { name: '速率', detail: '餘額遞減的速率。如果省略factor，將假設其值為2(倍率遞減法)。' }, }, }, DISC: { @@ -261,11 +261,11 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - pr: { name: '價格', detail: '這是證券每$100面額的價格。' }, - redemption: { name: '贖回價', detail: '這是證券每$100面額的贖回價值。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + pr: { name: '價格', detail: '證券每$100面額的價格。' }, + redemption: { name: '贖回價', detail: '證券每$100面額的贖回價值。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, DOLLARDE: { @@ -278,8 +278,8 @@ export default { }, ], functionParameter: { - fractionalDollar: { name: '分數', detail: '這是以整數部分和分數部分表示，並以小數點符號分隔的數字。' }, - fraction: { name: '分母', detail: '這是用於分數之分母的整數。' }, + fractionalDollar: { name: '分數', detail: '以整數部分和分數部分表示，並以小數點符號分隔的數字。' }, + fraction: { name: '分母', detail: '用於分數之分母的整數。' }, }, }, DOLLARFR: { @@ -292,8 +292,8 @@ export default { }, ], functionParameter: { - decimalDollar: { name: '小數', detail: '這是小數。' }, - fraction: { name: '分母', detail: '這是用於分數之分母的整數。' }, + decimalDollar: { name: '小數', detail: '小數。' }, + fraction: { name: '分母', detail: '用於分數之分母的整數。' }, }, }, DURATION: { @@ -306,12 +306,12 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - coupon: { name: '年度票息率', detail: '這是證券的年度票息率。' }, - yld: { name: '年收益率', detail: '這是證券的年收益。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + coupon: { name: '年度票息率', detail: '證券的年度票息率。' }, + yld: { name: '年收益率', detail: '證券的年收益。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, EFFECT: { @@ -324,7 +324,7 @@ export default { }, ], functionParameter: { - nominalRate: { name: '名義利率', detail: '這是名義利率。' }, + nominalRate: { name: '名義利率', detail: '名義利率。' }, npery: { name: '期數', detail: '每年以複利計算之期數。' }, }, }, @@ -338,9 +338,9 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是各期的利率。' }, - nper: { name: '總期數', detail: '這是年金的總付款期數。' }, - pmt: { name: '金額', detail: '這是各期給付的金額；不得在年金期限內變更。' }, + rate: { name: '利率', detail: '各期的利率。' }, + nper: { name: '總期數', detail: '年金的總付款期數。' }, + pmt: { name: '金額', detail: '各期給付的金額；不得在年金期限內變更。' }, pv: { name: '現值', detail: '一系列未來付款的現值或目前總額。' }, type: { name: '類型', detail: '數字0或1，指出付款期限。' }, }, @@ -355,8 +355,8 @@ export default { }, ], functionParameter: { - principal: { name: '初始資金', detail: '這是現值。' }, - schedule: { name: '利率陣列', detail: '這是要套用的利率陣列。' }, + principal: { name: '初始資金', detail: '現值。' }, + schedule: { name: '利率陣列', detail: '要套用的利率陣列。' }, }, }, INTRATE: { @@ -369,11 +369,11 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - investment: { name: '投資額', detail: '這是證券的投資額。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + investment: { name: '投資額', detail: '證券的投資額。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, IPMT: { @@ -386,11 +386,11 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是各期的利率。' }, - per: { name: '期數', detail: '這是求算利息的期次，其值必須介於1到nper之間。' }, - nper: { name: '總期數', detail: '這是年金的總付款期數。' }, + rate: { name: '利率', detail: '各期的利率。' }, + per: { name: '期數', detail: '求算利息的期次，其值必須介於1到nper之間。' }, + nper: { name: '總期數', detail: '年金的總付款期數。' }, pv: { name: '現值', detail: '一系列未來付款的現值或目前總額。' }, - fv: { name: '餘額', detail: '這是最後一次付款完成後，所能獲得的未來值或現金餘額。' }, + fv: { name: '餘額', detail: '最後一次付款完成後，所能獲得的未來值或現金餘額。' }, type: { name: '類型', detail: '數字0或1，指出付款期限。' }, }, }, @@ -404,8 +404,8 @@ export default { }, ], functionParameter: { - values: { name: '現金流', detail: '這是陣列或儲存格參照，其中包含要計算內部報酬率的數字。\n1.Values 必須至少包含一個正數和一個負數，以計算內部報酬率。\n2.IRR 使用 values 的順序來表示現金流量的順序。 請務必依所要的順序輸入支出及收入的值。\n3.如果陣列或參照引數中包含文字、邏輯值或空白儲存格，則這些值將會略過。' }, - guess: { name: '猜測值', detail: '這是您猜測接近 IRR 結果的數字。' }, + values: { name: '現金流', detail: '陣列或儲存格參照，其中包含要計算內部報酬率的數字。\n1.Values 必須至少包含一個正數和一個負數，以計算內部報酬率。\n2.IRR 使用 values 的順序來表示現金流量的順序。 請務必依所要的順序輸入支出及收入的值。\n3.如果陣列或參照引數中包含文字、邏輯值或空白儲存格，則這些值將會略過。' }, + guess: { name: '猜測值', detail: '猜測接近 IRR 結果的數字。' }, }, }, ISPMT: { @@ -418,10 +418,10 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是投資的利率。' }, - per: { name: '期數', detail: '這是要尋找利息的期間，其值必須介於1到Nper之間。' }, - nper: { name: '總期數', detail: '這是投資的總付款期數。' }, - pv: { name: '現值', detail: '這是投資的現值。若為貸款，Pv為貸款金額。' }, + rate: { name: '利率', detail: '投資的利率。' }, + per: { name: '期數', detail: '要尋找利息的期間，其值必須介於1到Nper之間。' }, + nper: { name: '總期數', detail: '投資的總付款期數。' }, + pv: { name: '現值', detail: '投資的現值。若為貸款，Pv為貸款金額。' }, }, }, MDURATION: { @@ -434,12 +434,12 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - coupon: { name: '年度票息率', detail: '這是證券的年度票息率。' }, - yld: { name: '年收益率', detail: '這是證券的年收益。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + coupon: { name: '年度票息率', detail: '證券的年度票息率。' }, + yld: { name: '年收益率', detail: '證券的年收益。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, MIRR: { @@ -452,9 +452,9 @@ export default { }, ], functionParameter: { - values: { name: '現金流', detail: '這是陣列或儲存格參照，其中包含數字。 這些數字代表定期發生的一系列支出 (負值) 和收入 (正值)。\n1.Values 必須至少包含一個正值和一個負值，以計算經修改的內部報酬率。 否則，MIRR 會傳回 #DIV/0! 的錯誤值。\n2.如果陣列或參照引數包含文字、邏輯值或空白儲存格，則忽略這些數值；但包含零值儲存格。' }, - financeRate: { name: '融資利率', detail: '這是投入資金的融資利率。' }, - reinvestRate: { name: '轉投資報酬率', detail: '這是各期收入淨額的轉投資報酬率。' }, + values: { name: '現金流', detail: '陣列或儲存格參照，其中包含數字。 這些數字代表定期發生的一系列支出 (負值) 和收入 (正值)。\n1.Values 必須至少包含一個正值和一個負值，以計算經修改的內部報酬率。 否則，MIRR 會傳回 #DIV/0! 的錯誤值。\n2.如果陣列或參照引數包含文字、邏輯值或空白儲存格，則忽略這些數值；但包含零值儲存格。' }, + financeRate: { name: '融資利率', detail: '投入資金的融資利率。' }, + reinvestRate: { name: '轉投資報酬率', detail: '各期收入淨額的轉投資報酬率。' }, }, }, NOMINAL: { @@ -467,7 +467,7 @@ export default { }, ], functionParameter: { - effectRate: { name: '實質利率', detail: '這是實質利率。' }, + effectRate: { name: '實質利率', detail: '實質利率。' }, npery: { name: '期數', detail: '每年以複利計算之期數。' }, }, }, @@ -481,10 +481,10 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是各期的利率。' }, - pmt: { name: '金額', detail: '這是各期給付的金額；不得在年金期限內變更。' }, + rate: { name: '利率', detail: '各期的利率。' }, + pmt: { name: '金額', detail: '各期給付的金額；不得在年金期限內變更。' }, pv: { name: '現值', detail: '一系列未來付款的現值或目前總額。' }, - fv: { name: '餘額', detail: '這是最後一次付款完成後，所能獲得的未來值或現金餘額。' }, + fv: { name: '餘額', detail: '最後一次付款完成後，所能獲得的未來值或現金餘額。' }, type: { name: '類型', detail: '數字0或1，指出付款期限。' }, }, }, @@ -498,9 +498,9 @@ export default { }, ], functionParameter: { - rate: { name: '貼現率', detail: '這是一段期間內的貼現率。' }, - value1: { name: '現金流1', detail: '這是 1 到 254 個代表支出和收入的引數。' }, - value2: { name: '現金流2', detail: '這是 1 到 254 個代表支出和收入的引數。' }, + rate: { name: '貼現率', detail: '一段期間內的貼現率。' }, + value1: { name: '現金流1', detail: '1 到 254 個代表支出和收入的引數。' }, + value2: { name: '現金流2', detail: '1 到 254 個代表支出和收入的引數。' }, }, }, ODDFPRICE: { @@ -513,15 +513,15 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - issue: { name: '發行日期', detail: '這是證券的發行日期。' }, - firstCoupon: { name: '首次付息日期', detail: '這是證券的首次付息日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - yld: { name: '年收益率', detail: '這是證券的年收益。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + issue: { name: '發行日期', detail: '證券的發行日期。' }, + firstCoupon: { name: '首次付息日期', detail: '證券的首次付息日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + yld: { name: '年收益率', detail: '證券的年收益。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, ODDFYIELD: { @@ -534,15 +534,15 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - issue: { name: '發行日期', detail: '這是證券的發行日期。' }, - firstCoupon: { name: '首次付息日期', detail: '這是證券的首次付息日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - pr: { name: '價格', detail: '這是證券的價格。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + issue: { name: '發行日期', detail: '證券的發行日期。' }, + firstCoupon: { name: '首次付息日期', detail: '證券的首次付息日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + pr: { name: '價格', detail: '證券的價格。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, ODDLPRICE: { @@ -555,14 +555,14 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - lastInterest: { name: '最後票息日期', detail: '這是證券的最後票息日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - yld: { name: '年收益率', detail: '這是證券的年收益。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + lastInterest: { name: '最後票息日期', detail: '證券的最後票息日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + yld: { name: '年收益率', detail: '證券的年收益。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, ODDLYIELD: { @@ -575,14 +575,14 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - lastInterest: { name: '最後票息日期', detail: '這是證券的最後票息日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - pr: { name: '價格', detail: '這是證券的價格。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + lastInterest: { name: '最後票息日期', detail: '證券的最後票息日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + pr: { name: '價格', detail: '證券的價格。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, PDURATION: { @@ -610,10 +610,10 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是各期的利率。' }, - nper: { name: '總期數', detail: '這是年金的總付款期數。' }, + rate: { name: '利率', detail: '各期的利率。' }, + nper: { name: '總期數', detail: '年金的總付款期數。' }, pv: { name: '現值', detail: '一系列未來付款的現值或目前總額。' }, - fv: { name: '餘額', detail: '這是最後一次付款完成後，所能獲得的未來值或現金餘額。' }, + fv: { name: '餘額', detail: '最後一次付款完成後，所能獲得的未來值或現金餘額。' }, type: { name: '類型', detail: '數字0或1，指出付款期限。' }, }, }, @@ -627,11 +627,11 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是各期的利率。' }, - per: { name: '期數', detail: '這是求算利息的期次，其值必須介於1到nper之間。' }, - nper: { name: '總期數', detail: '這是年金的總付款期數。' }, + rate: { name: '利率', detail: '各期的利率。' }, + per: { name: '期數', detail: '求算利息的期次，其值必須介於1到nper之間。' }, + nper: { name: '總期數', detail: '年金的總付款期數。' }, pv: { name: '現值', detail: '一系列未來付款的現值或目前總額。' }, - fv: { name: '餘額', detail: '這是最後一次付款完成後，所能獲得的未來值或現金餘額。' }, + fv: { name: '餘額', detail: '最後一次付款完成後，所能獲得的未來值或現金餘額。' }, type: { name: '類型', detail: '數字0或1，指出付款期限。' }, }, }, @@ -645,13 +645,13 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - yld: { name: '年收益率', detail: '這是證券的年收益。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + yld: { name: '年收益率', detail: '證券的年收益。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, PRICEDISC: { @@ -664,11 +664,11 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - discount: { name: '貼現率', detail: '這是證券的貼現率。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + discount: { name: '貼現率', detail: '證券的貼現率。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, PRICEMAT: { @@ -681,12 +681,12 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - issue: { name: '發行日期', detail: '這是證券的發行日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - yld: { name: '年收益率', detail: '這是證券的年收益。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + issue: { name: '發行日期', detail: '證券的發行日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + yld: { name: '年收益率', detail: '證券的年收益。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, PV: { @@ -699,10 +699,10 @@ export default { }, ], functionParameter: { - rate: { name: '利率', detail: '這是各期的利率。' }, - nper: { name: '總期數', detail: '這是年金的總付款期數。' }, - pmt: { name: '金額', detail: '這是各期給付的金額；不得在年金期限內變更。' }, - fv: { name: '餘額', detail: '這是最後一次付款完成後，所能獲得的未來值或現金餘額。' }, + rate: { name: '利率', detail: '各期的利率。' }, + nper: { name: '總期數', detail: '年金的總付款期數。' }, + pmt: { name: '金額', detail: '各期給付的金額；不得在年金期限內變更。' }, + fv: { name: '餘額', detail: '最後一次付款完成後，所能獲得的未來值或現金餘額。' }, type: { name: '類型', detail: '數字0或1，指出付款期限。' }, }, }, @@ -716,12 +716,12 @@ export default { }, ], functionParameter: { - nper: { name: '總期數', detail: '這是年金的總付款期數。' }, - pmt: { name: '金額', detail: '這是各期給付的金額；不得在年金期限內變更。' }, + nper: { name: '總期數', detail: '年金的總付款期數。' }, + pmt: { name: '金額', detail: '各期給付的金額；不得在年金期限內變更。' }, pv: { name: '現值', detail: '一系列未來付款的現值或目前總額。' }, - fv: { name: '餘額', detail: '這是最後一次付款完成後，所能獲得的未來值或現金餘額。' }, + fv: { name: '餘額', detail: '最後一次付款完成後，所能獲得的未來值或現金餘額。' }, type: { name: '類型', detail: '數字0或1，指出付款期限。' }, - guess: { name: '猜測值', detail: '這是對利率的猜測值。' }, + guess: { name: '猜測值', detail: '對利率的猜測值。' }, }, }, RECEIVED: { @@ -734,11 +734,11 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - investment: { name: '投資額', detail: '這是證券的投資額。' }, - discount: { name: '貼現率', detail: '這是證券的貼現率。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + investment: { name: '投資額', detail: '證券的投資額。' }, + discount: { name: '貼現率', detail: '證券的貼現率。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, RRI: { @@ -766,9 +766,9 @@ export default { }, ], functionParameter: { - cost: { name: '資產原始成本', detail: '這是資產的原始成本。' }, - salvage: { name: '資產殘餘價值', detail: '這是折舊最後的值 (有時稱為資產的殘餘價值)。' }, - life: { name: '資產使用年限', detail: '這是固定資產折舊的期數 (有時稱為固定資產的使用年限)。' }, + cost: { name: '資產原始成本', detail: '資產的原始成本。' }, + salvage: { name: '資產殘餘價值', detail: '折舊最後的值 (有時稱為資產的殘餘價值)。' }, + life: { name: '資產使用年限', detail: '固定資產折舊的期數 (有時稱為固定資產的使用年限)。' }, }, }, SYD: { @@ -781,10 +781,10 @@ export default { }, ], functionParameter: { - cost: { name: '資產原始成本', detail: '這是資產的原始成本。' }, - salvage: { name: '資產殘餘價值', detail: '這是折舊最後的值 (有時稱為資產的殘餘價值)。' }, - life: { name: '資產使用年限', detail: '這是固定資產折舊的期數 (有時稱為固定資產的使用年限)。' }, - per: { name: '週期', detail: '這是週期。' }, + cost: { name: '資產原始成本', detail: '資產的原始成本。' }, + salvage: { name: '資產殘餘價值', detail: '折舊最後的值 (有時稱為資產的殘餘價值)。' }, + life: { name: '資產使用年限', detail: '固定資產折舊的期數 (有時稱為固定資產的使用年限)。' }, + per: { name: '週期', detail: '週期。' }, }, }, TBILLEQ: { @@ -797,9 +797,9 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是國庫券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是國庫券的到期日期。' }, - discount: { name: '貼現率', detail: '這是國庫券的貼現率。' }, + settlement: { name: '結算日期', detail: '國庫券的結算日期。' }, + maturity: { name: '到期日期', detail: '國庫券的到期日期。' }, + discount: { name: '貼現率', detail: '國庫券的貼現率。' }, }, }, TBILLPRICE: { @@ -812,9 +812,9 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是國庫券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是國庫券的到期日期。' }, - discount: { name: '貼現率', detail: '這是國庫券的貼現率。' }, + settlement: { name: '結算日期', detail: '國庫券的結算日期。' }, + maturity: { name: '到期日期', detail: '國庫券的到期日期。' }, + discount: { name: '貼現率', detail: '國庫券的貼現率。' }, }, }, TBILLYIELD: { @@ -827,9 +827,9 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是國庫券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是國庫券的到期日期。' }, - pr: { name: '價格', detail: '這是國庫債券每 $100 美元面額的價格。' }, + settlement: { name: '結算日期', detail: '國庫券的結算日期。' }, + maturity: { name: '到期日期', detail: '國庫券的到期日期。' }, + pr: { name: '價格', detail: '國庫債券每 $100 美元面額的價格。' }, }, }, VDB: { @@ -842,13 +842,13 @@ export default { }, ], functionParameter: { - cost: { name: '成本', detail: '這是資產的原始成本。' }, - salvage: { name: '殘值', detail: '這是折舊最後的值 (有時稱為資產的殘餘價值)。' }, - life: { name: '使用年限', detail: '這是資產折舊的期數 (有時稱為資產的使用年限)。' }, - startPeriod: { name: '開始期間', detail: '這是要計算折舊的開始期間。' }, - endPeriod: { name: '結束期間', detail: '這是要計算折舊的結束期間。' }, - factor: { name: '速率', detail: '這是餘額遞減的速率。如果省略factor，將假設其值為2(倍率遞減法)。' }, - noSwitch: { name: '不切換', detail: '這是用於指定當折舊大於遞減餘額計算時，是否切換到直線折舊法的邏輯值。' }, + cost: { name: '成本', detail: '資產的原始成本。' }, + salvage: { name: '殘值', detail: '折舊最後的值 (有時稱為資產的殘餘價值)。' }, + life: { name: '使用年限', detail: '資產折舊的期數 (有時稱為資產的使用年限)。' }, + startPeriod: { name: '開始期間', detail: '要計算折舊的開始期間。' }, + endPeriod: { name: '結束期間', detail: '要計算折舊的結束期間。' }, + factor: { name: '速率', detail: '餘額遞減的速率。如果省略factor，將假設其值為2(倍率遞減法)。' }, + noSwitch: { name: '不切換', detail: '用於指定當折舊大於遞減餘額計算時，是否切換到直線折舊法的邏輯值。' }, }, }, XIRR: { @@ -861,9 +861,9 @@ export default { }, ], functionParameter: { - values: { name: '現金流', detail: '這是一系列與 dates 的付款日期對應的現金流。第一次付款是選擇性的，而且與投資開始時的成本和付款對應。如果第一個值是成本或付款，則它必須是負值。而之後的付款都會以一年 365 天為基礎來折算。序列值必須至少包括一個正值和一個負值。' }, - dates: { name: '日期表', detail: '這是一系列與現金流對應的付款日期。日期可能會以任何順序發生。' }, - guess: { name: '猜測值', detail: '這是您所猜測接近 XIRR 結果的數字。' }, + values: { name: '現金流', detail: '一系列與 dates 的付款日期對應的現金流。第一次付款是選擇性的，而且與投資開始時的成本和付款對應。如果第一個值是成本或付款，則它必須是負值。而之後的付款都會以一年 365 天為基礎來折算。序列值必須至少包括一個正值和一個負值。' }, + dates: { name: '日期表', detail: '一系列與現金流對應的付款日期。日期可能會以任何順序發生。' }, + guess: { name: '猜測值', detail: '所猜測接近 XIRR 結果的數字。' }, }, }, XNPV: { @@ -876,9 +876,9 @@ export default { }, ], functionParameter: { - rate: { name: '貼現率', detail: '這是要套用到現金流的貼現率。' }, - values: { name: '現金流', detail: '這是一系列與 dates 的付款日期對應的現金流。第一次付款是選擇性的，而且與投資開始時的成本和付款對應。如果第一個值是成本或付款，則它必須是負值。而之後的付款都會以一年 365 天為基礎來折算。序列值必須至少包括一個正值和一個負值。' }, - dates: { name: '日期表', detail: '這是一系列與現金流對應的付款日期。日期可能會以任何順序發生。' }, + rate: { name: '貼現率', detail: '要套用到現金流的貼現率。' }, + values: { name: '現金流', detail: '一系列與 dates 的付款日期對應的現金流。第一次付款是選擇性的，而且與投資開始時的成本和付款對應。如果第一個值是成本或付款，則它必須是負值。而之後的付款都會以一年 365 天為基礎來折算。序列值必須至少包括一個正值和一個負值。' }, + dates: { name: '日期表', detail: '一系列與現金流對應的付款日期。日期可能會以任何順序發生。' }, }, }, YIELD: { @@ -890,13 +890,13 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - pr: { name: '價格', detail: '這是證券每 $100 面額的價格。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - frequency: { name: '頻次', detail: '這是每年票息付款的次數。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + pr: { name: '價格', detail: '證券每 $100 面額的價格。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + frequency: { name: '頻次', detail: '每年票息付款的次數。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, YIELDDISC: { @@ -909,11 +909,11 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - pr: { name: '價格', detail: '這是證券每 $100 面額的價格。' }, - redemption: { name: '贖回價', detail: '這是證券到期時的贖回價值。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + pr: { name: '價格', detail: '證券每 $100 面額的價格。' }, + redemption: { name: '贖回價', detail: '證券到期時的贖回價值。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, YIELDMAT: { @@ -926,12 +926,12 @@ export default { }, ], functionParameter: { - settlement: { name: '結算日期', detail: '這是證券的結算日期。' }, - maturity: { name: '到期日期', detail: '這是證券的到期日期。' }, - issue: { name: '發行日期', detail: '這是證券的發行日期。' }, - rate: { name: '利率', detail: '這是證券的年度票息率。' }, - pr: { name: '價格', detail: '這是證券每 $100 面額的價格。' }, - basis: { name: '基礎', detail: '這是要使用的日計數基礎類型。' }, + settlement: { name: '結算日期', detail: '證券的結算日期。' }, + maturity: { name: '到期日期', detail: '證券的到期日期。' }, + issue: { name: '發行日期', detail: '證券的發行日期。' }, + rate: { name: '利率', detail: '證券的年度票息率。' }, + pr: { name: '價格', detail: '證券每 $100 面額的價格。' }, + basis: { name: '基礎', detail: '要使用的日計數基礎類型。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/information/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/information/zh-TW.ts index 1fa44f4a00c2..471d1eb26afd 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/information/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/information/zh-TW.ts @@ -25,8 +25,8 @@ export default { }, ], functionParameter: { - infoType: { name: '資訊類型', detail: '這是指定所要傳回何種儲存格資訊類型的文字值。' }, - reference: { name: '參考', detail: '這是您要取得其相關資訊的儲存格。' }, + infoType: { name: '資訊類型', detail: '指定所要傳回何種儲存格資訊類型的文字值。' }, + reference: { name: '參考', detail: '要取得其相關資訊的儲存格。' }, }, }, ERROR_TYPE: { @@ -39,7 +39,7 @@ export default { }, ], functionParameter: { - errorVal: { name: '錯誤值', detail: '這是您要尋找之識別數字的錯誤值。' }, + errorVal: { name: '錯誤值', detail: '要尋找之識別數字的錯誤值。' }, }, }, INFO: { @@ -118,7 +118,7 @@ export default { }, ], functionParameter: { - reference: { name: '參照', detail: '是您要測試之儲存格的參照。' }, + reference: { name: '參照', detail: '是要測試之儲存格的參照。' }, }, }, ISLOGICAL: { @@ -235,7 +235,7 @@ export default { }, ], functionParameter: { - value: { name: '值', detail: '這是要轉換的值。' }, + value: { name: '值', detail: '要轉換的值。' }, }, }, NA: { diff --git a/packages/sheets-formula-ui/src/locale/function-list/logical/zh-CN.ts b/packages/sheets-formula-ui/src/locale/function-list/logical/zh-CN.ts index 7ff229a45ad4..b88cfe940287 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/logical/zh-CN.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/logical/zh-CN.ts @@ -79,13 +79,13 @@ export default { ], functionParameter: { logicalTest: { name: '布尔表达式', detail: '要测试的条件。' }, - valueIfTrue: { name: '如果值为 true', detail: 'logical_test 的结果为 TRUE 时，您希望返回的值。' }, - valueIfFalse: { name: '如果值为 false', detail: 'logical_test 的结果为 FALSE 时，您希望返回的值。' }, + valueIfTrue: { name: '如果值为 true', detail: 'logical_test 的结果为 TRUE 时，希望返回的值。' }, + valueIfFalse: { name: '如果值为 false', detail: 'logical_test 的结果为 FALSE 时，希望返回的值。' }, }, }, IFERROR: { - description: '如果公式的计算结果错误，则返回您指定的值；否则返回公式的结果', - abstract: '如果公式的计算结果错误，则返回您指定的值；否则返回公式的结果', + description: '如果公式的计算结果错误，则返回指定的值；否则返回公式的结果', + abstract: '如果公式的计算结果错误，则返回指定的值；否则返回公式的结果', links: [ { title: '教学', @@ -98,8 +98,8 @@ export default { }, }, IFNA: { - description: '如果表达式的结果为 #N/A，则返回您指定的值，否则返回表达式的结果', - abstract: '如果表达式的结果为 #N/A，则返回您指定的值，否则返回表达式的结果', + description: '如果表达式的结果为 #N/A，则返回指定的值，否则返回表达式的结果', + abstract: '如果表达式的结果为 #N/A，则返回指定的值，否则返回表达式的结果', links: [ { title: '教学', @@ -208,7 +208,7 @@ export default { }, ], functionParameter: { - logical: { name: '逻辑表达式', detail: '您要反转逻辑的条件，可评估为 TRUE 或 FALSE。' }, + logical: { name: '逻辑表达式', detail: '要反转逻辑的条件，可评估为 TRUE 或 FALSE。' }, }, }, OR: { diff --git a/packages/sheets-formula-ui/src/locale/function-list/logical/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/logical/zh-TW.ts index f3727ff8d0fb..62a7f5720845 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/logical/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/logical/zh-TW.ts @@ -80,13 +80,13 @@ export default { ], functionParameter: { logicalTest: { name: '布林表達式', detail: '要測試的條件。 ' }, - valueIfTrue: { name: '如果值為 true', detail: 'logical_test 的結果為 TRUE 時，您希望傳回的值。 ' }, - valueIfFalse: { name: '如果值為 false', detail: 'logical_test 的結果為 FALSE 時，您希望傳回的值。 ' }, + valueIfTrue: { name: '如果值為 true', detail: 'logical_test 的結果為 TRUE 時，希望傳回的值。 ' }, + valueIfFalse: { name: '如果值為 false', detail: 'logical_test 的結果為 FALSE 時，希望傳回的值。 ' }, }, }, IFERROR: { - description: '如果公式的計算結果錯誤，則傳回您指定的值；否則傳回公式的結果', - abstract: '如果公式的計算結果錯誤，則傳回您指定的值；否則傳回公式的結果', + description: '如果公式的計算結果錯誤，則傳回指定的值；否則傳回公式的結果', + abstract: '如果公式的計算結果錯誤，則傳回指定的值；否則傳回公式的結果', links: [ { title: '教導', @@ -209,7 +209,7 @@ export default { }, ], functionParameter: { - logical: { name: '邏輯表達式', detail: '您要反轉邏輯的條件，可評估為 TRUE 或 FALSE。' }, + logical: { name: '邏輯表達式', detail: '要反轉邏輯的條件，可評估為 TRUE 或 FALSE。' }, }, }, OR: { diff --git a/packages/sheets-formula-ui/src/locale/function-list/lookup/zh-CN.ts b/packages/sheets-formula-ui/src/locale/function-list/lookup/zh-CN.ts index 74405e16bbf0..5572aa214620 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/lookup/zh-CN.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/lookup/zh-CN.ts @@ -298,7 +298,7 @@ export default { }, }, LOOKUP: { - description: '当您需要查询一行或一列并查找另一行或列中的相同位置的值时使用', + description: '当需要查询一行或一列并查找另一行或列中的相同位置的值时使用', abstract: '在向量或数组中查找值', links: [ { diff --git a/packages/sheets-formula-ui/src/locale/function-list/lookup/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/lookup/zh-TW.ts index 1b4b761a89df..87b84c262f0d 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/lookup/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/lookup/zh-TW.ts @@ -298,7 +298,7 @@ export default { }, }, LOOKUP: { - description: '當您需要查詢一行或一列並查找另一行或列中的相同位置的值時使用', + description: '當需要查詢一行或一列並查找另一行或列中的相同位置的值時使用', abstract: '在向量或陣列中找出值', links: [ { diff --git a/packages/sheets-formula-ui/src/locale/function-list/math/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/math/zh-TW.ts index 9549225aae58..56b0a568eb99 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/math/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/math/zh-TW.ts @@ -120,7 +120,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是欲求角度的正弦值，其值必須介於 -1 到 1。' }, + number: { name: '數值', detail: '欲求角度的正弦值，其值必須介於 -1 到 1。' }, }, }, ASINH: { @@ -133,7 +133,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是任意實數。' }, + number: { name: '數值', detail: '任意實數。' }, }, }, ATAN: { @@ -146,7 +146,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是欲求角度的正切值。' }, + number: { name: '數值', detail: '欲求角度的正切值。' }, }, }, ATAN2: { @@ -159,8 +159,8 @@ export default { }, ], functionParameter: { - xNum: { name: 'x 座標', detail: '這是點的 X 座標。' }, - yNum: { name: 'y 座標', detail: '這是點的 Y 座標。' }, + xNum: { name: 'x 座標', detail: '點的 X 座標。' }, + yNum: { name: 'y 座標', detail: '點的 Y 座標。' }, }, }, ATANH: { @@ -173,7 +173,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是任何介於 1 和 -1 之間的實數。' }, + number: { name: '數值', detail: '任何介於 1 和 -1 之間的實數。' }, }, }, BASE: { @@ -186,8 +186,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要轉換的數位。必須是大於或等於 0 且小於 2^53 的整數。' }, - radix: { name: '基數', detail: '這是要將數字轉換為底數的基數。必須是大於或等於 2 且小於或等於 36 的整數。' }, + number: { name: '數值', detail: '要轉換的數位。必須是大於或等於 0 且小於 2^53 的整數。' }, + radix: { name: '基數', detail: '要將數字轉換為底數的基數。必須是大於或等於 2 且小於或等於 36 的整數。' }, minLength: { name: '最小長度', detail: '傳回之字串的最小長度。必須是大於或等於 0 的整數。' }, }, }, @@ -201,8 +201,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨位的數值。' }, - significance: { name: '倍數', detail: '這是要捨位的倍數。' }, + number: { name: '數值', detail: '要捨位的數值。' }, + significance: { name: '倍數', detail: '要捨位的倍數。' }, }, }, CEILING_MATH: { @@ -215,8 +215,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨位的數值。' }, - significance: { name: '倍數', detail: '這是要捨位的倍數。' }, + number: { name: '數值', detail: '要捨位的數值。' }, + significance: { name: '倍數', detail: '要捨位的倍數。' }, mode: { name: '眾數', detail: '對於負數，請控制數位是否趨於或背離於零。' }, }, }, @@ -230,8 +230,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨位的數值。' }, - significance: { name: '倍數', detail: '這是要捨位的倍數。' }, + number: { name: '數值', detail: '要捨位的數值。' }, + significance: { name: '倍數', detail: '要捨位的倍數。' }, }, }, COMBIN: { @@ -244,8 +244,8 @@ export default { }, ], functionParameter: { - number: { name: '總數', detail: '這是項目數。' }, - numberChosen: { name: '樣品數量', detail: '這是每個組合中的項目數。' }, + number: { name: '總數', detail: '項目數。' }, + numberChosen: { name: '樣品數量', detail: '每個組合中的項目數。' }, }, }, COMBINA: { @@ -258,8 +258,8 @@ export default { }, ], functionParameter: { - number: { name: '總數', detail: '這是項目數。' }, - numberChosen: { name: '樣品數量', detail: '這是每個組合中的項目數。' }, + number: { name: '總數', detail: '項目數。' }, + numberChosen: { name: '樣品數量', detail: '每個組合中的項目數。' }, }, }, COS: { @@ -272,7 +272,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: ' 這是欲求算其餘弦值的角度，以弧度表示。' }, + number: { name: '數值', detail: '欲求算其餘弦值的角度，以弧度表示。' }, }, }, COSH: { @@ -285,7 +285,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是欲求得其雙曲線餘弦值的任意實數。' }, + number: { name: '數值', detail: '欲求得其雙曲線餘弦值的任意實數。' }, }, }, COT: { @@ -298,7 +298,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是欲求餘切值的角度，以弧度表示。' }, + number: { name: '數值', detail: '欲求餘切值的角度，以弧度表示。' }, }, }, COTH: { @@ -351,7 +351,7 @@ export default { ], functionParameter: { text: { name: '字串', detail: '字串長度必須小於或等於 255 個字元。' }, - radix: { name: '基數', detail: '這是要將數字轉換為底數的基數。 必須是大於或等於 2 且小於或等於 36 的整數。' }, + radix: { name: '基數', detail: '要將數字轉換為底數的基數。 必須是大於或等於 2 且小於或等於 36 的整數。' }, }, }, DEGREES: { @@ -364,7 +364,7 @@ export default { }, ], functionParameter: { - angle: { name: '角度', detail: '這是要轉換的角度，以弧度表示。' }, + angle: { name: '角度', detail: '要轉換的角度，以弧度表示。' }, }, }, EVEN: { @@ -377,7 +377,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨入的數值。' }, + number: { name: '數值', detail: '要捨入的數值。' }, }, }, EXP: { @@ -390,7 +390,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是套用至基數 e 的指數。' }, + number: { name: '數值', detail: '套用至基數 e 的指數。' }, }, }, FACT: { @@ -403,7 +403,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是您要階乘的非負數數字。 如果數字不是整數，則只會取整數。' }, + number: { name: '數值', detail: '要階乘的非負數數字。 如果數字不是整數，則只會取整數。' }, }, }, FACTDOUBLE: { @@ -416,7 +416,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是您要雙倍階乘的非負數數字。 如果數字不是整數，則只會取整數。' }, + number: { name: '數值', detail: '要雙倍階乘的非負數數字。 如果數字不是整數，則只會取整數。' }, }, }, FLOOR: { @@ -429,8 +429,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨位的數值。' }, - significance: { name: '倍數', detail: '這是要捨位的倍數。' }, + number: { name: '數值', detail: '要捨位的數值。' }, + significance: { name: '倍數', detail: '要捨位的倍數。' }, }, }, FLOOR_MATH: { @@ -443,8 +443,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨位的數值。' }, - significance: { name: '倍數', detail: '這是要捨位的倍數。' }, + number: { name: '數值', detail: '要捨位的數值。' }, + significance: { name: '倍數', detail: '要捨位的倍數。' }, mode: { name: '眾數', detail: '對於負數，請控制數位是否趨於或背離於零。' }, }, }, @@ -458,8 +458,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨位的數值。' }, - significance: { name: '倍數', detail: '這是要捨位的倍數。' }, + number: { name: '數值', detail: '要捨位的數值。' }, + significance: { name: '倍數', detail: '要捨位的倍數。' }, }, }, GCD: { @@ -486,7 +486,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要將數字向下捨去到最接近的整數的實數。' }, + number: { name: '數值', detail: '要將數字向下捨去到最接近的整數的實數。' }, }, }, ISO_CEILING: { @@ -541,7 +541,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要求得自然對數的正實數。' }, + number: { name: '數值', detail: '要求得自然對數的正實數。' }, }, }, LOG: { @@ -554,8 +554,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要求得對數的正實數。' }, - base: { name: '底數', detail: '這是對數的底數。 如果省略 base，則假設其值為 10。' }, + number: { name: '數值', detail: '要求得對數的正實數。' }, + base: { name: '底數', detail: '對數的底數。 如果省略 base，則假設其值為 10。' }, }, }, LOG10: { @@ -568,7 +568,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要求得底數為 10 之對數的正實數。' }, + number: { name: '數值', detail: '要求得底數為 10 之對數的正實數。' }, }, }, MDETERM: { @@ -581,7 +581,7 @@ export default { }, ], functionParameter: { - array: { name: '陣列', detail: '這是具有相同列數與欄數的數值陣列。' }, + array: { name: '陣列', detail: '具有相同列數與欄數的數值陣列。' }, }, }, MINVERSE: { @@ -594,7 +594,7 @@ export default { }, ], functionParameter: { - array: { name: '陣列', detail: '這是具有相同列數與欄數的數值陣列。' }, + array: { name: '陣列', detail: '具有相同列數與欄數的數值陣列。' }, }, }, MMULT: { @@ -607,8 +607,8 @@ export default { }, ], functionParameter: { - array1: { name: '陣列1', detail: '這是您要相乘的陣列。' }, - array2: { name: '陣列2', detail: '這是您要相乘的陣列。' }, + array1: { name: '陣列1', detail: '要相乘的陣列。' }, + array2: { name: '陣列2', detail: '要相乘的陣列。' }, }, }, MOD: { @@ -635,8 +635,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨入的數值。' }, - multiple: { name: '倍數', detail: '這是要捨入數字的倍數。' }, + number: { name: '數值', detail: '要捨入的數值。' }, + multiple: { name: '倍數', detail: '要捨入數字的倍數。' }, }, }, MULTINOMIAL: { @@ -676,7 +676,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要捨入的數值。' }, + number: { name: '數值', detail: '要捨入的數值。' }, }, }, PI: { @@ -729,8 +729,8 @@ export default { }, ], functionParameter: { - numerator: { name: '分子', detail: '這是被除數。' }, - denominator: { name: '分母', detail: '這是除數。' }, + numerator: { name: '分子', detail: '被除數。' }, + denominator: { name: '分母', detail: '除數。' }, }, }, RADIANS: { @@ -742,7 +742,7 @@ export default { }, ], functionParameter: { - angle: { name: '角度', detail: '這是要轉換的角度 (以度數為單位)。' }, + angle: { name: '角度', detail: '要轉換的角度 (以度數為單位)。' }, }, }, RAND: { @@ -812,8 +812,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要四捨五入的數字。' }, - numDigits: { name: '位數', detail: '這是要對數字引數進位的位數。' }, + number: { name: '數值', detail: '要四捨五入的數字。' }, + numDigits: { name: '位數', detail: '要對數字引數進位的位數。' }, }, }, ROUNDDOWN: { @@ -826,8 +826,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要四捨五入的數字。' }, - numDigits: { name: '位數', detail: '這是要對數字引數進位的位數。' }, + number: { name: '數值', detail: '要四捨五入的數字。' }, + numDigits: { name: '位數', detail: '要對數字引數進位的位數。' }, }, }, ROUNDUP: { @@ -840,8 +840,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要四捨五入的數字。' }, - numDigits: { name: '位數', detail: '這是要對數字引數進位的位數。' }, + number: { name: '數值', detail: '要四捨五入的數字。' }, + numDigits: { name: '位數', detail: '要對數字引數進位的位數。' }, }, }, SEC: { @@ -880,10 +880,10 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是冪級數的輸入值。' }, - n: { name: 'n', detail: '這是要增加 x 的初始乘冪。' }, - m: { name: 'm', detail: '這是要將級數中的每一項增加 n 所用的間距。' }, - coefficients: { name: '係數集', detail: '這是一組由 x 的每一個連續乘冪相乘的係數集。' }, + x: { name: 'x', detail: '冪級數的輸入值。' }, + n: { name: 'n', detail: '要增加 x 的初始乘冪。' }, + m: { name: 'm', detail: '要將級數中的每一項增加 n 所用的間距。' }, + coefficients: { name: '係數集', detail: '一組由 x 的每一個連續乘冪相乘的係數集。' }, }, }, SEQUENCE: { @@ -912,7 +912,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是任意實數。' }, + number: { name: '數值', detail: '任意實數。' }, }, }, SIN: { @@ -925,7 +925,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要求出正弦值的角度，以弧度表示。' }, + number: { name: '數值', detail: '要求出正弦值的角度，以弧度表示。' }, }, }, SINH: { @@ -938,7 +938,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是任意實數。' }, + number: { name: '數值', detail: '任意實數。' }, }, }, SQRT: { @@ -951,7 +951,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要求得平方根的數字。' }, + number: { name: '數值', detail: '要求得平方根的數字。' }, }, }, SQRTPI: { @@ -964,7 +964,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要乘以 pi 的數值。' }, + number: { name: '數值', detail: '要乘以 pi 的數值。' }, }, }, SUBTOTAL: { @@ -998,7 +998,7 @@ export default { }, number2: { name: '數值 2', - detail: '這是第二個要相加的數字。 可以按照這種方式指定最多 255 個數字。 ', + detail: '第二個要相加的數字。 可以按照這種方式指定最多 255 個數字。 ', }, }, }, @@ -1053,8 +1053,8 @@ export default { }, ], functionParameter: { - array1: { name: '陣列', detail: '這是您要求元素乘積和的第一個陣列引數。' }, - array2: { name: '陣列', detail: '這是您要求元素乘積和的第 2 個到第 255 個陣列引數。' }, + array1: { name: '陣列', detail: '要求元素乘積和的第一個陣列引數。' }, + array2: { name: '陣列', detail: '要求元素乘積和的第 2 個到第 255 個陣列引數。' }, }, }, SUMSQ: { @@ -1067,8 +1067,8 @@ export default { }, ], functionParameter: { - number1: { name: '數值1', detail: '這是要求出平方總和的第1個數字。您也可以使用單一陣列或陣列參照來取代以逗點分隔的引數。' }, - number2: { name: '數值2', detail: '這是要求出平方總和的第2個數字。可以按照這種方式指定最多 255 個數字。' }, + number1: { name: '數值1', detail: '要求出平方總和的第1個數字。也可以使用單一陣列或陣列參照來取代以逗點分隔的引數。' }, + number2: { name: '數值2', detail: '要求出平方總和的第2個數字。可以按照這種方式指定最多 255 個數字。' }, }, }, SUMX2MY2: { @@ -1081,8 +1081,8 @@ export default { }, ], functionParameter: { - arrayX: { name: '值陣列1', detail: '這是第一個值陣列或範圍。' }, - arrayY: { name: '值陣列2', detail: '這是第二個值陣列或範圍。' }, + arrayX: { name: '值陣列1', detail: '第一個值陣列或範圍。' }, + arrayY: { name: '值陣列2', detail: '第二個值陣列或範圍。' }, }, }, SUMX2PY2: { @@ -1095,8 +1095,8 @@ export default { }, ], functionParameter: { - arrayX: { name: '值陣列1', detail: '這是第一個值陣列或範圍。' }, - arrayY: { name: '值陣列2', detail: '這是第二個值陣列或範圍。' }, + arrayX: { name: '值陣列1', detail: '第一個值陣列或範圍。' }, + arrayY: { name: '值陣列2', detail: '第二個值陣列或範圍。' }, }, }, SUMXMY2: { @@ -1109,8 +1109,8 @@ export default { }, ], functionParameter: { - arrayX: { name: '值陣列1', detail: '這是第一個值陣列或範圍。' }, - arrayY: { name: '值陣列2', detail: '這是第二個值陣列或範圍。' }, + arrayX: { name: '值陣列1', detail: '第一個值陣列或範圍。' }, + arrayY: { name: '值陣列2', detail: '第二個值陣列或範圍。' }, }, }, TAN: { @@ -1123,7 +1123,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要求出正切值的角度，以弧度表示。' }, + number: { name: '數值', detail: '要求出正切值的角度，以弧度表示。' }, }, }, TANH: { @@ -1136,7 +1136,7 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是任意實數。' }, + number: { name: '數值', detail: '任意實數。' }, }, }, TRUNC: { @@ -1149,8 +1149,8 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要取至整數的數字。' }, - numDigits: { name: '位數', detail: '這是指定要捨去之精確位數的數字。其預設值為 0 (零)。' }, + number: { name: '數值', detail: '要取至整數的數字。' }, + numDigits: { name: '位數', detail: '指定要捨去之精確位數的數字。其預設值為 0 (零)。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/statistical/en-US.ts b/packages/sheets-formula-ui/src/locale/function-list/statistical/en-US.ts index abdaf3c8caec..445baeb559cb 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/statistical/en-US.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/statistical/en-US.ts @@ -1541,8 +1541,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array1: { name: 'array1', detail: 'The first array or range of data.' }, + array2: { name: 'array2', detail: 'The second array or range of data.' }, + tails: { name: 'tails', detail: 'Specifies the number of distribution tails. If tails = 1, T.TEST uses the one-tailed distribution. If tails = 2, T.TEST uses the two-tailed distribution.' }, + type: { name: 'type', detail: 'The kind of t-Test to perform.' }, }, }, TREND: { @@ -1569,8 +1571,8 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: 'array', detail: 'The array or range of values to trim and average.' }, + percent: { name: 'percent', detail: 'The fractional number of data points to exclude from the calculation.' }, }, }, VAR_P: { @@ -1639,8 +1641,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + x: { name: 'x', detail: 'The value for which you want the distribution.' }, + alpha: { name: 'alpha', detail: 'A parameter of the distribution.' }, + beta: { name: 'beta', detail: 'A parameter of the distribution.' }, + cumulative: { name: 'cumulative', detail: 'A logical value that determines the form of the function. If cumulative is TRUE, WEIBULL.DIST returns the cumulative distribution function; if FALSE, it returns the probability density function.' }, }, }, Z_TEST: { @@ -1653,8 +1657,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: 'array', detail: 'The array or range of data against which to test x.' }, + x: { name: 'x', detail: 'The value to test.' }, + sigma: { name: 'sigma', detail: 'The population (known) standard deviation. If omitted, the sample standard deviation is used.' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/statistical/ja-JP.ts b/packages/sheets-formula-ui/src/locale/function-list/statistical/ja-JP.ts index 87df95b3fd7d..fa85336e8a84 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/statistical/ja-JP.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/statistical/ja-JP.ts @@ -1504,8 +1504,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array1: { name: '配列1', detail: '比較対象となる一方のデータを含む配列またはセル範囲を指定します。' }, + array2: { name: '配列2', detail: '比較対象となるもう一方のデータを含む配列またはセル範囲を指定します。' }, + tails: { name: '尾部の特性', detail: '片側分布を計算するか、両側分布を計算するかを、数値で指定します。 尾部に 1 を指定すると片側分布の値が計算されます。 尾部に 2 を指定すると両側分布の値が計算されます。' }, + type: { name: '検定の種類', detail: '実行する t 検定の種類を数値で指定します。' }, }, }, TREND: { @@ -1532,8 +1534,8 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '配列', detail: '対象となる値の配列または範囲。' }, + percent: { name: '割合', detail: '計算から排除する端数のデータ ポイント数。' }, }, }, VAR_P: { @@ -1602,8 +1604,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + x: { name: 'x', detail: '関数に代入する値を指定します。' }, + alpha: { name: 'alpha', detail: '分布の最初のパラメータ。' }, + beta: { name: 'beta', detail: '分布の 2 番目のパラメーター。' }, + cumulative: { name: '累積', detail: '計算に使用する関数の形式を論理値で指定します。 関数形式に TRUE を指定すると累積分布関数の値が計算され、FALSE を指定すると確率密度関数の値が計算されます。' }, }, }, Z_TEST: { @@ -1616,8 +1620,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '配列', detail: 'x の検定対象となるデータを含む数値配列またはセル範囲を指定します。' }, + x: { name: 'x', detail: '検定する値を指定します。' }, + sigma: { name: '標準偏差', detail: '母集団全体に基づく標準偏差を指定します。 省略すると、標本に基づく標準偏差が使用されます。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/statistical/vi-VN.ts b/packages/sheets-formula-ui/src/locale/function-list/statistical/vi-VN.ts index ef8f21644726..2a31a872a3cd 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/statistical/vi-VN.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/statistical/vi-VN.ts @@ -1435,6 +1435,36 @@ export default { degFreedom: { name: 'bậc tự do', detail: 'Một số nguyên biểu thị số bậc tự do.' }, }, }, + T_TEST: { + description: 'Trả về xác suất kết hợp với Phép thử t-Student.', + abstract: 'Trả về xác suất kết hợp với Phép thử t-Student.', + links: [ + { + title: 'Hướng dẫn', + url: 'https://support.microsoft.com/vi-vn/office/t-test-%E5%87%BD%E6%95%B0-d4e08ec3-c545-485f-962e-276f7cbed055', + }, + ], + functionParameter: { + array1: { name: 'mảng 1', detail: 'Mảng thứ nhất của phạm vi dữ liệu.' }, + array2: { name: 'mảng 2', detail: 'Mảng thứ hai của phạm vi dữ liệu.' }, + tails: { name: 'đặc điểm đuôi', detail: 'Xác định số đuôi của phân phối. Nếu đuôi = 1, T.TEST sử dụng phân phối một phía. Nếu đuôi = 2, T.TEST sử dụng phân phối hai phía.' }, + type: { name: 'loại Phép thử', detail: 'Loại Phép thử t cần thực hiện.' }, + }, + }, + TRIMMEAN: { + description: 'Trả về trung bình của phần trong một tập dữ liệu.', + abstract: 'Trả về trung bình của phần trong một tập dữ liệu.', + links: [ + { + title: 'Hướng dẫn', + url: 'https://support.microsoft.com/vi-vn/office/trimmean-%E5%87%BD%E6%95%B0-d90c9878-a119-4746-88fa-63d988f511d3', + }, + ], + functionParameter: { + array: { name: 'mảng', detail: 'Mảng hoặc phạm vi giá trị cần cắt bớt và tính trung bình.' }, + percent: { name: 'tỷ lệ loại trừ', detail: 'Tỷ lệ các điểm dữ liệu cần loại bỏ ra khỏi việc tính toán.' }, + }, + }, VAR_P: { description: 'Tính toán phương sai dựa trên toàn bộ tập hợp (bỏ các giá trị lô-gic và văn bản trong tập hợp).', abstract: 'Tính toán phương sai dựa trên toàn bộ tập hợp', @@ -1491,4 +1521,35 @@ export default { value2: { name: 'giá trị 2', detail: 'Là các đối số dạng số từ 2 đến 254 tương ứng với một tập hợp.' }, }, }, + WEIBULL_DIST: { + description: 'Trả về phân bố Weibull.', + abstract: 'Trả về phân bố Weibull.', + links: [ + { + title: 'Hướng dẫn', + url: 'https://support.microsoft.com/vi-vn/office/weibull-dist-%E5%87%BD%E6%95%B0-4e783c39-9325-49be-bbc9-a83ef82b45db', + }, + ], + functionParameter: { + x: { name: 'x', detail: 'Giá trị mà bạn muốn có phân bố của nó.' }, + alpha: { name: 'alpha', detail: 'Tham số đầu tiên của phân phối.' }, + beta: { name: 'beta', detail: 'Tham số thứ hai của phân phối.' }, + cumulative: { name: 'tích lũy', detail: 'Một giá trị lô-gic quyết định dạng thức của hàm. Nếu tích lũy là TRUE, hàm WEIBULL.DIST trả về hàm phân bố tích lũy; nếu FALSE, nó trả về hàm mật độ xác suất.' }, + }, + }, + Z_TEST: { + description: 'Trả về giá trị xác suất một phía của kiểm tra z.', + abstract: 'Trả về giá trị xác suất một phía của kiểm tra z.', + links: [ + { + title: 'Hướng dẫn', + url: 'https://support.microsoft.com/vi-vn/office/z-test-%E5%87%BD%E6%95%B0-d633d5a3-2031-4614-a016-92180ad82bee', + }, + ], + functionParameter: { + array: { name: 'mảng', detail: 'Mảng hay khoảng dữ liệu để kiểm tra x.' }, + x: { name: 'x', detail: 'Giá trị cần kiểm tra.' }, + sigma: { name: 'Độ lệch chuẩn', detail: 'Độ lệch chuẩn tổng thể (đã biết). Nếu bỏ qua, độ lệch chuẩn mẫu sẽ được dùng.' }, + }, + }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/statistical/zh-CN.ts b/packages/sheets-formula-ui/src/locale/function-list/statistical/zh-CN.ts index cf45cd6c4b3c..7c39a555b1d6 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/statistical/zh-CN.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/statistical/zh-CN.ts @@ -1541,8 +1541,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array1: { name: '数组1', detail: '第一个数据数组或数据范围。' }, + array2: { name: '数组2', detail: '第二个数据数组或数据范围。' }, + tails: { name: '尾部特性', detail: '指定分布尾数。 如果 tails = 1，则 T.TEST 使用单尾分布。 如果 tails = 2，则 T.TEST 使用双尾分布。' }, + type: { name: '检验类型', detail: '要执行的 t 检验的类型。' }, }, }, TREND: { @@ -1569,8 +1571,8 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '数组', detail: '要求得内部平均值的数组或数据区域。' }, + percent: { name: '排除比例', detail: '从计算中排除数据点的百分比值。' }, }, }, VAR_P: { @@ -1639,8 +1641,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + x: { name: 'x', detail: '需要计算其分布的数值。' }, + alpha: { name: 'alpha', detail: '分布的第一个参数。' }, + beta: { name: 'beta', detail: '分布的第二个参数。' }, + cumulative: { name: '累积', detail: '决定函数形式的逻辑值。如果为TRUE，则 WEIBULL.DIST 返回累积分布函数；如果为 FALSE，则返回概率密度函数。' }, }, }, Z_TEST: { @@ -1653,8 +1657,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '数组', detail: '用来检验 x 的数组或数据区域。' }, + x: { name: 'x', detail: '要测试的值。' }, + sigma: { name: '标准偏差', detail: '总体（已知）标准偏差。 如果省略，则使用样本标准偏差。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/statistical/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/statistical/zh-TW.ts index ba66b1c02bda..16ff5456e693 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/statistical/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/statistical/zh-TW.ts @@ -129,7 +129,7 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是 beta 分佈的相關機率。' }, + probability: { name: '機率', detail: 'beta 分佈的相關機率。' }, alpha: { name: 'alpha', detail: '分佈的第一個參數。' }, beta: { name: 'beta', detail: '分佈的第二個參數。' }, A: { name: '下限', detail: '函數的下限，預設值為 0。' }, @@ -180,7 +180,7 @@ export default { functionParameter: { trials: { name: '實驗次數', detail: '伯努利實驗的次數。' }, probabilityS: { name: '成功機率', detail: '每一次實驗的成功機率。' }, - alpha: { name: '目標機率', detail: '這是臨界值。' }, + alpha: { name: '目標機率', detail: '臨界值。' }, }, }, CHISQ_DIST: { @@ -193,9 +193,9 @@ export default { }, ], functionParameter: { - x: { name: '值', detail: '這是用來評估分佈的值。' }, - degFreedom: { name: '自由度', detail: '這是自由度。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，CHISQ.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: '值', detail: '用來評估分佈的值。' }, + degFreedom: { name: '自由度', detail: '自由度。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，CHISQ.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, CHISQ_DIST_RT: { @@ -208,8 +208,8 @@ export default { }, ], functionParameter: { - x: { name: '值', detail: '這是用來評估分佈的值。' }, - degFreedom: { name: '自由度', detail: '這是自由度。' }, + x: { name: '值', detail: '用來評估分佈的值。' }, + degFreedom: { name: '自由度', detail: '自由度。' }, }, }, CHISQ_INV: { @@ -222,8 +222,8 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是與 χ2 分佈相關聯的機率。' }, - degFreedom: { name: '自由度', detail: '這是自由度。' }, + probability: { name: '機率', detail: '與 χ2 分佈相關聯的機率。' }, + degFreedom: { name: '自由度', detail: '自由度。' }, }, }, CHISQ_INV_RT: { @@ -236,8 +236,8 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是與 χ2 分佈相關聯的機率。' }, - degFreedom: { name: '自由度', detail: '這是自由度。' }, + probability: { name: '機率', detail: '與 χ2 分佈相關聯的機率。' }, + degFreedom: { name: '自由度', detail: '自由度。' }, }, }, CHISQ_TEST: { @@ -250,8 +250,8 @@ export default { }, ], functionParameter: { - actualRange: { name: '觀察範圍', detail: '這是觀察值範圍，用來檢定預期值。' }, - expectedRange: { name: '預期範圍', detail: '這是資料範圍，其內容為各欄總和乘各列總和後的值，再除以全部值總和的比率。' }, + actualRange: { name: '觀察範圍', detail: '觀察值範圍，用來檢定預期值。' }, + expectedRange: { name: '預期範圍', detail: '資料範圍，其內容為各欄總和乘各列總和後的值，再除以全部值總和的比率。' }, }, }, CONFIDENCE_NORM: { @@ -266,7 +266,7 @@ export default { functionParameter: { alpha: { name: 'alpha', detail: '用於計算置信水準的顯著水準。置信水準等於 100*(1 - alpha)%，換句話說，alpha 0.05 表示信賴水準為 95%。' }, standardDev: { name: '總體標準差', detail: '假設資料範圍的總體標準差已知。' }, - size: { name: '樣本大小', detail: '這是樣本大小。' }, + size: { name: '樣本大小', detail: '樣本大小。' }, }, }, CONFIDENCE_T: { @@ -281,7 +281,7 @@ export default { functionParameter: { alpha: { name: 'alpha', detail: '用於計算置信水準的顯著水準。置信水準等於 100*(1 - alpha)%，換句話說，alpha 0.05 表示信賴水準為 95%。' }, standardDev: { name: '總體標準差', detail: '假設資料範圍的總體標準差已知。' }, - size: { name: '樣本大小', detail: '這是樣本大小。' }, + size: { name: '樣本大小', detail: '樣本大小。' }, }, }, CORREL: { @@ -419,8 +419,8 @@ export default { }, ], functionParameter: { - number1: { name: '數值1', detail: '這是要計算平方差之總和的第 1 個引數。' }, - number2: { name: '數值2', detail: '這是要計算平方差之總和的第 2 到 255 個引數。' }, + number1: { name: '數值1', detail: '要計算平方差之總和的第 1 個引數。' }, + number2: { name: '數值2', detail: '要計算平方差之總和的第 2 到 255 個引數。' }, }, }, EXPON_DIST: { @@ -433,9 +433,9 @@ export default { }, ], functionParameter: { - x: { name: '值', detail: '這是用來評估分佈的值。' }, - lambda: { name: 'lambda', detail: '這是參數值。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，EXPON.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: '值', detail: '用來評估分佈的值。' }, + lambda: { name: 'lambda', detail: '參數值。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，EXPON.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, F_DIST: { @@ -448,10 +448,10 @@ export default { }, ], functionParameter: { - x: { name: '值', detail: '這是用於評估函數的值。' }, - degFreedom1: { name: '分子自由度', detail: '這是分子的自由度。' }, - degFreedom2: { name: '分母自由度', detail: '這是分母的自由度。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，F.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: '值', detail: '用於評估函數的值。' }, + degFreedom1: { name: '分子自由度', detail: '分子的自由度。' }, + degFreedom2: { name: '分母自由度', detail: '分母的自由度。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，F.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, F_DIST_RT: { @@ -464,9 +464,9 @@ export default { }, ], functionParameter: { - x: { name: '值', detail: '這是用於評估函數的值。' }, - degFreedom1: { name: '分子自由度', detail: '這是分子的自由度。' }, - degFreedom2: { name: '分母自由度', detail: '這是分母的自由度。' }, + x: { name: '值', detail: '用於評估函數的值。' }, + degFreedom1: { name: '分子自由度', detail: '分子的自由度。' }, + degFreedom2: { name: '分母自由度', detail: '分母的自由度。' }, }, }, F_INV: { @@ -480,8 +480,8 @@ export default { ], functionParameter: { probability: { name: '機率', detail: 'F 累積分佈相關的機率' }, - degFreedom1: { name: '分子自由度', detail: '這是分子的自由度。' }, - degFreedom2: { name: '分母自由度', detail: '這是分母的自由度。' }, + degFreedom1: { name: '分子自由度', detail: '分子的自由度。' }, + degFreedom2: { name: '分母自由度', detail: '分母的自由度。' }, }, }, F_INV_RT: { @@ -495,8 +495,8 @@ export default { ], functionParameter: { probability: { name: '機率', detail: 'F 累積分佈相關的機率' }, - degFreedom1: { name: '分子自由度', detail: '這是分子的自由度。' }, - degFreedom2: { name: '分母自由度', detail: '這是分母的自由度。' }, + degFreedom1: { name: '分子自由度', detail: '分子的自由度。' }, + degFreedom2: { name: '分母自由度', detail: '分母的自由度。' }, }, }, F_TEST: { @@ -509,8 +509,8 @@ export default { }, ], functionParameter: { - array1: { name: '陣列1', detail: '這是第一個陣列或資料範圍。' }, - array2: { name: '陣列2', detail: '這是第一個陣列或資料範圍。' }, + array1: { name: '陣列1', detail: '第一個陣列或資料範圍。' }, + array2: { name: '陣列2', detail: '第二個陣列或資料範圍。' }, }, }, FISHER: { @@ -523,7 +523,7 @@ export default { }, ], functionParameter: { - x: { name: '數值', detail: '這是要轉換的數值。' }, + x: { name: '數值', detail: '要轉換的數值。' }, }, }, FISHERINV: { @@ -536,7 +536,7 @@ export default { }, ], functionParameter: { - y: { name: '數值', detail: '這是要執行反轉換的數值。' }, + y: { name: '數值', detail: '要執行反轉換的數值。' }, }, }, FORECAST: { @@ -549,7 +549,7 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是要預測值的資料點。' }, + x: { name: 'x', detail: '要預測值的資料點。' }, knownYs: { name: '陣列_y', detail: '代表因變數資料的陣列或矩陣的範圍。' }, knownXs: { name: '陣列_x', detail: '代表自變數資料的陣列或矩陣的範圍。' }, }, @@ -621,7 +621,7 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是要預測值的資料點。' }, + x: { name: 'x', detail: '要預測值的資料點。' }, knownYs: { name: '陣列_y', detail: '代表因變數資料的陣列或矩陣的範圍。' }, knownXs: { name: '陣列_x', detail: '代表自變數資料的陣列或矩陣的範圍。' }, }, @@ -636,8 +636,8 @@ export default { }, ], functionParameter: { - dataArray: { name: '資料陣列', detail: '這是所要計算頻率的一組數值的陣列或參照。 如果 data_array 沒有值，FREQUENCY 會傳回零陣列。' }, - binsArray: { name: '區間陣列', detail: '這是區間的陣列或參照，用以將 data_array 中的值分組。 如果 bins_array 沒有值，FREQUENCY 會傳回 data_array 中的元素個數。' }, + dataArray: { name: '資料陣列', detail: '所要計算頻率的一組數值的陣列或參照。 如果 data_array 沒有值，FREQUENCY 會傳回零陣列。' }, + binsArray: { name: '區間陣列', detail: '區間的陣列或參照，用以將 data_array 中的值分組。 如果 bins_array 沒有值，FREQUENCY 會傳回 data_array 中的元素個數。' }, }, }, GAMMA: { @@ -663,7 +663,7 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出分佈的數值。' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, alpha: { name: 'alpha', detail: '分佈的第一個參數。' }, beta: { name: 'beta', detail: '分佈的第二個參數。' }, cumulative: { name: '累積', detail: '決定函數形式的邏輯值。如果為 TRUE，則 GAMMA.DIST 傳回累積分佈函數；如果為 FALSE，則傳回機率密度函數。' }, @@ -679,7 +679,7 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是與伽瑪分佈的相關機率。' }, + probability: { name: '機率', detail: '與伽瑪分佈的相關機率。' }, alpha: { name: 'alpha', detail: '分佈的第一個參數。' }, beta: { name: 'beta', detail: '分佈的第二個參數。' }, }, @@ -694,7 +694,7 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是要計算 GAMMALN 的值。' }, + x: { name: 'x', detail: '要計算 GAMMALN 的值。' }, }, }, GAMMALN_PRECISE: { @@ -707,7 +707,7 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是要計算 GAMMALN.PRECISE 的值。' }, + x: { name: 'x', detail: '要計算 GAMMALN.PRECISE 的值。' }, }, }, GAUSS: { @@ -720,7 +720,7 @@ export default { }, ], functionParameter: { - z: { name: 'z', detail: '這是您要找出分佈的數值。' }, + z: { name: 'z', detail: '要找出分佈的數值。' }, }, }, GEOMEAN: { @@ -747,10 +747,10 @@ export default { }, ], functionParameter: { - knownYs: { name: '已知資料_y', detail: '這是在 y = b*m^x 關係中一組已知的 y 值。' }, - knownXs: { name: '已知資料_x', detail: '這是在 y = b*m^x 關係中一組已知的 x 值。' }, - newXs: { name: '新資料_x', detail: '這是要 GROWTH 傳回對應 y 值的新 x 值。' }, - constb: { name: 'b', detail: '這是指定是否強迫常數 b 等於 1 的邏輯值。' }, + knownYs: { name: '已知資料_y', detail: '在 y = b*m^x 關係中一組已知的 y 值。' }, + knownXs: { name: '已知資料_x', detail: '在 y = b*m^x 關係中一組已知的 x 值。' }, + newXs: { name: '新資料_x', detail: '要 GROWTH 傳回對應 y 值的新 x 值。' }, + constb: { name: 'b', detail: '指定是否強迫常數 b 等於 1 的邏輯值。' }, }, }, HARMEAN: { @@ -822,8 +822,8 @@ export default { }, ], functionParameter: { - array: { name: '陣列', detail: '這是要判斷第 k 個最大值的陣列或資料範圍。' }, - k: { name: 'k', detail: ' 這是要傳回之資料陣列或儲存格範圍中的位置 (由最大起算)。' }, + array: { name: '陣列', detail: '要判斷第 k 個最大值的陣列或資料範圍。' }, + k: { name: 'k', detail: '要傳回之資料陣列或儲存格範圍中的位置 (由最大起算)。' }, }, }, LINEST: { @@ -864,10 +864,10 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出分佈的數值。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，LOGNORM.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，LOGNORM.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, LOGNORM_INV: { @@ -880,9 +880,9 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是對應到對數常態分佈的機率。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, + probability: { name: '機率', detail: '對應到對數常態分佈的機率。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, }, }, MAX: { @@ -1039,10 +1039,10 @@ export default { }, ], functionParameter: { - numberF: { name: '失敗次數', detail: '這是失敗的次數。' }, - numberS: { name: '成功次數', detail: '這是成功的閥值數目。' }, - probabilityS: { name: '成功機率', detail: '這是成功的機率。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，NEGBINOM.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + numberF: { name: '失敗次數', detail: '失敗的次數。' }, + numberS: { name: '成功次數', detail: '成功的閥值數目。' }, + probabilityS: { name: '成功機率', detail: '成功的機率。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，NEGBINOM.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, NORM_DIST: { @@ -1055,10 +1055,10 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出分佈的數值。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，NORM.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，NORM.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, NORM_INV: { @@ -1071,9 +1071,9 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是對應到常態分佈的機率。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, + probability: { name: '機率', detail: '對應到常態分佈的機率。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, }, }, NORM_S_DIST: { @@ -1086,8 +1086,8 @@ export default { }, ], functionParameter: { - z: { name: 'z', detail: '這是您要找出分佈的數值。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，NORM.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + z: { name: 'z', detail: '要找出分佈的數值。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，NORM.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, NORM_S_INV: { @@ -1100,7 +1100,7 @@ export default { }, ], functionParameter: { - probability: { name: '機率', detail: '這是對應到常態分佈的機率。' }, + probability: { name: '機率', detail: '對應到常態分佈的機率。' }, }, }, PEARSON: { @@ -1185,8 +1185,8 @@ export default { }, ], functionParameter: { - number: { name: '總數', detail: '這是項目數。' }, - numberChosen: { name: '樣品數量', detail: '這是每個排列中的項目數。' }, + number: { name: '總數', detail: '項目數。' }, + numberChosen: { name: '樣品數量', detail: '每個排列中的項目數。' }, }, }, PERMUTATIONA: { @@ -1199,8 +1199,8 @@ export default { }, ], functionParameter: { - number: { name: '總數', detail: '這是項目數。' }, - numberChosen: { name: '樣品數量', detail: '這是每個排列中的項目數。' }, + number: { name: '總數', detail: '項目數。' }, + numberChosen: { name: '樣品數量', detail: '每個排列中的項目數。' }, }, }, PHI: { @@ -1226,9 +1226,9 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出分佈的數值。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - cumulative: { name: '累積', detail: ' 這是決定函數形式的邏輯值。 如果為 TRUE，POISSON.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，POISSON.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, PROB: { @@ -1285,9 +1285,9 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要找出其排名的數字。' }, + number: { name: '數值', detail: '要找出其排名的數字。' }, ref: { name: '數位清單', detail: '數位清單的參照。會忽略 ref 中的非數值。' }, - order: { name: '排列方式', detail: '這是指定排列數值方式的數字。0 或省略為遞減順序排序，非 0 為遞增順序排序。' }, + order: { name: '排列方式', detail: '指定排列數值方式的數字。0 或省略為遞減順序排序，非 0 為遞增順序排序。' }, }, }, RANK_EQ: { @@ -1300,9 +1300,9 @@ export default { }, ], functionParameter: { - number: { name: '數值', detail: '這是要找出其排名的數字。' }, + number: { name: '數值', detail: '要找出其排名的數字。' }, ref: { name: '數位清單', detail: '數位清單的參照。會忽略 ref 中的非數值。' }, - order: { name: '排列方式', detail: '這是指定排列數值方式的數字。0 或省略為遞減順序排序，非 0 為遞增順序排序。' }, + order: { name: '排列方式', detail: '指定排列數值方式的數字。0 或省略為遞減順序排序，非 0 為遞增順序排序。' }, }, }, RSQ: { @@ -1371,8 +1371,8 @@ export default { }, ], functionParameter: { - array: { name: '陣列', detail: '這是要判斷第 k 個最小值的陣列或資料範圍。' }, - k: { name: 'k', detail: ' 這是要傳回之資料陣列或儲存格範圍中的位置 (由最小起算)。' }, + array: { name: '陣列', detail: '要判斷第 k 個最小值的陣列或資料範圍。' }, + k: { name: 'k', detail: '要傳回之資料陣列或儲存格範圍中的位置 (由最小起算)。' }, }, }, STANDARDIZE: { @@ -1385,9 +1385,9 @@ export default { }, ], functionParameter: { - x: { name: 'x', detail: '這是您要找出常態化的數值。' }, - mean: { name: '平均值', detail: '這是分佈的算術平均值。' }, - standardDev: { name: '標準差', detail: '這是分佈的標準差。' }, + x: { name: 'x', detail: '要找出常態化的數值。' }, + mean: { name: '平均值', detail: '分佈的算術平均值。' }, + standardDev: { name: '標準差', detail: '分佈的標準差。' }, }, }, STDEV_P: { @@ -1472,7 +1472,7 @@ export default { functionParameter: { x: { name: 'x', detail: '需要計算分佈的數值。' }, degFreedom: { name: '自由度', detail: '一個表示自由度數的整數。' }, - cumulative: { name: '累積', detail: '這是決定函數形式的邏輯值。 如果為 TRUE，T.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。 如果為 TRUE，T.DIST 會傳回累積分佈函數；如果為 FALSE，則會傳回機率密度函數。' }, }, }, T_DIST_2T: { @@ -1541,8 +1541,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array1: { name: '陣列1', detail: '第一個陣列或資料範圍。' }, + array2: { name: '陣列2', detail: '第二個陣列或資料範圍。' }, + tails: { name: '尾部特性', detail: '指定分佈的尾數。 如果 tails = 1，T.TEST 會使用單尾分佈。 如果 tails = 2，T.TEST 會使用雙尾分佈。' }, + type: { name: '檢定類型', detail: '要執行的 t 檢定類型。' }, }, }, TREND: { @@ -1569,8 +1571,8 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '陣列', detail: '要求得內部平均值的陣列或資料範圍。' }, + percent: { name: '排除比例', detail: '從計算中排除資料點的百分比值。' }, }, }, VAR_P: { @@ -1639,8 +1641,10 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + x: { name: 'x', detail: '要找出分佈的數值。' }, + alpha: { name: 'alpha', detail: '分佈的第一個參數。' }, + beta: { name: 'beta', detail: '分佈的第二個參數。' }, + cumulative: { name: '累積', detail: '決定函數形式的邏輯值。如果為 TRUE，則 WEIBULL.DIST 傳回累積分佈函數；如果為 FALSE，則傳回機率密度函數。' }, }, }, Z_TEST: { @@ -1653,8 +1657,9 @@ export default { }, ], functionParameter: { - number1: { name: 'number1', detail: 'first' }, - number2: { name: 'number2', detail: 'second' }, + array: { name: '陣列', detail: '用來檢定 x 的陣列或資料範圍。' }, + x: { name: 'x', detail: '要檢定的值。' }, + sigma: { name: '標準差', detail: '總體（已知）標準差。如果省略，則使用樣本標準差。' }, }, }, }; diff --git a/packages/sheets-formula-ui/src/locale/function-list/text/zh-TW.ts b/packages/sheets-formula-ui/src/locale/function-list/text/zh-TW.ts index 6ad7a425154d..0c5607d9c529 100644 --- a/packages/sheets-formula-ui/src/locale/function-list/text/zh-TW.ts +++ b/packages/sheets-formula-ui/src/locale/function-list/text/zh-TW.ts @@ -291,9 +291,9 @@ export default { }, ], functionParameter: { - text: { name: 'text', detail: '這是包含您想擷取之字元的文字字串。' }, - startNum: { name: 'start_num', detail: ' 這是要在文字中擷取之第一個字元的位置。 文字中的第一個字元start_num 1，依此類文字。\n如果start_num大於文字的長度，MID/MIDB 會傳回 “” (空白文字) 。\n如果start_num小於文字的長度，但start_num加上num_chars超過文字的長度，MID/MIDB 會傳回文字結尾的字元。\n如果 start_num 小於 1，MID/MIDB 會傳回 #VALUE！ 錯誤值。' }, - numChars: { name: 'num_chars', detail: '指定您要 MID 從文字傳回的字元數。\n如果 num_chars 為負數，MID 會傳回 #VALUE! 的錯誤值。' }, + text: { name: 'text', detail: '包含想擷取之字元的文字字串。' }, + startNum: { name: 'start_num', detail: ' 要在文字中擷取之第一個字元的位置。 文字中的第一個字元start_num 1，依此類文字。\n如果start_num大於文字的長度，MID/MIDB 會傳回 “” (空白文字) 。\n如果start_num小於文字的長度，但start_num加上num_chars超過文字的長度，MID/MIDB 會傳回文字結尾的字元。\n如果 start_num 小於 1，MID/MIDB 會傳回 #VALUE！ 錯誤值。' }, + numChars: { name: 'num_chars', detail: '指定要 MID 從文字傳回的字元數。\n如果 num_chars 為負數，MID 會傳回 #VALUE! 的錯誤值。' }, }, }, MIDB: { @@ -432,8 +432,8 @@ export default { }, ], functionParameter: { - text: { name: '文字', detail: '這是要重複的文字。' }, - numberTimes: { name: '重複次數', detail: '這是指定文字重複次數的正數。' }, + text: { name: '文字', detail: '要重複的文字。' }, + numberTimes: { name: '重複次數', detail: '指定文字重複次數的正數。' }, }, }, RIGHT: { @@ -544,7 +544,7 @@ export default { }, ], functionParameter: { - text: { name: '文字', detail: '您在此搜尋的文字。不允許萬用字元。' }, + text: { name: '文字', detail: '在此搜尋的文字。不允許萬用字元。' }, delimiter: { name: '分隔符號', detail: '標記要擷取之點之後的文字。' }, instanceNum: { name: '實例編號', detail: '要解壓縮文字的分隔符號實例。' }, matchMode: { name: '匹配模式', detail: '判斷文字搜尋是否區分大小寫。預設值會區分大小寫。' }, @@ -562,7 +562,7 @@ export default { }, ], functionParameter: { - text: { name: '文字', detail: '您在此搜尋的文字。不允許萬用字元。' }, + text: { name: '文字', detail: '在此搜尋的文字。不允許萬用字元。' }, delimiter: { name: '分隔符號', detail: '標記要擷取之點之後的文字。' }, instanceNum: { name: '實例編號', detail: '要解壓縮文字的分隔符號實例。' }, matchMode: { name: '匹配模式', detail: '判斷文字搜尋是否區分大小寫。預設值會區分大小寫。' }, diff --git a/packages/sheets-formula/src/services/function-list/compatibility.ts b/packages/sheets-formula/src/services/function-list/compatibility.ts index 75eac86d8b71..9bcdc8c2bef8 100644 --- a/packages/sheets-formula/src/services/function-list/compatibility.ts +++ b/packages/sheets-formula/src/services/function-list/compatibility.ts @@ -192,14 +192,14 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ { name: 'formula.functionList.CHITEST.functionParameter.actualRange.name', detail: 'formula.functionList.CHITEST.functionParameter.actualRange.detail', - example: '{58,35;11,25;10,23}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.CHITEST.functionParameter.expectedRange.name', detail: 'formula.functionList.CHITEST.functionParameter.expectedRange.detail', - example: '{45.35,47.65;17.56,18.44;16.09,16.91}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -243,14 +243,14 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ { name: 'formula.functionList.COVAR.functionParameter.array1.name', detail: 'formula.functionList.COVAR.functionParameter.array1.detail', - example: '{3,2,4,5,6}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.COVAR.functionParameter.array2.name', detail: 'formula.functionList.COVAR.functionParameter.array2.detail', - example: '{9,7,12,15,17}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -381,14 +381,14 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ { name: 'formula.functionList.FTEST.functionParameter.array1.name', detail: 'formula.functionList.FTEST.functionParameter.array1.detail', - example: '{58,35;11,25;10,23}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.FTEST.functionParameter.array2.name', detail: 'formula.functionList.FTEST.functionParameter.array2.detail', - example: '{45.35,47.65;17.56,18.44;16.09,16.91}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -562,7 +562,7 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ { name: 'formula.functionList.MODE.functionParameter.number1.name', detail: 'formula.functionList.MODE.functionParameter.number1.detail', - example: '{1,2,3}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -708,7 +708,7 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ { name: 'formula.functionList.PERCENTILE.functionParameter.array.name', detail: 'formula.functionList.PERCENTILE.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -730,7 +730,7 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ { name: 'formula.functionList.PERCENTRANK.functionParameter.array.name', detail: 'formula.functionList.PERCENTRANK.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -788,7 +788,7 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ { name: 'formula.functionList.QUARTILE.functionParameter.array.name', detail: 'formula.functionList.QUARTILE.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -932,16 +932,30 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ abstract: 'formula.functionList.TTEST.abstract', functionParameter: [ { - name: 'formula.functionList.TTEST.functionParameter.number1.name', - detail: 'formula.functionList.TTEST.functionParameter.number1.detail', - example: 'A1:A20', + name: 'formula.functionList.TTEST.functionParameter.array1.name', + detail: 'formula.functionList.TTEST.functionParameter.array1.detail', + example: 'A1:A4', require: 1, repeat: 0, }, { - name: 'formula.functionList.TTEST.functionParameter.number2.name', - detail: 'formula.functionList.TTEST.functionParameter.number2.detail', - example: 'A1:A20', + name: 'formula.functionList.TTEST.functionParameter.array2.name', + detail: 'formula.functionList.TTEST.functionParameter.array2.detail', + example: 'B1:B4', + require: 1, + repeat: 0, + }, + { + name: 'formula.functionList.TTEST.functionParameter.tails.name', + detail: 'formula.functionList.TTEST.functionParameter.tails.detail', + example: '2', + require: 1, + repeat: 0, + }, + { + name: 'formula.functionList.TTEST.functionParameter.type.name', + detail: 'formula.functionList.TTEST.functionParameter.type.detail', + example: '1', require: 1, repeat: 0, }, @@ -998,16 +1012,30 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ abstract: 'formula.functionList.WEIBULL.abstract', functionParameter: [ { - name: 'formula.functionList.WEIBULL.functionParameter.number1.name', - detail: 'formula.functionList.WEIBULL.functionParameter.number1.detail', - example: 'A1:A20', + name: 'formula.functionList.WEIBULL.functionParameter.x.name', + detail: 'formula.functionList.WEIBULL.functionParameter.x.detail', + example: '105', + require: 1, + repeat: 0, + }, + { + name: 'formula.functionList.WEIBULL.functionParameter.alpha.name', + detail: 'formula.functionList.WEIBULL.functionParameter.alpha.detail', + example: '20', require: 1, repeat: 0, }, { - name: 'formula.functionList.WEIBULL.functionParameter.number2.name', - detail: 'formula.functionList.WEIBULL.functionParameter.number2.detail', - example: 'A1:A20', + name: 'formula.functionList.WEIBULL.functionParameter.beta.name', + detail: 'formula.functionList.WEIBULL.functionParameter.beta.detail', + example: '100', + require: 1, + repeat: 0, + }, + { + name: 'formula.functionList.WEIBULL.functionParameter.cumulative.name', + detail: 'formula.functionList.WEIBULL.functionParameter.cumulative.detail', + example: 'true', require: 1, repeat: 0, }, @@ -1020,19 +1048,26 @@ export const FUNCTION_LIST_COMPATIBILITY: IFunctionInfo[] = [ abstract: 'formula.functionList.ZTEST.abstract', functionParameter: [ { - name: 'formula.functionList.ZTEST.functionParameter.number1.name', - detail: 'formula.functionList.ZTEST.functionParameter.number1.detail', - example: 'A1:A20', + name: 'formula.functionList.ZTEST.functionParameter.array.name', + detail: 'formula.functionList.ZTEST.functionParameter.array.detail', + example: 'A2:A11', require: 1, repeat: 0, }, { - name: 'formula.functionList.ZTEST.functionParameter.number2.name', - detail: 'formula.functionList.ZTEST.functionParameter.number2.detail', - example: 'A1:A20', + name: 'formula.functionList.ZTEST.functionParameter.x.name', + detail: 'formula.functionList.ZTEST.functionParameter.x.detail', + example: '4', require: 1, repeat: 0, }, + { + name: 'formula.functionList.ZTEST.functionParameter.sigma.name', + detail: 'formula.functionList.ZTEST.functionParameter.sigma.detail', + example: '10', + require: 0, + repeat: 0, + }, ], }, ]; diff --git a/packages/sheets-formula/src/services/function-list/financial.ts b/packages/sheets-formula/src/services/function-list/financial.ts index 851c0ca9574f..a543320d45ea 100644 --- a/packages/sheets-formula/src/services/function-list/financial.ts +++ b/packages/sheets-formula/src/services/function-list/financial.ts @@ -823,7 +823,7 @@ export const FUNCTION_LIST_FINANCIAL: IFunctionInfo[] = [ { name: 'formula.functionList.FVSCHEDULE.functionParameter.schedule.name', detail: 'formula.functionList.FVSCHEDULE.functionParameter.schedule.detail', - example: '{0.09,0.11,0.1}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -931,7 +931,7 @@ export const FUNCTION_LIST_FINANCIAL: IFunctionInfo[] = [ { name: 'formula.functionList.IRR.functionParameter.values.name', detail: 'formula.functionList.IRR.functionParameter.values.detail', - example: '{-700000,120000,150000,180000,210000,260000}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -1039,7 +1039,7 @@ export const FUNCTION_LIST_FINANCIAL: IFunctionInfo[] = [ { name: 'formula.functionList.MIRR.functionParameter.values.name', detail: 'formula.functionList.MIRR.functionParameter.values.detail', - example: '{-120000,39000,30000,21000,37000,46000}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -1140,7 +1140,7 @@ export const FUNCTION_LIST_FINANCIAL: IFunctionInfo[] = [ { name: 'formula.functionList.NPV.functionParameter.value1.name', detail: 'formula.functionList.NPV.functionParameter.value1.detail', - example: '{-10000,3000,4200,6800}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -2078,14 +2078,14 @@ export const FUNCTION_LIST_FINANCIAL: IFunctionInfo[] = [ { name: 'formula.functionList.XIRR.functionParameter.values.name', detail: 'formula.functionList.XIRR.functionParameter.values.detail', - example: '{-10000,2750,4250,3250,2750}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.XIRR.functionParameter.dates.name', detail: 'formula.functionList.XIRR.functionParameter.dates.detail', - example: '{39448,39508,39751,39859,39904}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -2114,14 +2114,14 @@ export const FUNCTION_LIST_FINANCIAL: IFunctionInfo[] = [ { name: 'formula.functionList.XNPV.functionParameter.values.name', detail: 'formula.functionList.XNPV.functionParameter.values.detail', - example: '{-10000,2750,4250,3250,2750}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.XNPV.functionParameter.dates.name', detail: 'formula.functionList.XNPV.functionParameter.dates.detail', - example: '{39448,39508,39751,39859,39904}', + example: 'B1:B4', require: 1, repeat: 0, }, diff --git a/packages/sheets-formula/src/services/function-list/lookup.ts b/packages/sheets-formula/src/services/function-list/lookup.ts index d12572aac6ad..f1390e54866f 100644 --- a/packages/sheets-formula/src/services/function-list/lookup.ts +++ b/packages/sheets-formula/src/services/function-list/lookup.ts @@ -113,7 +113,7 @@ export const FUNCTION_LIST_LOOKUP: IFunctionInfo[] = [ { name: 'formula.functionList.CHOOSECOLS.functionParameter.array.name', detail: 'formula.functionList.CHOOSECOLS.functionParameter.array.detail', - example: '{1,2,3;2,3,4}', + example: 'A1:C2', require: 1, repeat: 0, }, @@ -142,7 +142,7 @@ export const FUNCTION_LIST_LOOKUP: IFunctionInfo[] = [ { name: 'formula.functionList.CHOOSEROWS.functionParameter.array.name', detail: 'formula.functionList.CHOOSEROWS.functionParameter.array.detail', - example: '{1,2,3;2,3,4}', + example: 'A1:C2', require: 1, repeat: 0, }, diff --git a/packages/sheets-formula/src/services/function-list/math.ts b/packages/sheets-formula/src/services/function-list/math.ts index 75f9f2749e23..4682df28182f 100644 --- a/packages/sheets-formula/src/services/function-list/math.ts +++ b/packages/sheets-formula/src/services/function-list/math.ts @@ -789,7 +789,7 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [ { name: 'formula.functionList.MDETERM.functionParameter.array.name', detail: 'formula.functionList.MDETERM.functionParameter.array.detail', - example: '{3,6,1;1,1,0;3,10,2}', + example: 'A1:C3', require: 1, repeat: 0, }, @@ -804,7 +804,7 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [ { name: 'formula.functionList.MINVERSE.functionParameter.array.name', detail: 'formula.functionList.MINVERSE.functionParameter.array.detail', - example: '{3,6,1;1,1,0;3,10,2}', + example: 'A1:C3', require: 1, repeat: 0, }, @@ -1238,7 +1238,7 @@ export const FUNCTION_LIST_MATH: IFunctionInfo[] = [ { name: 'formula.functionList.SERIESSUM.functionParameter.coefficients.name', detail: 'formula.functionList.SERIESSUM.functionParameter.coefficients.detail', - example: '{1,-0.5,0.041666667,-0.001388889}', + example: 'A1:A4', require: 1, repeat: 0, }, diff --git a/packages/sheets-formula/src/services/function-list/statistical.ts b/packages/sheets-formula/src/services/function-list/statistical.ts index b0e8656b4fe2..0a83fb89552b 100644 --- a/packages/sheets-formula/src/services/function-list/statistical.ts +++ b/packages/sheets-formula/src/services/function-list/statistical.ts @@ -455,14 +455,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.CHISQ_TEST.functionParameter.actualRange.name', detail: 'formula.functionList.CHISQ_TEST.functionParameter.actualRange.detail', - example: '{58,35;11,25;10,23}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.CHISQ_TEST.functionParameter.expectedRange.name', detail: 'formula.functionList.CHISQ_TEST.functionParameter.expectedRange.detail', - example: '{45.35,47.65;17.56,18.44;16.09,16.91}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -535,14 +535,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.CORREL.functionParameter.array1.name', detail: 'formula.functionList.CORREL.functionParameter.array1.detail', - example: '{3,2,4,5,6}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.CORREL.functionParameter.array2.name', detail: 'formula.functionList.CORREL.functionParameter.array2.detail', - example: '{9,7,12,15,17}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -676,14 +676,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.COVARIANCE_P.functionParameter.array1.name', detail: 'formula.functionList.COVARIANCE_P.functionParameter.array1.detail', - example: '{3,2,4,5,6}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.COVARIANCE_P.functionParameter.array2.name', detail: 'formula.functionList.COVARIANCE_P.functionParameter.array2.detail', - example: '{9,7,12,15,17}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -698,14 +698,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.COVARIANCE_S.functionParameter.array1.name', detail: 'formula.functionList.COVARIANCE_S.functionParameter.array1.detail', - example: '{3,2,4,5,6}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.COVARIANCE_S.functionParameter.array2.name', detail: 'formula.functionList.COVARIANCE_S.functionParameter.array2.detail', - example: '{9,7,12,15,17}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -894,14 +894,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.F_TEST.functionParameter.array1.name', detail: 'formula.functionList.F_TEST.functionParameter.array1.detail', - example: '{58,35;11,25;10,23}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.F_TEST.functionParameter.array2.name', detail: 'formula.functionList.F_TEST.functionParameter.array2.detail', - example: '{45.35,47.65;17.56,18.44;16.09,16.91}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -953,14 +953,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.FORECAST.functionParameter.knownYs.name', detail: 'formula.functionList.FORECAST.functionParameter.knownYs.detail', - example: '{6,7,9,15,21}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.FORECAST.functionParameter.knownXs.name', detail: 'formula.functionList.FORECAST.functionParameter.knownXs.detail', - example: '{20,28,31,38,40}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -1070,14 +1070,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.FORECAST_LINEAR.functionParameter.knownYs.name', detail: 'formula.functionList.FORECAST_LINEAR.functionParameter.knownYs.detail', - example: '{6,7,9,15,21}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.FORECAST_LINEAR.functionParameter.knownXs.name', detail: 'formula.functionList.FORECAST_LINEAR.functionParameter.knownXs.detail', - example: '{20,28,31,38,40}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -1362,14 +1362,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.INTERCEPT.functionParameter.knownYs.name', detail: 'formula.functionList.INTERCEPT.functionParameter.knownYs.detail', - example: '{6,7,9,15,21}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.INTERCEPT.functionParameter.knownXs.name', detail: 'formula.functionList.INTERCEPT.functionParameter.knownXs.detail', - example: '{20,28,31,38,40}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -1384,7 +1384,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.KURT.functionParameter.number1.name', detail: 'formula.functionList.KURT.functionParameter.number1.detail', - example: '{1,2,3}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -1735,7 +1735,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.MODE_MULT.functionParameter.number1.name', detail: 'formula.functionList.MODE_MULT.functionParameter.number1.detail', - example: '{1,2,3}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -1757,7 +1757,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.MODE_SNGL.functionParameter.number1.name', detail: 'formula.functionList.MODE_SNGL.functionParameter.number1.detail', - example: '{1,2,3}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -1917,14 +1917,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.PEARSON.functionParameter.array1.name', detail: 'formula.functionList.PEARSON.functionParameter.array1.detail', - example: '{6,7,9,15,21}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.PEARSON.functionParameter.array2.name', detail: 'formula.functionList.PEARSON.functionParameter.array2.detail', - example: '{20,28,31,38,40}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -1939,7 +1939,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.PERCENTILE_EXC.functionParameter.array.name', detail: 'formula.functionList.PERCENTILE_EXC.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -1961,7 +1961,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.PERCENTILE_INC.functionParameter.array.name', detail: 'formula.functionList.PERCENTILE_INC.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -1983,7 +1983,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.PERCENTRANK_EXC.functionParameter.array.name', detail: 'formula.functionList.PERCENTRANK_EXC.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -2012,7 +2012,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.PERCENTRANK_INC.functionParameter.array.name', detail: 'formula.functionList.PERCENTRANK_INC.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -2129,14 +2129,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.PROB.functionParameter.xRange.name', detail: 'formula.functionList.PROB.functionParameter.xRange.detail', - example: '{0,1,2,3}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.PROB.functionParameter.probRange.name', detail: 'formula.functionList.PROB.functionParameter.probRange.detail', - example: '{0.2,0.3,0.1,0.4}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -2165,7 +2165,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.QUARTILE_EXC.functionParameter.array.name', detail: 'formula.functionList.QUARTILE_EXC.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -2187,7 +2187,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.QUARTILE_INC.functionParameter.array.name', detail: 'formula.functionList.QUARTILE_INC.functionParameter.array.detail', - example: '{1,2,3,4}', + example: 'A1:A4', require: 1, repeat: 0, }, @@ -2267,14 +2267,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.RSQ.functionParameter.array1.name', detail: 'formula.functionList.RSQ.functionParameter.array1.detail', - example: '{6,7,9,15,21}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.RSQ.functionParameter.array2.name', detail: 'formula.functionList.RSQ.functionParameter.array2.detail', - example: '{20,28,31,38,40}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -2289,7 +2289,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.SKEW.functionParameter.number1.name', detail: 'formula.functionList.SKEW.functionParameter.number1.detail', - example: '{2,3,4;3,4,5;5,6,4}', + example: 'A1:C3', require: 1, repeat: 0, }, @@ -2311,7 +2311,7 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.SKEW_P.functionParameter.number1.name', detail: 'formula.functionList.SKEW_P.functionParameter.number1.detail', - example: '{2,3,4;3,4,5;5,6,4}', + example: 'A1:C3', require: 1, repeat: 0, }, @@ -2333,14 +2333,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.SLOPE.functionParameter.knownYs.name', detail: 'formula.functionList.SLOPE.functionParameter.knownYs.detail', - example: '{6,7,9,15,21}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.SLOPE.functionParameter.knownXs.name', detail: 'formula.functionList.SLOPE.functionParameter.knownXs.detail', - example: '{20,28,31,38,40}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -2494,14 +2494,14 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ { name: 'formula.functionList.STEYX.functionParameter.knownYs.name', detail: 'formula.functionList.STEYX.functionParameter.knownYs.detail', - example: '{6,7,9,15,21}', + example: 'A1:A4', require: 1, repeat: 0, }, { name: 'formula.functionList.STEYX.functionParameter.knownXs.name', detail: 'formula.functionList.STEYX.functionParameter.knownXs.detail', - example: '{20,28,31,38,40}', + example: 'B1:B4', require: 1, repeat: 0, }, @@ -2631,16 +2631,30 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ abstract: 'formula.functionList.T_TEST.abstract', functionParameter: [ { - name: 'formula.functionList.T_TEST.functionParameter.number1.name', - detail: 'formula.functionList.T_TEST.functionParameter.number1.detail', - example: 'A1:A20', + name: 'formula.functionList.T_TEST.functionParameter.array1.name', + detail: 'formula.functionList.T_TEST.functionParameter.array1.detail', + example: 'A1:A4', require: 1, repeat: 0, }, { - name: 'formula.functionList.T_TEST.functionParameter.number2.name', - detail: 'formula.functionList.T_TEST.functionParameter.number2.detail', - example: 'A1:A20', + name: 'formula.functionList.T_TEST.functionParameter.array2.name', + detail: 'formula.functionList.T_TEST.functionParameter.array2.detail', + example: 'B1:B4', + require: 1, + repeat: 0, + }, + { + name: 'formula.functionList.T_TEST.functionParameter.tails.name', + detail: 'formula.functionList.T_TEST.functionParameter.tails.detail', + example: '2', + require: 1, + repeat: 0, + }, + { + name: 'formula.functionList.T_TEST.functionParameter.type.name', + detail: 'formula.functionList.T_TEST.functionParameter.type.detail', + example: '1', require: 1, repeat: 0, }, @@ -2675,16 +2689,16 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ abstract: 'formula.functionList.TRIMMEAN.abstract', functionParameter: [ { - name: 'formula.functionList.TRIMMEAN.functionParameter.number1.name', - detail: 'formula.functionList.TRIMMEAN.functionParameter.number1.detail', - example: 'A1:A20', + name: 'formula.functionList.TRIMMEAN.functionParameter.array.name', + detail: 'formula.functionList.TRIMMEAN.functionParameter.array.detail', + example: 'A2:A12', require: 1, repeat: 0, }, { - name: 'formula.functionList.TRIMMEAN.functionParameter.number2.name', - detail: 'formula.functionList.TRIMMEAN.functionParameter.number2.detail', - example: 'A1:A20', + name: 'formula.functionList.TRIMMEAN.functionParameter.percent.name', + detail: 'formula.functionList.TRIMMEAN.functionParameter.percent.detail', + example: '0.2', require: 1, repeat: 0, }, @@ -2785,16 +2799,30 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ abstract: 'formula.functionList.WEIBULL_DIST.abstract', functionParameter: [ { - name: 'formula.functionList.WEIBULL_DIST.functionParameter.number1.name', - detail: 'formula.functionList.WEIBULL_DIST.functionParameter.number1.detail', - example: 'A1:A20', + name: 'formula.functionList.WEIBULL_DIST.functionParameter.x.name', + detail: 'formula.functionList.WEIBULL_DIST.functionParameter.x.detail', + example: '105', require: 1, repeat: 0, }, { - name: 'formula.functionList.WEIBULL_DIST.functionParameter.number2.name', - detail: 'formula.functionList.WEIBULL_DIST.functionParameter.number2.detail', - example: 'A1:A20', + name: 'formula.functionList.WEIBULL_DIST.functionParameter.alpha.name', + detail: 'formula.functionList.WEIBULL_DIST.functionParameter.alpha.detail', + example: '20', + require: 1, + repeat: 0, + }, + { + name: 'formula.functionList.WEIBULL_DIST.functionParameter.beta.name', + detail: 'formula.functionList.WEIBULL_DIST.functionParameter.beta.detail', + example: '100', + require: 1, + repeat: 0, + }, + { + name: 'formula.functionList.WEIBULL_DIST.functionParameter.cumulative.name', + detail: 'formula.functionList.WEIBULL_DIST.functionParameter.cumulative.detail', + example: 'true', require: 1, repeat: 0, }, @@ -2807,19 +2835,26 @@ export const FUNCTION_LIST_STATISTICAL: IFunctionInfo[] = [ abstract: 'formula.functionList.Z_TEST.abstract', functionParameter: [ { - name: 'formula.functionList.Z_TEST.functionParameter.number1.name', - detail: 'formula.functionList.Z_TEST.functionParameter.number1.detail', - example: 'A1:A20', + name: 'formula.functionList.Z_TEST.functionParameter.array.name', + detail: 'formula.functionList.Z_TEST.functionParameter.array.detail', + example: 'A2:A11', require: 1, repeat: 0, }, { - name: 'formula.functionList.Z_TEST.functionParameter.number2.name', - detail: 'formula.functionList.Z_TEST.functionParameter.number2.detail', - example: 'A1:A20', + name: 'formula.functionList.Z_TEST.functionParameter.x.name', + detail: 'formula.functionList.Z_TEST.functionParameter.x.detail', + example: '4', require: 1, repeat: 0, }, + { + name: 'formula.functionList.Z_TEST.functionParameter.sigma.name', + detail: 'formula.functionList.Z_TEST.functionParameter.sigma.detail', + example: '10', + require: 0, + repeat: 0, + }, ], }, ]; diff --git a/packages/sheets-formula/src/services/function-list/text.ts b/packages/sheets-formula/src/services/function-list/text.ts index d10c3f1f2a4e..225cdae21450 100644 --- a/packages/sheets-formula/src/services/function-list/text.ts +++ b/packages/sheets-formula/src/services/function-list/text.ts @@ -955,7 +955,7 @@ export const FUNCTION_LIST_TEXT: IFunctionInfo[] = [ { name: 'formula.functionList.TEXTSPLIT.functionParameter.text.name', detail: 'formula.functionList.TEXTSPLIT.functionParameter.text.detail', - example: '{1,2,3;4,5,6}', + example: 'A1:C2', require: 1, repeat: 0, },