@kikuchan/decimal 0.1.0-alpha.1 → 0.1.0-alpha.3

package/package.json

@@ -6,7 +6,7 @@
     "arbitrary",
     "bigint"
   ],
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.3",
   "type": "module",
   "main": "./src/index.ts",
   "author": "kikuchan <kikuchan98@gmail.com>",

package/src/index.ts

@@ -41,10 +41,12 @@ export interface Decimal {
   splitBy(step: DecimalLike, mode?: RoundingMode): [Decimal, Decimal];
 
   // Sign and absolute
-  neg$(): this;
-  neg(): Decimal;
+  neg$(flag?: boolean): this;
+  neg(flag?: boolean): Decimal;
   abs$(): this;
   abs(): Decimal;
+  sign$(): this;
+  sign(): Decimal;
   isZero(): boolean;
   isPositive(): boolean;
   isNegative(): boolean;
@@ -405,7 +407,11 @@ class DecimalImpl implements Decimal {
   }
 
   #stripTrailingZeros$(): this {
-    if (this.digits <= 0n || this.coeff === 0n) return this;
+    if (this.coeff === 0n) {
+      this.digits = 0n;
+      return this;
+    }
+    if (this.digits <= 0n) return this;
     while (this.digits > 0n && this.coeff % 10n === 0n) {
       this.coeff /= 10n;
       this.digits -= 1n;
@@ -519,13 +525,15 @@ class DecimalImpl implements Decimal {
     return this.clone().splitBy$(step, mode);
   }
 
-  neg$(): this {
-    this.coeff = -this.coeff;
+  neg$(flag?: boolean): this {
+    if (flag !== false) {
+      this.coeff = -this.coeff;
+    }
     return this;
   }
 
-  neg(): DecimalImpl {
-    return this.clone().neg$();
+  neg(flag?: boolean): DecimalImpl {
+    return this.clone().neg$(flag);
   }
 
   isZero(): boolean {
@@ -864,6 +872,17 @@ class DecimalImpl implements Decimal {
     return this.clone().log$(base, digits);
   }
 
+  sign$() {
+    if (this.isZero()) return this;
+    this.coeff = this.coeff < 0n ? -1n : 1n;
+    this.digits = 0n;
+    return this;
+  }
+
+  sign() {
+    return this.clone().sign$();
+  }
+
   order(): bigint {
     if (this.isZero()) throw new RangeError('order undefined for 0');
     return BigInt(abs(this.coeff).toString().length) - 1n - this.digits;
@@ -986,7 +1005,6 @@ export namespace Decimal {
     return minmax(...values)[0];
   }
 
-  /* c8 ignore next */
   export function max(...values: (DecimalLike | null | undefined)[]): Decimal | null {
     return minmax(...values)[1];
   }

package/tests/decimal.spec.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import type { RoundingMode } from '../src/index.ts';
 import { Decimal, isDecimal, max, min, minmax, pow10 } from '../src/index.ts';
 
@@ -32,6 +32,11 @@ describe('Decimal construction', () => {
     expect(value.digits).toBe(5n);
   });
 
+  it('returns existing decimal instances unchanged', () => {
+    const value = Decimal(42);
+    expect(Decimal(value)).toBe(value);
+  });
+
   it('returns nullish inputs unchanged', () => {
     expect(Decimal(null)).toBeNull();
     expect(Decimal(undefined)).toBeUndefined();
@@ -261,6 +266,12 @@ describe('Decimal transforms', () => {
 });
 
 describe('Decimal type guards', () => {
+  it('detects decimals using isDecimal', () => {
+    const value = Decimal(7);
+    expect(Decimal.isDecimal(value)).toBe(true);
+    expect(Decimal.isDecimal(7)).toBe(false);
+  });
+
   it('recognizes supported literal inputs', () => {
     expect(Decimal.isDecimalLike('42.00')).toBe(true);
     expect(Decimal.isDecimalLike(42)).toBe(true);
@@ -367,6 +378,32 @@ describe('Decimal sign helpers', () => {
     expect(negative.isPositive()).toBe(false);
     expect(negative.isNegative()).toBe(true);
   });
+
+  describe('sign', () => {
+    it('returns a 0', () => {
+      const value = Decimal(0);
+      expect(value.sign().toString()).toBe('0');
+    });
+    it('returns a -1', () => {
+      const value = Decimal(-1.987);
+      expect(value.sign().toString()).toBe('-1');
+    });
+    it('returns a 1', () => {
+      const value = Decimal(1.987);
+      expect(value.sign().toString()).toBe('1');
+    });
+  });
+
+  describe('neg', () => {
+    it('returns negated value', () => {
+      const value = Decimal(1.987);
+      expect(value.neg(true).toString()).toBe('-1.987');
+    });
+    it('returns original value', () => {
+      const value = Decimal(1.987);
+      expect(value.neg(false).toString()).toBe('1.987');
+    });
+  });
 });
 
 describe('Decimal truncation', () => {
@@ -647,6 +684,14 @@ describe('Decimal roots', () => {
     expect(root.toString()).toBe('-3.00000000');
   });
 
+  it('uses floating approximations for moderate roots', () => {
+    const powSpy = vi.spyOn(Math, 'pow');
+    const root = Decimal(256).root(4n, 6n);
+    expect(powSpy).toHaveBeenCalled();
+    expect(root.eq(Decimal(4))).toBe(true);
+    powSpy.mockRestore();
+  });
+
   it('throws on even roots of negative numbers', () => {
     expect(() => Decimal(-16).root(2n, 8n)).toThrowError();
   });
@@ -714,6 +759,46 @@ describe('Decimal roots', () => {
     const tolerance = pow10(-(digits - 4n));
     expect(recomposed.isCloseTo(value.rescale(digits), tolerance)).toBe(true);
   });
+
+  it('falls back to order-based estimates when floating guesses overflow', () => {
+    const powSpy = vi.spyOn(Math, 'pow');
+    const huge = Decimal({ coeff: 1n, digits: -5000n });
+    const root = huge.root(2n, 4n);
+    expect(powSpy).not.toHaveBeenCalled();
+    expect(root.digits).toBe(4n);
+    powSpy.mockRestore();
+  });
+
+  it('recovers when floating approximation yields a non-finite guess', () => {
+    const powSpy = vi.spyOn(Math, 'pow').mockReturnValueOnce(Number.NaN);
+    const root = Decimal(64).root(3n, 8n);
+    expect(powSpy).toHaveBeenCalled();
+    expect(root.eq(Decimal(4))).toBe(true);
+    powSpy.mockRestore();
+  });
+
+  it('treats non-positive numeric degree hints as fallbacks while keeping bigint logic', () => {
+    const originalNumber = Number;
+    const targetDegree = 2n;
+    const mockNumber = function (value: unknown) {
+      if (value === targetDegree) return 0;
+      return originalNumber(value as never);
+    } as NumberConstructor;
+    for (const key of Object.getOwnPropertyNames(originalNumber)) {
+      const descriptor = Object.getOwnPropertyDescriptor(originalNumber, key);
+      if (descriptor) {
+        Object.defineProperty(mockNumber, key, descriptor);
+      }
+    }
+
+    (globalThis as { Number: NumberConstructor }).Number = mockNumber;
+    try {
+      const root = Decimal(16).root(targetDegree, 6n);
+      expect(root.eq(Decimal(4))).toBe(true);
+    } finally {
+      (globalThis as { Number: NumberConstructor }).Number = originalNumber;
+    }
+  });
 });
 
 describe('Decimal modular helpers', () => {
@@ -726,6 +811,11 @@ describe('Decimal modular helpers', () => {
     expect(Decimal(-17).modPositive(5).toString()).toBe(Decimal(3).toString());
   });
 
+  it('leaves positive remainders unchanged in modPositive', () => {
+    const result = Decimal(17).modPositive(5);
+    expect(result.toString()).toBe(Decimal(2).toString());
+  });
+
   it('rejects negative divisors for positive modulo', () => {
     expect(() => Decimal(1).modPositive(-5)).toThrow('Modulo divisor must be positive');
   });
@@ -1096,11 +1186,18 @@ describe('Decimal boundaries', () => {
     expect(clamped.eq(original)).toBe(true);
   });
 
-  it('rescale preserves explicit zero scales without stripping digits', () => {
+  it('compresses zero to standard form with rescale', () => {
     const value = Decimal({ coeff: 0n, digits: 5n });
     const compressed = value.rescale();
-    expect(compressed.digits).toBe(5n);
-    expect(compressed.toString()).toBe('0.00000');
+    expect(compressed.digits).toBe(0n);
+    expect(compressed.toString()).toBe('0');
+  });
+
+  it('compresses zero with negative exponent to standard form with rescale', () => {
+    const value = Decimal({ coeff: 0n, digits: -5n });
+    const compressed = value.rescale();
+    expect(compressed.digits).toBe(0n);
+    expect(compressed.toString()).toBe('0');
   });
 });