Merge pull request #1916 from cosmos/decimal-expand-shrink

Add `Decimal.adjustFractionalDigits`

Author: webmaster128

CHANGELOG.md

@@ -14,8 +14,11 @@ and this project adheres to
   specifying the buffer type but you need an `ArrayBuffer`. Internally it might
   perform a copy but in the vast majority of cases it will just change the type
   after ensuring `ArrayBuffer` is used. ([#1883])
+- @cosmjs/math: Add `Decimal.adjustFractionalDigits` which allows you to change
+  the fractional digits of a Decimal without changing its value. ([#1916])
 
 [#1883]: https://github.com/cosmos/cosmjs/issues/1883
+[#1916]: https://github.com/cosmos/cosmjs/pull/1916
 
 ### Changed
 

packages/math/src/decimal.spec.ts

@@ -225,6 +225,64 @@ describe("Decimal", () => {
     });
   });
 
+  describe("adjustFractionalDigits", () => {
+    it("can expand", () => {
+      const a = Decimal.fromUserInput("1.23", 2);
+      const aa = a.adjustFractionalDigits(2);
+      const aaa = a.adjustFractionalDigits(3);
+      const aaaa = a.adjustFractionalDigits(4);
+      expect(aa.toString()).toEqual("1.23");
+      expect(aa.fractionalDigits).toEqual(2);
+      expect(aaa.toString()).toEqual("1.23");
+      expect(aaa.fractionalDigits).toEqual(3);
+      expect(aaaa.toString()).toEqual("1.23");
+      expect(aaaa.fractionalDigits).toEqual(4);
+    });
+
+    it("can shrink", () => {
+      const a = Decimal.fromUserInput("1.23456789", 8);
+      const a8 = a.adjustFractionalDigits(8);
+      const a7 = a.adjustFractionalDigits(7);
+      const a6 = a.adjustFractionalDigits(6);
+      const a5 = a.adjustFractionalDigits(5);
+      const a4 = a.adjustFractionalDigits(4);
+      const a3 = a.adjustFractionalDigits(3);
+      const a2 = a.adjustFractionalDigits(2);
+      const a1 = a.adjustFractionalDigits(1);
+      const a0 = a.adjustFractionalDigits(0);
+      expect(a8.toString()).toEqual("1.23456789");
+      expect(a8.fractionalDigits).toEqual(8);
+      expect(a7.toString()).toEqual("1.2345678");
+      expect(a7.fractionalDigits).toEqual(7);
+      expect(a6.toString()).toEqual("1.234567");
+      expect(a6.fractionalDigits).toEqual(6);
+      expect(a5.toString()).toEqual("1.23456");
+      expect(a5.fractionalDigits).toEqual(5);
+      expect(a4.toString()).toEqual("1.2345");
+      expect(a4.fractionalDigits).toEqual(4);
+      expect(a3.toString()).toEqual("1.234");
+      expect(a3.fractionalDigits).toEqual(3);
+      expect(a2.toString()).toEqual("1.23");
+      expect(a2.fractionalDigits).toEqual(2);
+      expect(a1.toString()).toEqual("1.2");
+      expect(a1.fractionalDigits).toEqual(1);
+      expect(a0.toString()).toEqual("1");
+      expect(a0.fractionalDigits).toEqual(0);
+    });
+
+    it("allows arithmetic between different fractional difits", () => {
+      const a = Decimal.fromUserInput("5.33", 2);
+      const b = Decimal.fromUserInput("2.1", 1);
+      expect(() => a.plus(b)).toThrowError(/Fractional digits do not match/i); // maybe not convenient but this is what we expect
+
+      const bb = b.adjustFractionalDigits(a.fractionalDigits);
+      expect(a.plus(bb).toString()).toEqual("7.43");
+
+      const aa = a.adjustFractionalDigits(b.fractionalDigits);
+      expect(aa.plus(b).toString()).toEqual("7.4");
+    });
+  });
+
   describe("toString", () => {
     it("displays no decimal point for full numbers", () => {
       expect(Decimal.fromUserInput("44", 0).toString()).toEqual("44");

packages/math/src/decimal.ts

@@ -49,14 +49,19 @@ export class Decimal {
       throw new Error("Got more fractional digits than supported");
     }
 
-    const quantity = `${whole}${fractional.padEnd(fractionalDigits, "0")}`;
+    const quantity = BigInt(`${whole}${fractional.padEnd(fractionalDigits, "0")}`);
 
     return new Decimal(quantity, fractionalDigits);
   }
 
   public static fromAtomics(atomics: string, fractionalDigits: number): Decimal {
     Decimal.verifyFractionalDigits(fractionalDigits);
-    return new Decimal(atomics, fractionalDigits);
+    if (!atomics.match(/^[0-9]+$/)) {
+      throw new Error(
+        "Invalid string format. Only non-negative integers in decimal representation supported.",
+      );
+    }
+    return new Decimal(BigInt(atomics), fractionalDigits);
   }
 
   /**
@@ -67,7 +72,7 @@ export class Decimal {
    */
   public static zero(fractionalDigits: number): Decimal {
     Decimal.verifyFractionalDigits(fractionalDigits);
-    return new Decimal("0", fractionalDigits);
+    return new Decimal(0n, fractionalDigits);
   }
 
   /**
@@ -78,7 +83,7 @@ export class Decimal {
    */
   public static one(fractionalDigits: number): Decimal {
     Decimal.verifyFractionalDigits(fractionalDigits);
-    return new Decimal("1" + "0".repeat(fractionalDigits), fractionalDigits);
+    return new Decimal(10n ** BigInt(fractionalDigits), fractionalDigits);
   }
 
   private static verifyFractionalDigits(fractionalDigits: number): void {
@@ -110,22 +115,16 @@ export class Decimal {
     readonly fractionalDigits: number;
   };
 
-  private constructor(atomics: string, fractionalDigits: number) {
-    if (!atomics.match(/^[0-9]+$/)) {
-      throw new Error(
-        "Invalid string format. Only non-negative integers in decimal representation supported.",
-      );
-    }
-
+  private constructor(atomics: bigint, fractionalDigits: number) {
     this.data = {
-      atomics: BigInt(atomics),
+      atomics: atomics,
       fractionalDigits: fractionalDigits,
     };
   }
 
   /** Creates a new instance with the same value */
   private clone(): Decimal {
-    return new Decimal(this.atomics, this.fractionalDigits);
+    return new Decimal(this.data.atomics, this.data.fractionalDigits);
   }
 
   /** Returns the greatest decimal <= this which has no fractional part (rounding down) */
@@ -137,7 +136,7 @@ export class Decimal {
     if (fractional === 0n) {
       return this.clone();
     } else {
-      return Decimal.fromAtomics((whole * factor).toString(), this.fractionalDigits);
+      return new Decimal(whole * factor, this.fractionalDigits);
     }
   }
 
@@ -150,7 +149,31 @@ export class Decimal {
     if (fractional === 0n) {
       return this.clone();
     } else {
-      return Decimal.fromAtomics(((whole + 1n) * factor).toString(), this.fractionalDigits);
+      return new Decimal((whole + 1n) * factor, this.fractionalDigits);
+    }
+  }
+
+  /**
+   * Creates a new Decimal with the same value using the new fractional digits.
+   * Roughly speaking this can expand an 3.24 to 3.24000 or shrink a 5.4321 to 5.4.
+   *
+   * This allows you to perform arithmetic operations given two decimals
+   * with different fractional digits by normalizing them.
+   *
+   * When new fractional digis is smaller than the original value, the amount
+   * is truncated (not rounded!).
+   */
+  public adjustFractionalDigits(newFractionalDigits: number): Decimal {
+    Decimal.verifyFractionalDigits(newFractionalDigits);
+    const diff = newFractionalDigits - this.fractionalDigits;
+    if (diff > 0) {
+      // expand
+      return new Decimal(this.data.atomics * 10n ** BigInt(diff), newFractionalDigits);
+    } else if (diff === 0) {
+      return this.clone();
+    } else {
+      // shrink
+      return new Decimal(this.data.atomics / 10n ** BigInt(-diff), newFractionalDigits);
     }
   }
 
@@ -186,7 +209,7 @@ export class Decimal {
   public plus(b: Decimal): Decimal {
     if (this.fractionalDigits !== b.fractionalDigits) throw new Error("Fractional digits do not match");
     const sum = this.data.atomics + b.data.atomics;
-    return new Decimal(sum.toString(), this.fractionalDigits);
+    return new Decimal(sum, this.fractionalDigits);
   }
 
   /**
@@ -199,7 +222,7 @@ export class Decimal {
     if (this.fractionalDigits !== b.fractionalDigits) throw new Error("Fractional digits do not match");
     const difference = this.data.atomics - b.data.atomics;
     if (difference < 0n) throw new Error("Difference must not be negative");
-    return new Decimal(difference.toString(), this.fractionalDigits);
+    return new Decimal(difference, this.fractionalDigits);
   }
 
   /**
@@ -209,7 +232,7 @@ export class Decimal {
    */
   public multiply(b: Uint32 | Uint53 | Uint64): Decimal {
     const product = this.data.atomics * b.toBigInt();
-    return new Decimal(product.toString(), this.fractionalDigits);
+    return new Decimal(product, this.fractionalDigits);
   }
 
   public equals(b: Decimal): boolean {