Skip to content

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

fix(formula): format complex numbers like Excel (#8172)

wpxp123456d02a235fc46e
diff --git a/packages/engine-formula/src/basics/__tests__/complex.spec.ts b/packages/engine-formula/src/basics/__tests__/complex.spec.ts
index 2639cbfe03..5aee0ac773 100644
--- a/packages/engine-formula/src/basics/__tests__/complex.spec.ts
+++ b/packages/engine-formula/src/basics/__tests__/complex.spec.ts
@@ -47,4 +47,34 @@ describe('Test complex', () => {
expect(new Complex('1+2-3i').isError()).toBe(true);
expect(new Complex('1-2+3i').isError()).toBe(true);
});
+
+ it('Writes tiny numbers in plain decimal notation', () => {
+ expect(Complex.getComplex(1e-7, -1, 'i')).toBe('0.0000001-i');
+ expect(Complex.getComplex(1e-7, 1, 'i')).toBe('0.0000001+i');
+ });
+
+ it('Rounds to 15 significant digits', () => {
+ expect(Complex.getComplex(2 / 3, 1, 'i')).toBe('0.666666666666667+i');
+ expect(Complex.getComplex(0.1 + 0.2, 1, 'i')).toBe('0.3+i');
+ });
+
+ it('Omits the coefficient of a unit imaginary part', () => {
+ expect(Complex.getComplex(0, 1, 'i')).toBe('i');
+ expect(Complex.getComplex(0, -1, 'i')).toBe('-i');
+ expect(Complex.getComplex(1, -1, 'i')).toBe('1-i');
+ expect(Complex.getComplex(1, 1, 'i')).toBe('1+i');
+ });
+
+ it('Keeps plain notation while it fits in 21 characters', () => {
+ expect(Complex.getComplex(1e-19, 1, 'i')).toBe('0.0000000000000000001+i');
+ expect(Complex.getComplex(1e20, 1, 'i')).toBe('100000000000000000000+i');
+ expect(Complex.getComplex(0.0000123456789012345, 1, 'i')).toBe('0.0000123456789012345+i');
+ });
+
+ it('Falls back to scientific notation past that width', () => {
+ expect(Complex.getComplex(1e-20, 1, 'i')).toBe('1E-20+i');
+ expect(Complex.getComplex(1.5e-19, 1, 'i')).toBe('1.5E-19+i');
+ expect(Complex.getComplex(0.00000123456789012345, 1, 'i')).toBe('1.23456789012345E-06+i');
+ expect(Complex.getComplex(1e21, 1, 'i')).toBe('1E+21+i');
+ });
});
diff --git a/packages/engine-formula/src/basics/complex.ts b/packages/engine-formula/src/basics/complex.ts
index 2875fe242c..8198a7a8b4 100644
--- a/packages/engine-formula/src/basics/complex.ts
+++ b/packages/engine-formula/src/basics/complex.ts
@@ -37,24 +37,74 @@ function findSignIndex(inumberStr: string, sign: '+' | '-'): number {
return -1;
}
+/**
+ * Excel prints the parts of a complex number with at most 15 significant
+ * digits and keeps plain decimal notation while the text fits in 21
+ * characters, e.g. `0.0000001` and `100000000000000000000`. Longer values fall
+ * back to scientific notation such as `1.23456789012345E-06`.
+ *
+ * The whole conversion stays inside Decimal so the rounded value is never
+ * turned into a double and formatted again, which can round a second time.
+ */
+const MAX_FIXED_LENGTH = 21;
+
+function formatComplexNumber(value: Decimal): string {
+ if (!value.isFinite()) {
+ return value.toString();
+ }
+
+ if (value.isZero()) {
+ return '0';
+ }
+
+ const sign = value.isNegative() ? '-' : '';
+ const abs = value.abs().toSignificantDigits(15, Decimal.ROUND_HALF_UP);
+ const fixed = abs.toFixed();
+
+ if (fixed.length <= MAX_FIXED_LENGTH) {
+ return `${sign}${fixed}`;
+ }
+
+ const [mantissa, exponent] = abs.toExponential().split('e');
+ const power = Number(exponent);
+ const exponentText = `${power < 0 ? '-' : '+'}${Math.abs(power).toString().padStart(2, '0')}`;
+
+ return `${sign}${mantissa}E${exponentText}`;
+}
+
+/**
+ * Formats the imaginary part. Excel omits the coefficient of the unit, so `1`
+ * and `-1` render as `i` and `-i`.
+ */
+function formatImaginaryNumber(iValue: Decimal, suffix: string): string {
+ if (iValue.eq(1)) {
+ return suffix;
+ }
+
+ if (iValue.eq(-1)) {
+ return `-${suffix}`;
+ }
+
+ return `${formatComplexNumber(iValue)}${suffix}`;
+}
+
export class Complex {
static getComplex(realNum: number, iNum: number, suffix: string): number | string {
- const _realNum = new Decimal(realNum).toSignificantDigits(15).toNumber();
- const _iNum = new Decimal(iNum).toSignificantDigits(15).toNumber();
+ const realValue = new Decimal(realNum).toSignificantDigits(15, Decimal.ROUND_HALF_UP);
+ const iValue = new Decimal(iNum).toSignificantDigits(15, Decimal.ROUND_HALF_UP);
const _suffix = suffix === '' ? 'i' : suffix;
let result: number | string;
- if (_realNum === 0 && _iNum === 0) {
+ if (realValue.isZero() && iValue.isZero()) {
result = 0;
- } else if (_realNum === 0) {
- result = _iNum === 1 ? _suffix : `${_iNum}${_suffix}`;
- } else if (_iNum === 0) {
- result = _realNum;
+ } else if (realValue.isZero()) {
+ result = formatImaginaryNumber(iValue, _suffix);
+ } else if (iValue.isZero()) {
+ result = realValue.toNumber();
} else {
- const sign = _iNum > 0 ? '+' : '';
- const suffixStr = _iNum === 1 ? _suffix : `${_iNum}${_suffix}`;
- result = `${_realNum}${sign}${suffixStr}`;
+ const sign = iValue.gt(0) ? '+' : '';
+ result = `${formatComplexNumber(realValue)}${sign}${formatImaginaryNumber(iValue, _suffix)}`;
}
return result;
@@ -388,9 +438,11 @@ export class Complex {
}
Ln(): number | string {
- const abs = Decimal.sqrt(Decimal.pow(this._realNum, 2).add(Decimal.pow(this._iNum, 2)));
- const realNum = Decimal.ln(abs).toNumber();
- const iNum = Decimal.acos(new Decimal(this._realNum).div(abs)).toNumber();
+ // Keep the real part and the argument in double precision so the
+ // result matches Excel, including ln|z| when |z| is close to 1.
+ // atan2 also carries the sign of the imaginary part.
+ const realNum = Math.log(Math.hypot(this._realNum, this._iNum));
+ const iNum = Math.atan2(this._iNum, this._realNum);
return Complex.getComplex(realNum, iNum, this._suffix);
}
diff --git a/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts
index 08ffdf8d60..4d4df642e6 100644
--- a/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/complex/__tests__/index.spec.ts
@@ -38,6 +38,14 @@ describe('Test complex function', () => {
expect(result2.getValue()).toBe(3);
});
+ it('Formats a tiny real part like Excel', () => {
+ const realNum = NumberValueObject.create(1e-7);
+ const iNum = NumberValueObject.create(-1);
+ const suffix = StringValueObject.create('i');
+ const result = testFunction.calculate(realNum, iNum, suffix);
+ expect(result.getValue()).toBe('0.0000001-i');
+ });
+
it('Value is number string', () => {
const realNum = StringValueObject.create('-0.5');
const iNum = NumberValueObject.create(4);
diff --git a/packages/engine-formula/src/functions/engineering/imcot/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imcot/__tests__/index.spec.ts
index 4f48b1f606..185997dbe4 100644
--- a/packages/engine-formula/src/functions/engineering/imcot/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/imcot/__tests__/index.spec.ts
@@ -29,7 +29,7 @@ describe('Test imcot function', () => {
it('Value is normal number', () => {
const inumber = StringValueObject.create('5+12i');
const result = testFunction.calculate(inumber);
- expect(result.getValue()).toBe('-4.10750577681088e-11-0.999999999936648i');
+ expect(result.getValue()).toBe('-4.10750577681088E-11-0.999999999936648i');
});
it('Value is large numbers', () => {
diff --git a/packages/engine-formula/src/functions/engineering/imcsc/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imcsc/__tests__/index.spec.ts
index 9907c8876c..e5e7ac5b34 100644
--- a/packages/engine-formula/src/functions/engineering/imcsc/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/imcsc/__tests__/index.spec.ts
@@ -29,7 +29,7 @@ describe('Test imcsc function', () => {
it('Value is normal number', () => {
const inumber = StringValueObject.create('5+12i');
const result = testFunction.calculate(inumber);
- expect(result.getValue()).toBe('-0.0000117836687482814-0.00000348576140783804i');
+ expect(result.getValue()).toBe('-0.0000117836687482814-3.48576140783804E-06i');
});
it('Value is large numbers', () => {
diff --git a/packages/engine-formula/src/functions/engineering/imln/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imln/__tests__/index.spec.ts
index dcc89c8301..3438d40994 100644
--- a/packages/engine-formula/src/functions/engineering/imln/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/imln/__tests__/index.spec.ts
@@ -32,6 +32,18 @@ describe('Test imln function', () => {
expect(result.getValue()).toBe('2.56494935746154+1.17600520709514i');
});
+ it('Value has a negative imaginary part', () => {
+ const inumber = StringValueObject.create('5-12i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('2.56494935746154-1.17600520709514i');
+ });
+
+ it('Value has a tiny real part', () => {
+ const inumber = StringValueObject.create('0.0000001-i');
+ const result = testFunction.calculate(inumber);
+ expect(result.getValue()).toBe('4.88498130835068E-15-1.5707962267949i');
+ });
+
it('Value is large numbers', () => {
const inumber = NumberValueObject.create(25698432);
const result = testFunction.calculate(inumber);
diff --git a/packages/engine-formula/src/functions/engineering/imsec/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imsec/__tests__/index.spec.ts
index 457133a88e..4e87a0fc01 100644
--- a/packages/engine-formula/src/functions/engineering/imsec/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/imsec/__tests__/index.spec.ts
@@ -29,7 +29,7 @@ describe('Test imsec function', () => {
it('Value is normal number', () => {
const inumber = StringValueObject.create('5+12i');
const result = testFunction.calculate(inumber);
- expect(result.getValue()).toBe('0.00000348576140854289-0.0000117836687488848i');
+ expect(result.getValue()).toBe('3.48576140854289E-06-0.0000117836687488848i');
});
it('Value is large numbers', () => {
diff --git a/packages/engine-formula/src/functions/engineering/imtan/__tests__/index.spec.ts b/packages/engine-formula/src/functions/engineering/imtan/__tests__/index.spec.ts
index e8b89cc2d9..c082be9821 100644
--- a/packages/engine-formula/src/functions/engineering/imtan/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/engineering/imtan/__tests__/index.spec.ts
@@ -29,7 +29,7 @@ describe('Test imtan function', () => {
it('Value is normal number', () => {
const inumber = StringValueObject.create('5+12i');
const result = testFunction.calculate(inumber);
- expect(result.getValue()).toBe('-4.10750577733132e-11+1.00000000006335i');
+ expect(result.getValue()).toBe('-4.10750577733132E-11+1.00000000006335i');
});
it('Value is large numbers', () => {