✨ Support excluded min/max in float (#4105)

* ✨ Support excluded min/max in `float`

Up-to-now, it was not possible to ask for float  between min and max with either min or max or both not in the range.

Following the request #4046, we thought about it and started to offer ways to do so.

* versions

* restrictsome tests

Author: dubzzz

.yarn/versions/9cf55ded.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/float.ts

@@ -21,12 +21,26 @@ export interface FloatConstraints {
    * @remarks Since 2.8.0
    */
   min?: number;
+  /**
+   * Should the lower bound (aka min) be excluded?
+   * Note: Excluding min=Number.NEGATIVE_INFINITY would result into having min set to -3.4028234663852886e+38.
+   * @defaultValue false
+   * @remarks Since 3.12.0
+   */
+  minExcluded?: boolean;
   /**
    * Upper bound for the generated 32-bit floats (included)
    * @defaultValue Number.POSITIVE_INFINITY, 3.4028234663852886e+38 when noDefaultInfinity is true
    * @remarks Since 2.8.0
    */
   max?: number;
+  /**
+   * Should the upper bound (aka max) be excluded?
+   * Note: Excluding max=Number.POSITIVE_INFINITY would result into having max set to 3.4028234663852886e+38.
+   * @defaultValue false
+   * @remarks Since 3.12.0
+   */
+  maxExcluded?: boolean;
   /**
    * By default, lower and upper bounds are -infinity and +infinity.
    * By setting noDefaultInfinity to true, you move those defaults to minimal and maximal finite values.
@@ -82,11 +96,15 @@ export function float(constraints: FloatConstraints = {}): Arbitrary<number> {
   const {
     noDefaultInfinity = false,
     noNaN = false,
+    minExcluded = false,
+    maxExcluded = false,
     min = noDefaultInfinity ? -MAX_VALUE_32 : safeNegativeInfinity,
     max = noDefaultInfinity ? MAX_VALUE_32 : safePositiveInfinity,
   } = constraints;
-  const minIndex = safeFloatToIndex(min, 'min');
-  const maxIndex = safeFloatToIndex(max, 'max');
+  const minIndexRaw = safeFloatToIndex(min, 'min');
+  const minIndex = minExcluded ? minIndexRaw + 1 : minIndexRaw;
+  const maxIndexRaw = safeFloatToIndex(max, 'max');
+  const maxIndex = maxExcluded ? maxIndexRaw - 1 : maxIndexRaw;
   if (minIndex > maxIndex) {
     // Comparing min and max might be problematic in case min=+0 and max=-0
     // For that reason, we prefer to compare computed index to be safer

packages/fast-check/test/unit/arbitrary/float.spec.ts

@@ -80,6 +80,32 @@ describe('float', () => {
     );
   });
 
+  it('should reject any constraints defining min (not-NaN) equal to max if one is exclusive', () => {
+    fc.assert(
+      fc.property(
+        float32raw(),
+        fc.record({ noDefaultInfinity: fc.boolean(), noNaN: fc.boolean() }, { withDeletedKeys: true }),
+        fc.constantFrom('min', 'max', 'both'),
+        (f, otherCt, exclusiveMode) => {
+          // Arrange
+          fc.pre(isNotNaN32bits(f));
+          spyInteger();
+
+          // Act / Assert
+          expect(() =>
+            float({
+              ...otherCt,
+              min: f,
+              max: f,
+              minExcluded: exclusiveMode === 'min' || exclusiveMode === 'both',
+              maxExcluded: exclusiveMode === 'max' || exclusiveMode === 'both',
+            })
+          ).toThrowError();
+        }
+      )
+    );
+  });
+
   it('should reject non-32-bit or NaN floating point numbers if specified for min', () => {
     fc.assert(
       fc.property(float64raw(), (f64) => {
@@ -136,10 +162,16 @@ describe('float', () => {
     expect(integer).not.toHaveBeenCalled();
   });
 
-  it('should properly convert integer value for index between min and max into its associated float value', () =>
+  it('should properly convert integer value for index between min and max into its associated float value', () => {
+    const withoutExcludedConstraints = {
+      ...defaultFloatRecordConstraints,
+      minExcluded: fc.constant(false),
+      maxExcluded: fc.constant(false),
+    };
+
     fc.assert(
       fc.property(
-        fc.option(floatConstraints(), { nil: undefined }),
+        fc.option(floatConstraints(withoutExcludedConstraints), { nil: undefined }),
         fc.maxSafeNat(),
         fc.option(fc.integer({ min: 2 }), { nil: undefined }),
         (ct, mod, biasFactor) => {
@@ -159,7 +191,8 @@ describe('float', () => {
           expect(f).toBe(indexToFloat(arbitraryGeneratedIndex));
         }
       )
-    ));
+    );
+  });
 
   describe('with NaN', () => {
     const withNaNRecordConstraints = { ...defaultFloatRecordConstraints, noNaN: fc.constant(false) };
@@ -236,13 +269,15 @@ describe('float', () => {
           const { min, max } = minMaxForConstraints(ct);
           const minIndex = floatToIndex(min);
           const maxIndex = floatToIndex(max);
+          const expectedMinIndex = ct.minExcluded ? minIndex + 1 : minIndex;
+          const expectedMaxIndex = ct.maxExcluded ? maxIndex - 1 : maxIndex;
 
           // Act
           float(ct);
 
           // Assert
           expect(integer).toHaveBeenCalledTimes(1);
-          expect(integer).toHaveBeenCalledWith({ min: minIndex, max: maxIndex });
+          expect(integer).toHaveBeenCalledWith({ min: expectedMinIndex, max: expectedMaxIndex });
         })
       );
     });

website/docs/core-blocks/arbitraries/primitives/number.md

@@ -136,6 +136,8 @@ It always generates valid 32-bit floating point values.
 
 - `min?` — default: `-∞` and `-3.4028234663852886e+38` when `noDefaultInfinity:true` — _lower bound for the generated 32-bit floats (included)_
 - `max?` — default: `+∞` and `+3.4028234663852886e+38` when `noDefaultInfinity:true` — _upper bound for the generated 32-bit floats (included)_
+- `minExcluded?` — default: `false` — _do not include `min` in the set of possible values_
+- `maxExcluded?` — default: `false` — _do not include `max` in the set of possible values_
 - `noDefaultInfinity?` — default: `false` — _use finite values for `min` and `max` by default_
 - `noNaN?` — default: `false` — _do not generate `Number.NaN`_
 
@@ -159,6 +161,10 @@ fc.float({ noDefaultInfinity: true, min: Number.NEGATIVE_INTEGER, max: Number.PO
 // should not be set to -∞ and +∞. It does not forbid the user to explicitely set them to -∞ and +∞.
 // Examples of generated values: -5.435122013092041, 1981086548623360, -2.2481372319305137e-9, -2.5223372357846707e-44, 5.606418179297701e-30…
 
+fc.float({ min: 0, max: 1, maxExcluded: true });
+// Note: All possible 32-bit floating point values between 0 (included) and 1 (excluded)
+// Examples of generated values: 3.2229864679470793e-44, 2.4012229232976108e-20, 1.1826533935374394e-27, 0.9999997615814209, 3.783505853677006e-44…
+
 fc.integer({ min: 0, max: (1 << 24) - 1 })
   .map((v) => v / (1 << 24))
   .noBias();