fix: decimal javascript calculation

package.json

@@ -100,6 +100,7 @@
     "c8": "~7.11.0",
     "conventional-changelog-cli": "~2.2.2",
     "cypress": "~9.5.0",
+    "decimal.js": "^10.3.1",
     "esbuild": "~0.14.23",
     "eslint": "~8.9.0",
     "eslint-config-prettier": "~8.4.0",

src/datatype.ts

@@ -1,15 +1,16 @@
 import type { Faker } from '.';
+import Decimal from 'decimal.js';
 
 /**
  * Module to generate various primitive values and data types.
  */
 export class Datatype {
-  constructor(private readonly faker: Faker, seed?: any[] | any) {
+  constructor(private readonly faker: Faker, seed?: number[] | number) {
     // Use a user provided seed if it is an array or number
     if (Array.isArray(seed) && seed.length) {
       this.faker.mersenne.seed_array(seed);
-    } else if (!isNaN(seed)) {
-      this.faker.mersenne.seed(seed);
+    } else if (!isNaN(seed as number)) {
+      this.faker.mersenne.seed(seed as number);
     }
 
     // Bind `this` so namespaced is working correctly
@@ -72,7 +73,10 @@ export class Datatype {
       )
     );
     // Workaround problem in Float point arithmetics for e.g. 6681493 / 0.01
-    randomNumber = randomNumber / (1 / options.precision);
+    const decimalPrecision = new Decimal(1)
+      .dividedBy(options?.precision)
+      .toNumber();
+    randomNumber = randomNumber / decimalPrecision;
 
     return randomNumber;
   }
@@ -275,7 +279,7 @@ export class Datatype {
         ? this.faker.datatype.string()
         : this.faker.datatype.number();
     }
-    return returnArray;
+    return returnArray as (string | number)[];
   }
 
   /**

test/datatype.spec.ts

@@ -12,6 +12,8 @@ const seededRuns = [
         withMinAndMax: -1,
         withMax: 26,
         withMinAndMaxAndPrecision: -0.43,
+        withMinAndMaxAndPrecision5: -0.42605,
+        withMinAndMaxAndPrecision9: -0.426047312,
       },
       float: {
         noArgs: 37453.64,
@@ -20,6 +22,8 @@ const seededRuns = [
         withMinAndMax: -0.43,
         withMax: 25.84,
         withMinAndMaxAndPrecision: -0.4261,
+        withMinAndMaxAndPrecision5: -0.42605,
+        withMinAndMaxAndPrecision9: -0.426047312,
       },
       datetime: {
         // TODO @Shinigami92 2022-01-29: We will fix the deterministic in #343
@@ -81,6 +85,8 @@ const seededRuns = [
         withMinAndMax: -13,
         withMax: 18,
         withMinAndMaxAndPrecision: -12.92,
+        withMinAndMaxAndPrecision5: -12.91526,
+        withMinAndMaxAndPrecision9: -12.915260943,
       },
       float: {
         noArgs: 26202.2,
@@ -89,6 +95,8 @@ const seededRuns = [
         withMinAndMax: -12.92,
         withMax: 18.08,
         withMinAndMaxAndPrecision: -12.9153,
+        withMinAndMaxAndPrecision5: -12.91526,
+        withMinAndMaxAndPrecision9: -12.915260943,
       },
       datetime: {
         // TODO @Shinigami92 2022-01-29: We will fix the deterministic in #343
@@ -150,6 +158,8 @@ const seededRuns = [
         withMinAndMax: 61,
         withMax: 64,
         withMinAndMaxAndPrecision: 61.07,
+        withMinAndMaxAndPrecision5: 61.06574,
+        withMinAndMaxAndPrecision9: 61.065737066,
       },
       float: {
         noArgs: 92851.09,
@@ -158,6 +168,8 @@ const seededRuns = [
         withMinAndMax: 61.07,
         withMax: 64.07,
         withMinAndMaxAndPrecision: 61.0658,
+        withMinAndMaxAndPrecision5: 61.06574,
+        withMinAndMaxAndPrecision9: 61.065737066,
       },
       datetime: {
         // TODO @Shinigami92 2022-01-29: We will fix the deterministic in #343
@@ -290,6 +302,32 @@ describe('datatype', () => {
           });
           expect(actual).toEqual(expectations.number.withMinAndMaxAndPrecision);
         });
+
+        it('should return a deterministic value for given min, max and precision of 0.00001', () => {
+          faker.seed(seed);
+
+          const actual = faker.datatype.number({
+            min: -42,
+            max: 69,
+            precision: 0.00001,
+          });
+          expect(actual).toEqual(
+            expectations.number.withMinAndMaxAndPrecision5
+          );
+        });
+
+        it('should return a deterministic value for given min, max and precision of 0.000000001', () => {
+          faker.seed(seed);
+
+          const actual = faker.datatype.number({
+            min: -42,
+            max: 69,
+            precision: 0.000000001,
+          });
+          expect(actual).toEqual(
+            expectations.number.withMinAndMaxAndPrecision9
+          );
+        });
       });
 
       describe('float', () => {
@@ -469,6 +507,16 @@ describe('datatype', () => {
           expect(number).toBe(Number(number.toFixed(3)));
         });
 
+        it('should return a random float given a precision value of 0.00001', () => {
+          const number = faker.datatype.float(0.00001);
+          expect(number).toBe(Number(number.toFixed(5)));
+        });
+
+        it('should return a random float given a precision value of 0.000000001', () => {
+          const number = faker.datatype.float(0.000000001);
+          expect(number).toBe(Number(number.toFixed(9)));
+        });
+
         it('should return a random number given a maximum value as Object', () => {
           const options = { max: 10 };
           expect(faker.datatype.float(options)).greaterThanOrEqual(0);