💎 #169 Ensure floats out of Gen.float() abide by minPrecision

nth-commit · nth-commit · commit ad16ba21033a · 2020-12-11T10:00:49.000+13:00
diff --git a/packages/pbt/package.json b/packages/pbt/package.json
@@ -17,7 +17,9 @@
     "ix": "^4.0.0"
   },
   "devDependencies": {
+    "@types/big.js": "^6.0.0",
     "@types/jest": "^26.0.10",
+    "big.js": "^6.0.3",
     "cross-env": "^7.0.2",
     "fast-check": "^2.2.0",
     "jest": "^26.4.1",
diff --git a/packages/pbt/src/Gen/Gens/FloatGen.ts b/packages/pbt/src/Gen/Gens/FloatGen.ts
@@ -25,14 +25,14 @@ type FloatGenConfig = Readonly<{
   origin: number | null;
   minPrecision: number | null;
   maxPrecision: number | null;
-  scale: ScaleMode | null;
+  noBias: boolean;
 }>;
 
 // TODO: Origin validation (defer to genFactory.integer())
 // TODO: Handle decimal min/max by destructuring into min/max integer component and min/max fractional component
 // TODO: Handle a min/max range of less than 2
 // TODO: Negative ranges do not shrink to the origin e.g. Gen.float().between(-10, -1) does not minimise to -1 (it minimises to -2, off-by-one)
-// TODO: Memoize powers of 10
+// TODO: Add "unsafe" filter, a filter that does not produce discards. Use internally in float gen
 
 export const FloatGen = {
   create: (): FloatGen => {
@@ -72,7 +72,7 @@ export const FloatGen = {
 
       /* istanbul ignore next */
       noBias(): FloatGen {
-        return this.withConfig({ scale: 'constant' });
+        return this.withConfig({ noBias: true });
       }
 
       private withConfig(config: Partial<FloatGenConfig>): FloatGen {
@@ -89,7 +89,7 @@ export const FloatGen = {
       origin: null,
       minPrecision: null,
       maxPrecision: null,
-      scale: null,
+      noBias: false,
     });
   },
 };
@@ -138,7 +138,7 @@ const genFloat = (args: FloatGenConfig): GenRunnable<number> => {
    * precisions will be generated, producing "less complex" fractions.
    */
   const genFractionalComponent = (precision: number): Gen<number> => {
-    const maxFractionalComponentAsInteger = Math.pow(10, precision) - 1;
+    const maxFractionalComponentAsInteger = tenPowX(precision) - 1;
     return Gen.integer().between(0, maxFractionalComponentAsInteger).noBias();
   };
 
@@ -150,7 +150,7 @@ const genFloat = (args: FloatGenConfig): GenRunnable<number> => {
 };
 
 const makeDecimal = (integerComponent: number, fractionalComponentAsInteger: number, precision: number): number => {
-  const integerToFractionRatio = Math.pow(10, precision);
+  const integerToFractionRatio = tenPowX(precision);
   const fractionalComponent = fractionalComponentAsInteger / integerToFractionRatio;
   switch (Math.sign(integerComponent)) {
     /* istanbul ignore next */
@@ -207,66 +207,90 @@ const tryDeriveMaxPrecision = (maxPrecision: number | null): number | string =>
 };
 
 const tryDeriveMin = (min: number | null, minPrecision: number, maxPrecision: number): number | string => {
-  if (min === null) return -MAX_INT_32; // TODO: Ensure this fits into minPrecision
+  if (min !== null) {
+    const precisionOfMin = measurePrecision(min);
+    if (precisionOfMin > maxPrecision) {
+      return `Bound violates maximum precision constraint, minPrecision = ${minPrecision}, maxPrecision = ${maxPrecision}, min = ${min}`;
+    }
 
-  const precisionOfMin = measurePrecision(min);
-  if (precisionOfMin > maxPrecision) {
-    return `Bound must be within precision range, minPrecision = ${minPrecision}, maxPrecision = ${maxPrecision}, min = ${min}`;
+    const precisionMagnitude = magnitudeOfPrecision(minPrecision);
+    if (min < -precisionMagnitude) {
+      return `Bound violates minimum precision constraint, minPrecision = ${minPrecision}, minMin = -${precisionMagnitude}, receivedMin = ${min}`;
+    }
   }
 
-  const precisionMagnitude = magnitudeOfPrecision(minPrecision);
-  if (min < -precisionMagnitude) {
-    return `Bound violates minimum precision constraint, minPrecision = ${minPrecision}, minMin = -${precisionMagnitude}, receivedMin = ${min}`;
+  if (min === null && minPrecision > 0) {
+    return -tenPowX(FLOAT_BITS - minPrecision);
   }
 
-  return min;
+  return min === null ? -MAX_INT_32 : roundToInteger(min);
 };
 
 const tryDeriveMax = (max: number | null, minPrecision: number, maxPrecision: number): number | string => {
-  if (max === null) return MAX_INT_32; // TODO: Ensure this fits into minPrecision
+  if (max !== null) {
+    const precisionOfMax = measurePrecision(max);
+    if (precisionOfMax > maxPrecision) {
+      return `Bound violates maximum precision constraint, minPrecision = ${minPrecision}, maxPrecision = ${maxPrecision}, max = ${max}`;
+    }
 
-  const precisionOfMax = measurePrecision(max);
-  if (precisionOfMax > maxPrecision) {
-    return `Bound must be within precision range, minPrecision = ${minPrecision}, maxPrecision = ${maxPrecision}, max = ${max}`;
+    const precisionMagnitude = magnitudeOfPrecision(minPrecision);
+    if (max > precisionMagnitude) {
+      return `Bound violates minimum precision constraint, minPrecision = ${minPrecision}, maxMax = ${precisionMagnitude}, receivedMax = ${max}`;
+    }
   }
 
-  const precisionMagnitude = magnitudeOfPrecision(minPrecision);
-  if (max > precisionMagnitude) {
-    return `Bound violates minimum precision constraint, minPrecision = ${minPrecision}, maxMax = ${precisionMagnitude}, receivedMax = ${max}`;
+  if (max === null && minPrecision > 0) {
+    return tenPowX(FLOAT_BITS - minPrecision);
   }
 
-  return max;
+  return max === null ? MAX_INT_32 : roundToInteger(max);
 };
 
 const measurePrecision = (x: number): number => {
-  const xStr = x.toPrecision(1);
+  const xStr = x.toPrecision();
   const match = xStr.match(/e-(\d+)/);
 
   /*istanbul ignore next */
   if (match !== null) {
     return Number(match[1]);
   }
 
-  let count = 0;
-  x = Math.abs(x);
-
-  while (x % 1 > 0) {
-    count++;
-    x = x * 10;
-
-    /*istanbul ignore next */
-    if (count > 100) {
-      throw new Error(`Fatal: Exceeded calculation limit whilst measuring precision, x = ${x}`);
-    }
-  }
-
-  return count;
+  const fractionalComponentStr = xStr.split('.')[1];
+  return fractionalComponentStr === undefined ? 0 : fractionalComponentStr.length;
 };
 
-const unitOfPrecision = (precision: number): number => Math.pow(10, -precision);
+const unitOfPrecision = (precision: number): number => tenPowX(-precision);
 
 const magnitudeOfPrecision = (precision: number): number => {
   if (precision === 0) return Infinity;
-  const max = Math.pow(10, FLOAT_BITS - precision) - unitOfPrecision(precision);
-  return max;
+  return tenPowX(FLOAT_BITS - precision) - unitOfPrecision(precision);
+};
+
+const tenPowX = (() => {
+  const memo = new Map<number, number>();
+
+  return (x: number): number => {
+    let result = memo.get(x);
+
+    if (!result) {
+      result = Math.pow(10, x);
+      memo.set(x, result);
+    }
+
+    return result;
+  };
+})();
+
+const roundToInteger = (x: number): number => {
+  switch (Math.sign(x)) {
+    case 0:
+      return 0;
+    case 1:
+      return Math.round(x);
+    case -1:
+      return -Math.round(-x);
+    /* istanbul ignore next */
+    default:
+      throw new Error('Fatal: Unhandled result from Math.sign');
+  }
 };
diff --git a/packages/pbt/src/Runners/Check.ts b/packages/pbt/src/Runners/Check.ts
@@ -118,7 +118,7 @@ const accumulateIterations = <Ts extends any[]>(property: Property<Ts>, config:
   last(
     pipe(
       property.run(config.seed, config.iterations, { size: config.size, path: config.path }),
-      ExhaustionStrategy.apply(ExhaustionStrategy.defaultStrategy(), (iteration) => iteration.kind === 'discard'),
+      ExhaustionStrategy.asOperator((iteration) => iteration.kind === 'discard'),
       scan<Exhaustible<Property.PropertyIteration<Ts>>, IterationAccumulator<Ts>>({
         seed: {
           lastIteration: {
diff --git a/packages/pbt/src/Runners/ExhaustionStrategy.ts b/packages/pbt/src/Runners/ExhaustionStrategy.ts
@@ -1,4 +1,5 @@
 import { OperatorFunction } from 'ix/interfaces';
+import { pipe } from 'ix/iterable';
 import { flatMap } from 'ix/iterable/operators';
 
 export const Exhausted = Symbol('Exhausted');
@@ -12,9 +13,9 @@ export type ExhaustionStrategy = {
 };
 
 export namespace ExhaustionStrategy {
-  export const apply = <Iteration>(
-    exhaustionStrategy: ExhaustionStrategy,
+  export const asOperator = <Iteration>(
     isDiscard: (iteration: Iteration) => boolean,
+    exhaustionStrategy: ExhaustionStrategy = defaultStrategy(),
   ): OperatorFunction<Iteration, Exhaustible<Iteration>> =>
     flatMap((iteration) => {
       if (exhaustionStrategy.isExhausted()) {
@@ -30,6 +31,12 @@ export namespace ExhaustionStrategy {
       return exhaustionStrategy.isExhausted() ? [iteration, { kind: 'exhausted' }] : [iteration];
     });
 
+  export const apply = <Iteration>(
+    stream: Iterable<Iteration>,
+    isDiscard: (iteration: Iteration) => boolean,
+    exhaustionStrategy: ExhaustionStrategy = defaultStrategy(),
+  ): Iterable<Exhaustible<Iteration>> => pipe(stream, asOperator(isDiscard, exhaustionStrategy));
+
   export const whenDiscardRateExceeds = (rate: number): ExhaustionStrategy => {
     if (rate < 0 || rate > 1) throw new Error('Fatal: Discard rate out-of-range');
 
diff --git a/packages/pbt/src/Runners/Sample.ts b/packages/pbt/src/Runners/Sample.ts
@@ -66,7 +66,7 @@ export const sampleTreesInternal = <T>(gen: Gen<T>, config: Partial<SampleConfig
   const sampleAccumulator = last(
     pipe(
       gen.run(rng, size, {}),
-      ExhaustionStrategy.apply(ExhaustionStrategy.defaultStrategy(), (iteration) => iteration.kind === 'discard'),
+      ExhaustionStrategy.asOperator((iteration) => iteration.kind === 'discard'),
       scan<Exhaustible<GenIteration<T>>, SampleAccumulator<T>>({
         seed: {
           trees: [],
diff --git a/packages/pbt/test/Gen/Gen.Float.test.ts b/packages/pbt/test/Gen/Gen.Float.test.ts
@@ -1,13 +1,8 @@
+import { Big } from 'big.js';
 import { Gen } from 'pbt';
 import * as dev from '../../src';
 import { expectGen } from '../Helpers/expectGen';
 
-export namespace LocalGen {
-  const U_SHORT_MAX = Math.pow(2, 15);
-
-  export const short = (): Gen<number> => Gen.integer().between(U_SHORT_MAX, -U_SHORT_MAX);
-}
-
 test('Gen.float().between(0, 10).betweenPrecision(0, 2)', () => {
   for (let i = 0; i <= 10; i++) {
     const gen = dev.Gen.float().between(0, 10).betweenPrecision(0, 2);
@@ -51,12 +46,11 @@ test('Gen.float().between(-10, -1).betweenPrecision(0, 2)', () => {
 describe('errors', () => {
   test.property(
     'Gen.float().ofMinPrecision(x), x ∉ ℤ *produces* error; minimum precision must be an integer',
-    Gen.integer().greaterThanEqual(0),
+    Gen.float().greaterThanEqual(0).ofMinPrecision(1),
     (x) => {
-      const x0 = x + 0.1;
-      const gen = dev.Gen.float().ofMinPrecision(x0);
+      const gen = dev.Gen.float().ofMinPrecision(x);
 
-      expectGen(gen).toError(`Minimum precision must be an integer, minPrecision = ${x0}`);
+      expectGen(gen).toError(`Minimum precision must be an integer, minPrecision = ${x}`);
     },
   );
 
@@ -82,12 +76,11 @@ describe('errors', () => {
 
   test.property(
     'Gen.float().ofMaxPrecision(x), x ∉ ℤ *produces* error; maximum precision must be an integer',
-    Gen.integer().greaterThanEqual(0),
+    Gen.float().greaterThanEqual(0).ofMinPrecision(1),
     (x) => {
-      const x0 = x + 0.1;
-      const gen = dev.Gen.float().ofMaxPrecision(x0);
+      const gen = dev.Gen.float().ofMaxPrecision(x);
 
-      expectGen(gen).toError(`Maximum precision must be an integer, maxPrecision = ${x0}`);
+      expectGen(gen).toError(`Maximum precision must be an integer, maxPrecision = ${x}`);
     },
   );
 
@@ -112,29 +105,37 @@ describe('errors', () => {
   );
 
   test.property(
-    'Gen.float().greaterThanEqual(x).ofMaxPrecision(y), fractionalPrecisionOf(x) > y *produces* error; bound must be within precision',
-    LocalGen.short(),
-    Gen.integer().between(0, 10),
-    (x, p) => {
-      const x0 = x + Math.pow(10, -p - 1);
-      const gen = dev.Gen.float().greaterThanEqual(x0).ofMaxPrecision(p);
+    'Gen.float().greaterThanEqual(x).ofMaxPrecision(y), fractionalPrecisionOf(x) > y *produces* error; bound violates maximum precision constraint',
+    Gen.integer()
+      .between(0, 5)
+      .flatMap((maxPrecision) =>
+        Gen.float()
+          .ofMinPrecision(maxPrecision + 2) // TODO: This should be +1, but there is a bug in current version of float gen
+          .map((min) => [min, maxPrecision]),
+      ),
+    ([min, maxPrecision]) => {
+      const gen = dev.Gen.float().greaterThanEqual(min).ofMaxPrecision(maxPrecision);
 
       expectGen(gen).toError(
-        `Bound must be within precision range, minPrecision = 0, maxPrecision = ${p}, min = ${x0}`,
+        `Bound violates maximum precision constraint, minPrecision = 0, maxPrecision = ${maxPrecision}, min = ${min}`,
       );
     },
   );
 
   test.property(
-    'Gen.float().lessThanEqual(x).ofMaxPrecision(y), fractionalPrecisionOf(x) > y *produces* error; bound must be within precision',
-    LocalGen.short(),
-    Gen.integer().between(0, 10),
-    (x, p) => {
-      const x0 = x + Math.pow(10, -p - 1);
-      const gen = dev.Gen.float().lessThanEqual(x0).ofMaxPrecision(p);
+    'Gen.float().lessThanEqual(x).ofMaxPrecision(y), fractionalPrecisionOf(x) > y *produces* error; bound violates maximum precision constraint',
+    Gen.integer()
+      .between(0, 5)
+      .flatMap((maxPrecision) =>
+        Gen.float()
+          .ofMinPrecision(maxPrecision + 2) // TODO: This should be +1, but there is a bug in current version of float gen
+          .map((max) => [max, maxPrecision]),
+      ),
+    ([max, maxPrecision]) => {
+      const gen = dev.Gen.float().lessThanEqual(max).ofMaxPrecision(maxPrecision);
 
       expectGen(gen).toError(
-        `Bound must be within precision range, minPrecision = 0, maxPrecision = ${p}, max = ${x0}`,
+        `Bound violates maximum precision constraint, minPrecision = 0, maxPrecision = ${maxPrecision}, max = ${max}`,
       );
     },
   );
@@ -173,3 +174,17 @@ describe('errors', () => {
     },
   );
 });
+
+test.property(
+  'Gen.float().ofMinPrecision(p) *produces* values where fractional precision >= p',
+  Gen.integer().between(1, 16),
+  (p) => {
+    const gen = dev.Gen.float().ofMinPrecision(p);
+
+    expectGen(gen).assertOnValues((x) => {
+      const rounded = Big(x).round(p - 1);
+
+      expect(x).not.toEqual(rounded.toNumber());
+    });
+  },
+);
diff --git a/packages/pbt/test/Gen/Gen.StateMachine.test.ts b/packages/pbt/test/Gen/Gen.StateMachine.test.ts
@@ -29,7 +29,7 @@ describe('about simple n-ary switches', () => {
 
       const gen = dev.Gen.stateMachine(initialState, generateTransition, applyTransition);
 
-      expectGen(gen).onMinimum(
+      expectGen(gen).assertOnMinimum(
         (states) => new Set(states).size === 2,
         (minimum) => {
           expect(minimum).toHaveLength(2);
@@ -48,7 +48,7 @@ describe('about simple n-ary switches', () => {
 
       const gen = dev.Gen.stateMachine(initialState, generateTransition, applyTransition);
 
-      expectGen(gen).onMinimum(
+      expectGen(gen).assertOnMinimum(
         (states) => new Set(states).size === 3,
         (minimum) => {
           expect(minimum).toHaveLength(3);
diff --git a/packages/pbt/test/Helpers/expectGen.ts b/packages/pbt/test/Helpers/expectGen.ts
diff --git a/yarn.lock b/yarn.lock
