Merge 8276e03 into master

CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.7.1
+
+- fixed: `nextInt` results for `max >= 0x80000000` were not uniformly distributed
+- narrowed the range of possible `max` values for `Drandom`
+
 # 0.7.0+1
 
 - Added Xoshiro256**

lib/src/21_base32.dart

@@ -70,23 +70,30 @@ abstract class RandomBase32 implements Random {
         : combineUpper53bitsJS(nextRaw32(), nextRaw32());
   }
 
+  static final int _POW2_32 = 4294967296; // it's (1 << 32). For JS it's safer to set a constant
+
   /// Generates a non-negative random integer uniformly distributed in
   /// the range from 0, inclusive, to [max], exclusive.
-  ///
-  /// To make the distribution uniform, we use the so-called
-  /// [Debiased Modulo Once - Java Method](https://git.io/Jm0D7).
-  ///
-  /// This implementation is slightly faster than the standard one for
-  /// all [max] values, except for [max], which are powers of two.
   @override
   int nextInt(int max) {
-    if (max < 1 || max > 0xFFFFFFFF) {
-      throw RangeError.range(max, 1, 0xFFFFFFFF);
+    // almost the same as https://bit.ly/35OH1Vh
+
+    if (max <= 0 || max > _POW2_32) {
+      throw RangeError.range(
+          max, 1, _POW2_32, 'max', 'Must be positive and <= 2^32');
     }
-    int r = nextRaw32();
-    int m = max - 1;
-    for (int u = r; u - (r = u % max) + m < 0; u = nextRaw32()) {}
-    return r;
+    if ((max & -max) == max) {
+      // Fast case for powers of two.
+      return nextRaw32() & (max - 1);
+    }
+
+    int rnd32;
+    int result;
+    do {
+      rnd32 = nextRaw32();
+      result = rnd32 % max;
+    } while ((rnd32 - result + max) > _POW2_32);
+    return result;
   }
 
   /// Generates a random floating point value uniformly distributed
@@ -148,3 +155,4 @@ abstract class RandomBase32 implements Random {
   @protected
   int boolCache_prevShift = 0;
 }
+

lib/src/80_drandom.dart

@@ -0,0 +1,27 @@
+import '60_xoshiro128pp.dart';
+
+class Drandom extends Xoshiro128pp {
+  Drandom()
+      : super(Xoshiro128pp.defaultSeedA, Xoshiro128pp.defaultSeedB, Xoshiro128pp.defaultSeedC,
+      Xoshiro128pp.defaultSeedD);
+
+  /// Generates a non-negative random integer uniformly distributed in
+  /// the range from 0, inclusive, to [max], exclusive.
+  ///
+  /// To make the distribution uniform, we use the so-called
+  /// [Debiased Modulo Once - Java Method](https://git.io/Jm0D7).
+  ///
+  /// This implementation is slightly faster than the standard one for
+  /// all [max] values, except for [max], which are powers of two.
+  @override
+  int nextInt(int max) {
+    if (max < 1 || max > 0x80000000) {
+      throw RangeError.range(max, 1, 0x80000000);
+    }
+    int r = nextRaw32();
+    int m = max - 1;
+    for (int u = r; u - (r = u % max) + m < 0; u = nextRaw32()) {}
+    return r;
+  }
+
+}

lib/src/90_aliases.dart

@@ -34,8 +34,3 @@ class Qrandom extends Xoshiro128pp {
       Xoshiro128pp.defaultSeedB, Xoshiro128pp.defaultSeedC, Xoshiro128pp.defaultSeedD);
 }
 
-class Drandom extends Xoshiro128pp {
-  Drandom()
-      : super(Xoshiro128pp.defaultSeedA, Xoshiro128pp.defaultSeedB, Xoshiro128pp.defaultSeedC,
-            Xoshiro128pp.defaultSeedD);
-}

lib/xrandom.dart

@@ -11,4 +11,6 @@ export 'src/60_xorshift32.dart' show Xorshift32;
 export 'src/60_xorshift64.dart' show Xorshift64;
 export 'src/60_xoshiro128pp.dart' show Xoshiro128pp;
 export 'src/60_xoshiro256.dart' show Xoshiro256pp, Xoshiro256ss;
-export 'src/90_aliases.dart' show Xrandom, Qrandom, Drandom;
+
+export 'src/80_drandom.dart' show Drandom;
+export 'src/90_aliases.dart' show Xrandom, Qrandom;

pubspec.yaml

@@ -1,7 +1,7 @@
 name: xrandom
 description: "Random number generators library focused on the consistency,
               performance and reproducibility"
-version: 0.7.0+1
+version: 0.7.1
 homepage: https://github.com/rtmigo/xrandom
 
 environment:

test/aliases_test.dart

@@ -43,12 +43,7 @@ void main() {
     expect(random.nextInt(1000), 904);
   });
 
-  test('Drandom readme', () {
-    final random = Drandom();
-    expect( List.generate(5, (_) => random.nextInt(100)),
-        [42, 17, 96, 23, 46] );
 
-  });
 
   void checkRespectsSeed(RandomBase32 Function(int seed) create) {
     expect( List.generate(3, (_) => create(123).nextRaw32()),

test/drandom_test.dart

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: (c) 2021-2022 Art Galkin <github.com/rtmigo>
+// SPDX-License-Identifier: MIT
+
+import 'package:test/test.dart';
+import 'package:xrandom/xrandom.dart'; // no imports for src should be here
+
+void main() {
+  test('Drandom readme', () {
+    final random = Drandom();
+    expect( List.generate(5, (_) => random.nextInt(100)),
+        [42, 17, 96, 23, 46] );
+  });
+
+  test('Drandom large', () {
+    final random = Drandom();
+    expect( List.generate(5, (_) => random.nextInt(0x7FEEDDAA)),
+        [1686059242, 361797217, 1133571596, 465717623, 1522544346] );
+  });
+
+  test('Drandom nextInt range', () {
+    final random = Drandom();
+
+    expect(()=>random.nextInt(0x80000001), throwsRangeError);
+    random.nextInt(0x80000000); // does not throw anything
+  });
+
+}

test/helper.dart

@@ -16,7 +16,6 @@ const FAST = INT64_SUPPORTED;
 
 
 Map refData(String algo, String seedId) {
-
   switch (algo) {
     case 'xoshiro256pp':
       algo = 'xoshiro256++';
@@ -30,13 +29,11 @@ Map refData(String algo, String seedId) {
     case 'xorshift128p':
       algo = 'xorshift128+';
       break;
-
   }
 
   for (final m in referenceData) {
     if (m['sample_class'] == algo &&
-        m['sample_name'] == seedId)
-    {
+        m['sample_name'] == seedId) {
       return m;
     }
   }
@@ -65,16 +62,14 @@ extension RdataExt on Map {
 }
 
 
-
 void checkDoornikRandbl32(RandomBase32 Function() createRandom, String seedId) {
-  test('doornik_randbl_32 ${createRandom().runtimeType} seedId=$seedId', ()
-  {
+  test('doornik_randbl_32 ${createRandom().runtimeType} seedId=$seedId', () {
     final random = createRandom();
     final filePrefix = random.runtimeType.toString().toLowerCase();
     final values = refData(filePrefix, seedId).doornik();
     for (final refItem in enumerate(values)) {
-      assert(0<=refItem.value);
-      assert(refItem.value<1.0);
+      assert(0 <= refItem.value);
+      assert(refItem.value < 1.0);
       expect(random.nextFloat(), refItem.value,
           reason: 'refitem ${refItem.index}');
     }
@@ -106,7 +101,7 @@ void checkReferenceFiles(RandomBase32 Function() createRandom, String seedId) {
 
 
     test('toDouble', () {
-      final values =  (random is RandomBase64)
+      final values = (random is RandomBase64)
           ? refData(filePrefix, seedId).double_multi()
           : refData(filePrefix, seedId).double_memcast();
       int idx = 0;
@@ -119,20 +114,19 @@ void checkReferenceFiles(RandomBase32 Function() createRandom, String seedId) {
     if (createRandom() is RandomBase64) {
       test('nextDoubleBitcast', () {
         final values =
-            refData(filePrefix, seedId).double_memcast();
+        refData(filePrefix, seedId).double_memcast();
         int idx = 0;
         for (final value in values) {
           expect((random as RandomBase64).nextDoubleBitcast(), value,
               reason: 'item ${idx++}');
         }
       });
     }
-
-
   });
 }
 
-List expectedList(RandomBase32 r) => [
+List expectedList(RandomBase32 r) =>
+    [
       (r is RandomBase64) ? r.nextRaw64() : r.nextRaw32(),
       r.nextInt(100000),
       r.nextDouble(),
@@ -145,9 +139,9 @@ String trimLeadingZeros(String s) {
   return s.replaceAll(RegExp(r'^0+(?=.)'), '');
 }
 
-void testCommonRandom(RandomBase32 Function() createRandom, RandomBase32 Function() createExpectedRandom) {
+void testCommonRandom(RandomBase32 Function() createRandom,
+    RandomBase32 Function() createExpectedRandom) {
   group('Common random ${createRandom().runtimeType}', () {
-
     test('nextDouble', () => checkDoubles(createRandom(), true));
     test('nextFloat', () => checkDoubles(createRandom(), false));
 
@@ -157,59 +151,38 @@ void testCommonRandom(RandomBase32 Function() createRandom, RandomBase32 Functio
     test('ints when power of two', () {
       final r = createExpectedRandom();
       bool zeroFound = false;
-      for (int i=0; i<1000; ++i)
-        {
-          int x = r.nextInt(128);
-          expect(x, greaterThanOrEqualTo(0));
-          expect(x, lessThan(128));
-          if (x==0) {
-            zeroFound = true;
-          }
+      for (int i = 0; i < 1000; ++i) {
+        int x = r.nextInt(128);
+        expect(x, greaterThanOrEqualTo(0));
+        expect(x, lessThan(128));
+        if (x == 0) {
+          zeroFound = true;
         }
+      }
       expect(zeroFound, isTrue);
     });
 
-
     test('Seed is different each time', () {
       // even with different seeds, we can get rare matches of results.
       // But most of the the results should be unique
       expect(
-          List.generate(100, (index) => createRandom().nextDouble())
+          List
+              .generate(100, (index) => createRandom().nextDouble())
               .toSet()
               .length,
           greaterThan(90));
     });
 
-    // test('Huge ints: (1<<32)',
-    //     () => checkHugeInts(createRandom(), 4294967296));
-    // // "the fast case for powers of two"
-    // test('Huge ints: 0x80000000',
-    //     () => checkHugeInts(createRandom(), 0x80000000));
-    //
-    // test('Huge ints: JS_MAX_SAFE_INTEGER',
-    //         () => checkHugeInts(createRandom(), JS_MAX_SAFE_INTEGER));
-    //
-    // if (INT64_SUPPORTED) {
-    //   test('Huge ints: 0x7FFFFFFFFFFFFFFF',
-    //           () => checkHugeInts(createRandom(), int.parse('0x7FFFFFFFFFFFFFFF')));
-    // }
-
-
-
     test('nextIntCheckRange', () {
       final r = createRandom();
       expect(() => r.nextInt(-1), throwsRangeError);
       expect(() => r.nextInt(0), throwsRangeError);
-      expect(() => r.nextInt(0xFFFFFFFF+1), throwsRangeError);
-      // if (INT64_SUPPORTED) {
-      //   r.nextInt(0xFFFFFFFF + 1); // no errors
-      // } else {
-      //   expect(() => r.nextInt(0xFFFFFFFF + 1), throwsRangeError);
-      // }
+      expect(() => r.nextInt(0xFFFFFFFF + 2), throwsRangeError);
 
       // no errors
       r.nextInt(1);
       r.nextInt(0xFFFFFFFF);
+      r.nextInt(0xFFFFFFFF + 1);
     });
 
     test('nextInt(2) works almost like next bool', () {
@@ -249,14 +222,13 @@ void testCommonRandom(RandomBase32 Function() createRandom, RandomBase32 Functio
     });
 
     test('next32 <-> next64', () {
-
       // we don't specify, whether the generator 64 bit or 32 bit,
       // so which method returns the generator output and which
       // returns the split or combined value
 
       if (!INT64_SUPPORTED) {
-         expect(()=>createExpectedRandom().nextRaw64(), throwsA(isA<Unsupported64Error>()));
-         return;
+        expect(() => createExpectedRandom().nextRaw64(), throwsA(isA<Unsupported64Error>()));
+        return;
       }
 
       // It must work both ways equally
@@ -272,17 +244,10 @@ void testCommonRandom(RandomBase32 Function() createRandom, RandomBase32 Functio
       expect(random2.nextRaw32(), b64.lower32());
     });
 
-    // test('nextFloat roughly compares to nextDouble', () {
-    //   final r1 = createRandom();
-    //   final r2 = createRandom();
-    //
-    //   const N = 1000;
-    //   for (int i = 0; i < N; ++i) {
-    //     final d = r1.nextDouble();
-    //     var x = r.nextInt(1);
-    //     expect(x, 0);
-    //   }
-    // });
+    test('large ints uniformity', () {
+      final r = createRandom();
+      checkUniformityForLargeInts(r);
+    });
   });
 }
 
@@ -325,6 +290,36 @@ void checkBooleans(Random r) {
   expect(countTrue, lessThan(N * 0.6));
 }
 
+void checkUniformityForLargeInts(Random random) {
+  // eliminating the issue:
+  // https://github.com/rtmigo/xrandom_dart/issues/3
+
+  const mid = 1431655765; // (1 << 32) ~/ 3;
+  const max = mid * 2;
+  var lower = 0;
+  var upper = 0;
+  const N = 10000000;
+  for (var i = 0; i < N; i++) {
+    if (random.nextInt(max) < mid) {
+      lower++;
+    } else {
+      upper++;
+    }
+  }
+
+  const int expected = 5000000;
+  const int delta = 100000;
+
+  assert(expected * 2 == N);
+  assert(delta * 50 == expected);
+
+  expect(lower, greaterThan(expected - delta));
+  expect(lower, lessThan(expected + delta));
+  expect(upper, greaterThan(expected - delta));
+  expect(upper, lessThan(expected + delta));
+}
+
+
 void checkIntegers(Random r) {
   int countMin = 0;
   int countMax = 0;

test/refdata.dart

@@ -1,2 +1,3 @@
 void addReferenceData(
     {String? algorithm, String? seed, String? type, List? values}) {}
+