✨ New double number arbitrary

[dubzzz]

In a nutshell

As for float in the past - see #1040, our current implementation of fc.double has many drawbacks:

• unable to generate all values
• +infinity, -infinity, NaN are not part of the possible values
• default range is limited to [0, 1[

We want to go further. When using fast-check users wants it to find bugs so by default +infinity, -infinity and NaN should be included. More generally, by default any possible double value should be included.

Due to that need we cannot keep the "generate uniformly values in range [min, max[". Now, the double implementation generate any of the possible double value in the range of acceptable values with the same probability (except when biased is toggled in which case fast-check can tweak the generator to find corner cases more quickly).

✔️ New feature
❌ Fix an issue
❌ Documentation improvement
❌ Other: please explain

(✔️: yes, ❌: no)

Potential impacts

None

[codesandbox-ci]

This pull request is automatically built and testable in CodeSandbox.

To see build info of the built libraries, click here or the icon next to each commit SHA.

Latest deployment of this branch, based on commit 3d3930d:

Sandbox	Source
Vanilla	Configuration
fast-check-examples	Configuration

[coveralls]

Coverage increased (+0.08%) to 96.581% when pulling 3d3930d on feat/double-next into a11c14b on master.

[dubzzz]

Performance measurement:

gen.array(constant) x 3,853 ops/sec ±0.13% (1089 runs sampled)
gen.array(constant).noShrink x 1,543 ops/sec ±0.30% (1082 runs sampled)

gen.string x 963 ops/sec ±0.28% (1082 runs sampled)
gen.string.noShrink x 623 ops/sec ±1.47% (1064 runs sampled)

gen.float x 1,659 ops/sec ±0.31% (1084 runs sampled)
gen.float.noShrink x 1,006 ops/sec ±0.23% (1075 runs sampled)

gen.float(manual) x 1,690 ops/sec ±0.22% (1085 runs sampled)
gen.float(manual).noShrink x 1,007 ops/sec ±0.24% (1078 runs sampled)

gen.floatNext x 1,659 ops/sec ±0.25% (1086 runs sampled)
gen.floatNext.noShrink x 995 ops/sec ±0.24% (1079 runs sampled)

gen.double x 1,447 ops/sec ±0.26% (1084 runs sampled)
gen.double.noShrink x 916 ops/sec ±0.25% (1080 runs sampled)

gen.doubleNext x 1,461 ops/sec ±0.37% (1084 runs sampled)
gen.doubleNext.noShrink x 897 ops/sec ±0.30% (1084 runs sampled)

gen.integer x 5,711 ops/sec ±0.10% (1092 runs sampled)
gen.integer.noShrink x 1,663 ops/sec ±0.24% (1080 runs sampled)

gen.bigInt x 2,462 ops/sec ±0.19% (1091 runs sampled)
gen.bigInt.noShrink x 1,144 ops/sec ±0.25% (1086 runs sampled)

gen.maxSafeInteger x 5,545 ops/sec ±0.12% (1092 runs sampled)
gen.maxSafeInteger.noShrink x 1,624 ops/sec ±0.25% (1085 runs sampled)

Benchmark code

const Benchmark = require('benchmark');
const fc = require('../lib/fast-check');

const MIN_SAMPLES = 1000;
const benchConf = { minSamples: MIN_SAMPLES };

const runner = (arb) => {
  fc.assert(fc.property(arb, () => true));
};

const manualFloat = (fc) => fc.integer(0, (1 << 24) - 1).map((v) => v / (1 << 24));
const algos = [
  { name: 'gen.array(constant)', arb: fc.array(fc.constant('a')) },
  { name: 'gen.string', arb: fc.string() },
  { name: 'gen.float', arb: fc.float() },
  { name: 'gen.float(manual)', arb: manualFloat(fc) },
  { name: 'gen.floatNext', arb: fc.float({ next: true }) },
  { name: 'gen.double', arb: fc.double() },
  { name: 'gen.doubleNext', arb: fc.double({ next: true }) },
  { name: 'gen.integer', arb: fc.integer() },
  { name: 'gen.bigInt', arb: fc.bigInt() },
  { name: 'gen.maxSafeInteger', arb: fc.maxSafeInteger() },
];

for (const a of algos) {
  Benchmark.invoke([new Benchmark(a.name, () => runner(a.arb), benchConf)], {
    name: 'run',
    queued: true,
    onCycle: (event) => console.log(String(event.target)),
  });
  Benchmark.invoke([new Benchmark(a.name + '.noShrink', () => runner(a.arb.noShrink()), benchConf)], {
    name: 'run',
    queued: true,
    onCycle: (event) => console.log(String(event.target)),
  });
}