⚡️ Faster ulid mapper function (#4098)

* ⚡️ Faster `ulid` mapper function

Here are some stats extracted from a benchmark:

```txt
┌─────────┬────────┬──────────────────────┬─────────────────────┬─────────────────────┐
│ (index) │  name  │         mean         │         p99         │        p999         │
├─────────┼────────┼──────────────────────┼─────────────────────┼─────────────────────┤
│    0    │ 'old'  │ 0.036524547798902726 │ 0.06470000091940165 │ 0.24509999994188547 │
│    1    │ 'new'  │ 0.02174825419917982  │ 0.04059999994933605 │ 0.24960000067949295 │
│    2    │ 'old2' │ 0.03769995739969145  │ 0.06599999964237213 │ 0.3251000000163913  │
│    3    │ 'new2' │ 0.022186629200091585 │ 0.04079999960958958 │ 0.29510000068694353 │
└─────────┴────────┴──────────────────────┴─────────────────────┴─────────────────────┘
```

Benchmark have been done using:

```js
const { Bench } = require('tinybench');
const data = [...Array(100)].map(() => Math.floor(Math.random() * 0xffffffffffff));
const bench = new Bench({ warmupIterations: 20, iterations: 1_000_000 });
bench.add('old', () => {
  for (const value of data) {
    uintToBase32StringMapperOld(value, 10);
  }
});
bench.run().then((data) => {
  console.table(data.map((e) => ({ name: e.name, mean: e.result.mean, p99: e.result.p99, p999: e.result.p999 })));
});
```

* versions

Author: dubzzz

.yarn/versions/35875d1a.yml

@@ -0,0 +1,8 @@
+releases:
+  fast-check: minor
+
+declined:
+  - "@fast-check/ava"
+  - "@fast-check/jest"
+  - "@fast-check/vitest"
+  - "@fast-check/worker"

packages/fast-check/src/arbitrary/_internals/mappers/UintToBase32String.ts

@@ -1,7 +1,5 @@
 import { Error, String } from '../../../utils/globals';
 
-const safeMathFloor = Math.floor;
-
 /** @internal */
 const encodeSymbolLookupTable: Record<number, string> = {
   10: 'A',
@@ -79,13 +77,24 @@ function pad(value: string, paddingLength: number) {
 }
 
 /** @internal */
-export function uintToBase32StringMapper(num: number, paddingLength: number): string {
+function smallUintToBase32StringMapper(num: number): string {
   let base32Str = '';
-  for (let remaining = num; remaining !== 0; remaining = safeMathFloor(remaining / 32)) {
-    const current = remaining % 32;
+  // num must be in 0 (incl.), 0x7fff_ffff (incl.)
+  // >>5 is equivalent to /32 and <<5 to x32
+  for (let remaining = num; remaining !== 0; ) {
+    const next = remaining >> 5;
+    const current = remaining - (next << 5);
     base32Str = encodeSymbol(current) + base32Str;
+    remaining = next;
   }
-  return pad(base32Str, paddingLength);
+  return base32Str;
+}
+
+/** @internal */
+export function uintToBase32StringMapper(num: number, paddingLength: number): string {
+  const head = ~~(num / 0x40000000);
+  const tail = num & 0x3fffffff;
+  return pad(smallUintToBase32StringMapper(head), paddingLength - 6) + pad(smallUintToBase32StringMapper(tail), 6);
 }
 
 /** @internal */

packages/fast-check/src/arbitrary/ulid.ts

@@ -6,6 +6,28 @@ import { paddedUintToBase32StringMapper, uintToBase32StringUnmapper } from './_i
 const padded10Mapper = paddedUintToBase32StringMapper(10);
 const padded8Mapper = paddedUintToBase32StringMapper(8);
 
+type MapperIn = [number, number, number];
+type MapperOut = string;
+
+function ulidMapper(parts: MapperIn): MapperOut {
+  return (
+    padded10Mapper(parts[0]) + // 10 chars of base32 -> 48 bits
+    padded8Mapper(parts[1]) + // 8 chars of base32 -> 40 bits
+    padded8Mapper(parts[2])
+  );
+}
+
+function ulidUnmapper(value: unknown): MapperIn {
+  if (typeof value !== 'string' || value.length !== 26) {
+    throw new Error('Unsupported type');
+  }
+  return [
+    uintToBase32StringUnmapper(value.slice(0, 10)),
+    uintToBase32StringUnmapper(value.slice(10, 18)),
+    uintToBase32StringUnmapper(value.slice(18)),
+  ];
+}
+
 /**
  * For ulid
  *
@@ -24,22 +46,7 @@ export function ulid(): Arbitrary<string> {
   const randomnessPartTwoArbitrary = integer({ min: 0, max: 0xffffffffff }); // 40 bits
 
   return tuple(timestampPartArbitrary, randomnessPartOneArbitrary, randomnessPartTwoArbitrary).map(
-    (parts) => {
-      return (
-        padded10Mapper(parts[0]) + // 10 chars of base32 -> 48 bits
-        padded8Mapper(parts[1]) + // 8 chars of base32 -> 40 bits
-        padded8Mapper(parts[2])
-      );
-    },
-    (value) => {
-      if (typeof value !== 'string' || value.length !== 26) {
-        throw new Error('Unsupported type');
-      }
-      return [
-        uintToBase32StringUnmapper(value.slice(0, 10)),
-        uintToBase32StringUnmapper(value.slice(10, 18)),
-        uintToBase32StringUnmapper(value.slice(18)),
-      ];
-    }
+    ulidMapper,
+    ulidUnmapper
   );
 }

packages/fast-check/test/unit/arbitrary/_internals/mappers/UintToBase32String.spec.ts

@@ -7,9 +7,9 @@ import {
 describe('uintToBase32StringUnmapper', () => {
   it('should be able to unmap any mapped value', () =>
     fc.assert(
-      fc.property(fc.maxSafeNat(), (input) => {
+      fc.property(fc.maxSafeNat(), fc.integer({ min: 6, max: 20 }), (input, length) => {
         // Arrange
-        const mapped = paddedUintToBase32StringMapper(12)(input);
+        const mapped = paddedUintToBase32StringMapper(length)(input);
         // Act
         const out = uintToBase32StringUnmapper(mapped);
         // Assert