fix(number): keep decimal multipleOf floats exact and within bounds - #4162

✅ Deploy Preview for fakerjs ready!

Built without sensitive environment variables

Name	Link
🔨 Latest commit	b5dd698
🔍 Latest deploy log	https://app.netlify.com/projects/fakerjs/deploys/6ae81946a4266c282990e2aa
😎 Deploy Preview	https://deploy-preview-4162.fakerjs.dev
📱 Preview on mobile	Toggle QR Code... Use your smartphone camera to open QR code link.
🤖 Make changes	Run an agent on this branch

To edit notification comments on pull requests, go to your Netlify project configuration.

Codecov Report

❌ Patch coverage is 90.00000% with 2 lines in your changes missing coverage. Please review.
✅ Project coverage is 99.14%. Comparing base (73afc25) to head (b5dd698).

@@            Coverage Diff             @@
##             next    #4162      +/-   ##
==========================================
- Coverage   99.19%   99.14%   -0.05%     
==========================================
  Files        1184     1184              
  Lines        3953     3969      +16     
  Branches      714      718       +4     
==========================================
+ Hits         3921     3935      +14     
- Misses         28       29       +1     
- Partials        4        5       +1     

Although this handles “nice” literals like 0.3 or 1.5 with matching bounds, it isn’t a full fix, and it can regress other bounds. For example:

faker.number.float({ min: 1.1, max: 1.3, multipleOf: 0.05 })
// → [1.15, 1.2, 1.25, 1.3]  // 1.1 is now missing; it was previously reachable

String(multipleOf).split('.') also feels fragile — e.g. 1e-7 doesn’t stringify with a .

For a more general fix I’d:

• Detect when min, max, and multipleOf are finite-length decimals (i.e. not values like Math.PI or 1/3)
• Find a shared integer scale, multiply everything by it, and round
• Call faker.number.int(), then divide once

I also considered "tricking" the engine to collapse these values by itself.

E.g. by using +1-1 or /10*10

But I havent looked any deeper into this yet.

@matthewmayer you're right on both points. Reworked in f31bab0 along the lines you suggested:

• decimalPlaces() finds each value's number of decimal places numerically, as the smallest d (up to 15) with Math.round(x * 10^d) / 10^d === x, so 3e-7 gives 7 and no string parsing is involved. Math.PI and 1 / 3 have no finite form and return Infinity.
• When min, max and multipleOf are all finite decimals, they're scaled by the shared power of ten, rounded to integers, passed to number.int, and the result is divided once. Your example { min: 1.1, max: 1.3, multipleOf: 0.05 } now yields [1.1, 1.15, 1.2, 1.25, 1.3], and there's a test for it.
• 10^-n steps (and so fractionDigits), integer-only inputs and non-decimal values keep the existing path, so their output and error messages don't change.

@ST-DDT re the "+1-1" / "/10*10" idea: I think that would only round away the representation error after the fact. It wouldn't bring back a bound that ceil(min * factor) already skipped (1.1 in the example above), which scaling all three values together does.

Addressed in the latest push: shortened the scaling comment, scoped the re-throw comment to the if, restructured the result as the suggested tempInt ternary, and added a Math.PI lower-bound test ({ min: Math.PI, max: 3.3, multipleOf: 0.05 } only yields 3.15, 3.2, 3.25 or 3.3). number.spec.ts passes.

Fixed the red CI: the Lint failure was oxfmt formatting in number.spec.ts, now formatted. I also merged next to clear the conflict (kept both the new MERSENNE_MAX_VALUE upper-bound test and ours). oxfmt --check ., oxlint and number.spec.ts pass locally.

@matthewmayer I would like to have an explicit approval from you as well (human math checking), then I will approve 🙂

aside from the docs issue, this is fine.