Better seeds.

Author: mbostock

README.md

@@ -109,10 +109,10 @@ Returns the same type of function for generating random numbers but where the gi
 
 ```js
 const d3 = require("d3-random");
-const seed = 0.42; // any number in [0, 1)
+const seed = 0.44871573888282423; // any number in [0, 1)
 const random = d3.randomNormal.source(d3.randomLcg(seed))(0, 1);
 
-random(); // -0.8192429857722214
+random(); // -0.6253955998897069
 ```
 
 <a name="randomLcg" href="#randomLcg">#</a> d3.<b>randomLcg</b>(<i>[seed]</i>) · [Examples](https://observablehq.com/@fil/linear-congruential-generator)

test/bates-test.js

@@ -6,7 +6,7 @@ var tape = require("tape"),
 require("./inDelta");
 
 tape("d3.randomBates(n) returns random numbers with a mean of one-half", function(test) {
-  var randomBates = d3.randomBates.source(d3.randomLcg(0.1));
+  var randomBates = d3.randomBates.source(d3.randomLcg(0.6351090615932817));
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(1))), 0.5, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(10))), 0.5, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(1.5))), 0.5, 0.05);
@@ -15,7 +15,7 @@ tape("d3.randomBates(n) returns random numbers with a mean of one-half", functio
 });
 
 tape("d3.randomBates(n) returns random numbers with a variance of 1 / (12 * n)", function(test) {
-  var randomBates = d3.randomBates.source(d3.randomLcg(0.2));
+  var randomBates = d3.randomBates.source(d3.randomLcg(0.1284832084868286));
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(1))), 1 / 12, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(10))), 1 / 120, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(1.5))), 1 / 18, 0.05);
@@ -24,7 +24,7 @@ tape("d3.randomBates(n) returns random numbers with a variance of 1 / (12 * n)",
 });
 
 tape("d3.randomBates(n) returns random numbers with a skewness of 0", function(test) {
-  var randomBates = d3.randomBates.source(d3.randomLcg(0.3));
+  var randomBates = d3.randomBates.source(d3.randomLcg(0.051567609139606674));
   test.inDelta(skewness(d3.range(10000).map(randomBates(1))), 0, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBates(10))), 0, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBates(1.5))), 0, 0.05);
@@ -33,7 +33,7 @@ tape("d3.randomBates(n) returns random numbers with a skewness of 0", function(t
 });
 
 tape("d3.randomBates(n) returns random numbers with a kurtosis of -6 / (5 * n)", function(test) {
-  var randomBates = d3.randomBates.source(d3.randomLcg(0.4));
+  var randomBates = d3.randomBates.source(d3.randomLcg(0.696913354780724));
   test.inDelta(kurtosis(d3.range(10000).map(randomBates(1))), -6 / 5, 0.05);
   test.inDelta(kurtosis(d3.range(10000).map(randomBates(10))), -6 / 50, 0.1);
   test.inDelta(kurtosis(d3.range(10000).map(randomBates(1.5))), -6 / 7.5, 0.05);
@@ -42,7 +42,7 @@ tape("d3.randomBates(n) returns random numbers with a kurtosis of -6 / (5 * n)",
 });
 
 tape("d3.randomBates(0) is equivalent to d3.randomUniform()", function(test) {
-  var randomBates = d3.randomBates.source(d3.randomLcg(0.5));
+  var randomBates = d3.randomBates.source(d3.randomLcg(0.7717596603725383));
   test.inDelta(d3.mean(d3.range(10000).map(randomBates(0))), 0.5, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBates(0))), 1 / 12, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBates(0))), 0, 0.05);

test/bernoulli-test.js

@@ -11,7 +11,7 @@ var skew = function(p) { return (1 - 2 * p) / Math.sqrt(variance(p)); };
 var kurt = function(p) { return (6 * Math.pow(p, 2) - 6 * p + 1) / variance(p); };
 
 tape("randomBernoulli(p) returns random bernoulli distributed numbers with a mean of p", function(test) {
-  var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.1));
+  var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.48444190806583465));
   test.inDelta(d3.mean(d3.range(10000).map(randomBernoulli(1))), mean(1), variance(1));
   test.inDelta(d3.mean(d3.range(10000).map(randomBernoulli(.5))), mean(.5), variance(.5));
   test.inDelta(d3.mean(d3.range(10000).map(randomBernoulli(.25))), mean(.25), variance(.25));
@@ -20,7 +20,7 @@ tape("randomBernoulli(p) returns random bernoulli distributed numbers with a mea
 });
 
 tape("randomBernoulli(p) returns random bernoulli distributed numbers with a variance of p * (1 - p)", function(test) {
-  var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.2));
+  var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.9781605192898934));
   test.inDelta(d3.variance(d3.range(10000).map(randomBernoulli(1))), variance(1), 0);
   test.inDelta(d3.variance(d3.range(10000).map(randomBernoulli(.5))), variance(.5), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBernoulli(.25))), variance(.25), 0.05);
@@ -29,14 +29,14 @@ tape("randomBernoulli(p) returns random bernoulli distributed numbers with a var
 });
 
 tape("randomBernoulli(p) returns random bernoulli distributed numbers with a skewness of (1 - 2 * p) / sqrt(p * (1 - p)).", function(test) {
-  var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.3));
+  var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.9776249148208429));
   test.inDelta(skewness(d3.range(10000).map(randomBernoulli(.5))), skew(.5), 0.08);
   test.inDelta(skewness(d3.range(10000).map(randomBernoulli(.25))), skew(.25), 0.05);
   test.end();
 });
 
 tape("randomBernoulli(p) returns random bernoulli distributed numbers with a kurtosis excess of (6 * p^2 - 6 * p - 1) / (p * (1 - p)).", function(test) {
-  var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.4));
+  var randomBernoulli = d3.randomBernoulli.source(d3.randomLcg(0.8260973119979638));
   test.inDelta(kurtosis(d3.range(10000).map(randomBernoulli(.05))), kurt(.05), kurt(.05) * 0.2);
   test.inDelta(kurtosis(d3.range(10000).map(randomBernoulli(.10))), kurt(.10), kurt(.10) * 0.2);
   test.inDelta(kurtosis(d3.range(10000).map(randomBernoulli(.15))), kurt(.15), kurt(.15) * 0.2);

test/beta-test.js

@@ -7,7 +7,7 @@ var mean = function(alpha, beta) { return alpha / (alpha + beta); };
 var variance = function(alpha, beta) { return (alpha * beta) / Math.pow(alpha + beta, 2) / (alpha + beta + 1); };
 
 tape("randomBeta(alpha, beta) returns random numbers with a mean of alpha / (alpha + beta)", function(test) {
-  var randomBeta = d3.randomBeta.source(d3.randomLcg(0.1));
+  var randomBeta = d3.randomBeta.source(d3.randomLcg(0.8275880644751501));
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(1, 1))), mean(1, 1), 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(1, 2))), mean(1, 2), 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomBeta(2, 1))), mean(2, 1), 0.05);
@@ -18,7 +18,7 @@ tape("randomBeta(alpha, beta) returns random numbers with a mean of alpha / (alp
 });
 
 tape("randomBeta(alpha, beta) returns random numbers with a variance of (alpha * beta) / (alpha + beta)^2 / (alpha + beta + 1)", function(test) {
-  var randomBeta = d3.randomBeta.source(d3.randomLcg(0.2));
+  var randomBeta = d3.randomBeta.source(d3.randomLcg(0.8272345925494458));
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(1, 1))), variance(1, 1), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(1, 2))), variance(1, 2), 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomBeta(2, 1))), variance(2, 1), 0.05);

test/binomial-test.js

@@ -11,7 +11,7 @@ var skew = function(n, p) { return (1 - 2 * p) / Math.sqrt(variance(n, p)); };
 var kurt = function(n, p) { return (6 * Math.pow(p, 2) - 6 * p + 1) / (variance(n, p)); };
 
 tape("randomBinomial(n, p) returns random binomial distributed numbers with a mean of n * p", function(test) {
-  var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.1));
+  var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.3994478770613372));
   test.inDelta(d3.mean(d3.range(10000).map(randomBinomial(100, 1))), mean(100, 1), variance(100, 1));
   test.inDelta(d3.mean(d3.range(10000).map(randomBinomial(100, .5))), mean(100, .5), variance(100, .5));
   test.inDelta(d3.mean(d3.range(10000).map(randomBinomial(100, .25))), mean(100, .25), variance(100, .25));
@@ -21,7 +21,7 @@ tape("randomBinomial(n, p) returns random binomial distributed numbers with a me
 });
 
 tape("randomBinomial(n, p) returns random binomial distributed numbers with a variance of n * p * (1 - p)", function(test) {
-  var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.2));
+  var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.7214876234380256));
   test.inDelta(d3.variance(d3.range(10000).map(randomBinomial(100, 1))), variance(100, 1), 0);
   test.inDelta(d3.variance(d3.range(10000).map(randomBinomial(100, .5))), variance(100, .5), 0.5);
   test.inDelta(d3.variance(d3.range(10000).map(randomBinomial(100, .25))), variance(100, .25), 1);
@@ -31,7 +31,7 @@ tape("randomBinomial(n, p) returns random binomial distributed numbers with a va
 });
 
 tape("randomBinomial(n, p) returns random binomial distributed numbers with a skewness of (1 - 2 * p) / sqrt(n * p * (1 - p))", function(test) {
-  var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.3));
+  var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.0646181509291679));
   test.inDelta(skewness(d3.range(10000).map(randomBinomial(100, .05))), skew(100, .05), 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBinomial(100, .10))), skew(100, .10), 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomBinomial(100, .15))), skew(100, .15), 0.05);
@@ -45,7 +45,7 @@ tape("randomBinomial(n, p) returns random binomial distributed numbers with a sk
 });
 
 tape("randomBinomial(n, p) returns random binomial distributed numbers with a kurtosis excess of (6 * p^2 - 6 * p - 1) / (n * p * (1 - p))", function(test) {
-  var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.4));
+  var randomBinomial = d3.randomBinomial.source(d3.randomLcg(0.6451552018202751));
   test.inDelta(kurtosis(d3.range(10000).map(randomBinomial(100, .05))), kurt(100, .05), 0.2);
   test.inDelta(kurtosis(d3.range(10000).map(randomBinomial(100, .10))), kurt(100, .10), 0.1);
   test.inDelta(kurtosis(d3.range(10000).map(randomBinomial(100, .15))), kurt(100, .15), 0.1);

test/gamma-test.js

@@ -6,7 +6,7 @@ var tape = require("tape"),
 require("./inDelta");
 
 tape("randomGamma(k) returns random numbers with a mean of k", function(test) {
-  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.1));
+  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.8177609532536807));
   test.inDelta(d3.mean(d3.range(10000).map(randomGamma(0.1))), 0.1, 0.01);
   test.inDelta(d3.mean(d3.range(10000).map(randomGamma(0.5))), 0.5, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomGamma(1))), 1, 0.05);
@@ -16,7 +16,7 @@ tape("randomGamma(k) returns random numbers with a mean of k", function(test) {
 });
 
 tape("randomGamma(k) returns random numbers with a variance of k", function(test) {
-  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.2));
+  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.6494198931625885));
   test.inDelta(d3.variance(d3.range(10000).map(randomGamma(0.1))), 0.1, 0.005);
   test.inDelta(d3.variance(d3.range(10000).map(randomGamma(0.5))), 0.5, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomGamma(1))), 1, 0.05);
@@ -26,7 +26,7 @@ tape("randomGamma(k) returns random numbers with a variance of k", function(test
 });
 
 tape("randomGamma(k) returns random numbers with a skewness of 2 / sqrt(k)", function(test) {
-  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.3));
+  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.02223371708142996));
   test.inDelta(skewness(d3.range(10000).map(randomGamma(0.1))), Math.sqrt(40), 1);
   test.inDelta(skewness(d3.range(10000).map(randomGamma(0.5))), Math.sqrt(8), 0.25);
   test.inDelta(skewness(d3.range(10000).map(randomGamma(1))), 2, 0.1);
@@ -36,7 +36,7 @@ tape("randomGamma(k) returns random numbers with a skewness of 2 / sqrt(k)", fun
 });
 
 tape("randomGamma(k) returns random numbers with an excess kurtosis of 6 / k", function(test) {
-  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.4));
+  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.19568718910927974));
   test.inDelta(kurtosis(d3.range(10000).map(randomGamma(0.1))), 60, 15);
   test.inDelta(kurtosis(d3.range(10000).map(randomGamma(0.5))), 12, 3);
   test.inDelta(kurtosis(d3.range(10000).map(randomGamma(1))), 6, 1.5);
@@ -46,7 +46,7 @@ tape("randomGamma(k) returns random numbers with an excess kurtosis of 6 / k", f
 });
 
 tape("randomGamma(k, theta) returns random numbers with a mean of k * theta and a variance of k * theta^2", function(test) {
-  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.5));
+  var randomGamma = d3.randomGamma.source(d3.randomLcg(0.9608725416165995));
   test.inDelta(d3.mean(d3.range(10000).map(randomGamma(1, 2))), 2, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomGamma(2, 4))), 8, 0.2);
   test.inDelta(d3.deviation(d3.range(10000).map(randomGamma(1, 2))), 2, 0.1);

test/geometric-test.js

@@ -11,7 +11,7 @@ var skew = function(p) { return (2 - p) / Math.sqrt(1 - p); };
 var kurt = function(p) { return (Math.pow(p, 2) - 6 * p + 6) / (1 - p); };
 
 tape("randomGeometric(p) returns random geometrically distributed numbers with a mean of 1 / p.", function(test) {
-  var randomGeometric = d3.randomGeometric.source(d3.randomLcg(0.1));
+  var randomGeometric = d3.randomGeometric.source(d3.randomLcg(0.7687729138471455));
   test.inDelta(d3.mean(d3.range(10000).map(randomGeometric(1))), mean(1), variance(1));
   test.inDelta(d3.mean(d3.range(10000).map(randomGeometric(.5))), mean(.5), variance(.5));
   test.inDelta(d3.mean(d3.range(10000).map(randomGeometric(0.25))), mean(0.25), variance(0.25));
@@ -20,7 +20,7 @@ tape("randomGeometric(p) returns random geometrically distributed numbers with a
 });
 
 tape("randomGeometric(p) returns random geometrically distributed numbers with a variance of (1 - p) / p^2.", function(test) {
-  var randomGeometric = d3.randomGeometric.source(d3.randomLcg(0.2));
+  var randomGeometric = d3.randomGeometric.source(d3.randomLcg(0.7194220774328326));
   test.inDelta(d3.variance(d3.range(10000).map(randomGeometric(1))), variance(1), variance(1) * 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomGeometric(.5))), variance(.5), variance(.5) * 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomGeometric(0.25))), variance(0.25), variance(.25) * 0.05);
@@ -29,15 +29,15 @@ tape("randomGeometric(p) returns random geometrically distributed numbers with a
 });
 
 tape("randomGeometric(p) returns random geometrically distributed numbers with a skewness of (2 - p) / sqrt(1 - p).", function(test) {
-  var randomGeometric = d3.randomGeometric.source(d3.randomLcg(0.3));
+  var randomGeometric = d3.randomGeometric.source(d3.randomLcg(0.016030992648006448));
   test.inDelta(skewness(d3.range(10000).map(randomGeometric(.5))), skew(.5), 0.05 * skew(.5));
   test.inDelta(skewness(d3.range(10000).map(randomGeometric(0.25))), skew(0.25), 0.05 * skew(0.25));
   test.inDelta(skewness(d3.range(10000).map(randomGeometric(0.125))), skew(0.125), 0.1 * skew(0.125));
   test.end();
 });
 
 tape("randomGeometric(p) returns random geometrically distributed numbers with a kurtosis excess of (p^2 - 6 * p + 6) / (1 - p).", function(test) {
-  var randomGeometric = d3.randomGeometric.source(d3.randomLcg(0.42));
+  var randomGeometric = d3.randomGeometric.source(d3.randomLcg(0.4039802168183795));
   test.inDelta(kurtosis(d3.range(20000).map(randomGeometric(.5))), kurt(.5), 0.2 * kurt(.5));
   test.inDelta(kurtosis(d3.range(20000).map(randomGeometric(0.25))), kurt(0.25), 0.3 * kurt(0.25));
   test.inDelta(kurtosis(d3.range(20000).map(randomGeometric(0.125))), kurt(0.125), 0.3 * kurt(0.125));

test/int-test.js

@@ -4,27 +4,27 @@ var tape = require("tape"),
 require("./inDelta");
 
 tape("randomInt(max) returns random integers with a mean of (max - 1) / 2", function(test) {
-  var randomInt = d3.randomInt.source(d3.randomLcg(0.1));
+  var randomInt = d3.randomInt.source(d3.randomLcg(0.7350864698209636));
   test.inDelta(d3.mean(d3.range(10000).map(randomInt(3))), 1.0, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomInt(21))), 10.0, 0.5);
   test.end();
 });
 
 tape("randomInt(max) returns random integers in the range [0, max - 1]", function(test) {
-  var randomInt = d3.randomInt.source(d3.randomLcg(0.2));
+  var randomInt = d3.randomInt.source(d3.randomLcg(0.17809137433591848));
   test.deepEqual(d3.extent(d3.range(10000).map(randomInt(3))), [0, 2]);
   test.deepEqual(d3.extent(d3.range(10000).map(randomInt(21))), [0, 20]);
   test.end();
 });
 
 tape("randomInt(min, max) returns random integers with a mean of (min + max - 1) / 2", function(test) {
-  var randomInt = d3.randomInt.source(d3.randomLcg(0.3));
+  var randomInt = d3.randomInt.source(d3.randomLcg(0.46394764422984647));
   test.inDelta(d3.mean(d3.range(10000).map(randomInt(10, 43))), 26, 0.5);
   test.end();
 });
 
 tape("randomInt(min, max) returns random integers in the range [min, max - 1]", function(test) {
-  var randomInt = d3.randomInt.source(d3.randomLcg(0.4));
+  var randomInt = d3.randomInt.source(d3.randomLcg(0.9598431138570096));
   test.deepEqual(d3.extent(d3.range(10000).map(randomInt(10, 42))), [10, 41]);
   test.end();
 });

test/irwinHall-test.js

@@ -6,7 +6,7 @@ var tape = require("tape"),
 require("./inDelta");
 
 tape("d3.randomIrwinHall(n) returns random numbers with a mean of n / 2", function(test) {
-  var randomIrwinHall = d3.randomIrwinHall.source(d3.randomLcg(0.1));
+  var randomIrwinHall = d3.randomIrwinHall.source(d3.randomLcg(0.028699383123896194));
   test.inDelta(d3.mean(d3.range(10000).map(randomIrwinHall(1))), 1 / 2, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomIrwinHall(10))), 10 / 2, 0.05);
   test.inDelta(d3.mean(d3.range(10000).map(randomIrwinHall(1.5))), 1.5 / 2, 0.05);
@@ -15,7 +15,7 @@ tape("d3.randomIrwinHall(n) returns random numbers with a mean of n / 2", functi
 });
 
 tape("d3.randomIrwinHall(n) returns random numbers with a variance of n / 12", function(test) {
-  var randomIrwinHall = d3.randomIrwinHall.source(d3.randomLcg(0.2));
+  var randomIrwinHall = d3.randomIrwinHall.source(d3.randomLcg(0.1515471143624345));
   test.inDelta(d3.variance(d3.range(10000).map(randomIrwinHall(1))), 1 / 12, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomIrwinHall(10))), 10 / 12, 0.05);
   test.inDelta(d3.variance(d3.range(10000).map(randomIrwinHall(1.5))), 1.5 / 12, 0.05);
@@ -24,7 +24,7 @@ tape("d3.randomIrwinHall(n) returns random numbers with a variance of n / 12", f
 });
 
 tape("d3.randomIrwinHall(n) returns random numbers with a skewness of 0", function(test) {
-  var randomIrwinHall = d3.randomIrwinHall.source(d3.randomLcg(0.3));
+  var randomIrwinHall = d3.randomIrwinHall.source(d3.randomLcg(0.47334122849782845));
   test.inDelta(skewness(d3.range(10000).map(randomIrwinHall(1))), 0, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomIrwinHall(10))), 0, 0.05);
   test.inDelta(skewness(d3.range(10000).map(randomIrwinHall(1.5))), 0, 0.05);
@@ -33,7 +33,7 @@ tape("d3.randomIrwinHall(n) returns random numbers with a skewness of 0", functi
 });
 
 tape("d3.randomIrwinHall(n) returns random numbers with a kurtosis of -6 / (5 * n)", function(test) {
-  var randomIrwinHall = d3.randomIrwinHall.source(d3.randomLcg(0.4));
+  var randomIrwinHall = d3.randomIrwinHall.source(d3.randomLcg(0.8217913599574529));
   test.inDelta(kurtosis(d3.range(10000).map(randomIrwinHall(1))), -6 / 5, 0.1);
   test.inDelta(kurtosis(d3.range(10000).map(randomIrwinHall(10))), -6 / 50, 0.1);
   test.inDelta(kurtosis(d3.range(10000).map(randomIrwinHall(1.5))), -6 / 7.5, 0.05);