http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java b/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java index 072f5c5..4013c47 100644 --- a/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java +++ b/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java @@ -21,8 +21,6 @@ import org.apache.commons.math4.exception.NumberIsTooLargeException; import org.apache.commons.math4.exception.NumberIsTooSmallException; import org.apache.commons.math4.exception.OutOfRangeException; import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; import org.apache.commons.math4.util.FastMath; /** @@ -35,7 +33,7 @@ import org.apache.commons.math4.util.FastMath; */ public class TriangularDistribution extends AbstractRealDistribution { /** Serializable version identifier. */ - private static final long serialVersionUID = 20120112L; + private static final long serialVersionUID = 20160311L; /** Lower limit of this distribution (inclusive). */ private final double a; /** Upper limit of this distribution (inclusive). */ @@ -46,31 +44,8 @@ public class TriangularDistribution extends AbstractRealDistribution { private final double solverAbsoluteAccuracy; /** - * Creates a triangular real distribution using the given lower limit, - * upper limit, and mode. - * <p> - * <b>Note:</b> this constructor will implicitly create an instance of - * {@link Well19937c} as random generator to be used for sampling only (see - * {@link #sample()} and {@link #sample(int)}). In case no sampling is - * needed for the created distribution, it is advised to pass {@code null} - * as random generator via the appropriate constructors to avoid the - * additional initialisation overhead. - * - * @param a Lower limit of this distribution (inclusive). - * @param b Upper limit of this distribution (inclusive). - * @param c Mode of this distribution. - * @throws NumberIsTooLargeException if {@code a >= b} or if {@code c > b}. - * @throws NumberIsTooSmallException if {@code c < a}. - */ - public TriangularDistribution(double a, double c, double b) - throws NumberIsTooLargeException, NumberIsTooSmallException { - this(new Well19937c(), a, c, b); - } - - /** - * Creates a triangular distribution. + * Creates a distribution. * - * @param rng Random number generator. * @param a Lower limit of this distribution (inclusive). * @param b Upper limit of this distribution (inclusive). * @param c Mode of this distribution. @@ -78,13 +53,11 @@ public class TriangularDistribution extends AbstractRealDistribution { * @throws NumberIsTooSmallException if {@code c < a}. * @since 3.1 */ - public TriangularDistribution(RandomGenerator rng, - double a, + public TriangularDistribution(double a, double c, double b) - throws NumberIsTooLargeException, NumberIsTooSmallException { - super(rng); - + throws NumberIsTooLargeException, + NumberIsTooSmallException { if (a >= b) { throw new NumberIsTooLargeException( LocalizedFormats.LOWER_BOUND_NOT_BELOW_UPPER_BOUND,
http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java b/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java index 704aa97..404cc02 100644 --- a/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java +++ b/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java @@ -20,8 +20,6 @@ package org.apache.commons.math4.distribution; import org.apache.commons.math4.exception.NumberIsTooLargeException; import org.apache.commons.math4.exception.OutOfRangeException; import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; import org.apache.commons.math4.rng.UniformRandomProvider; /** @@ -34,7 +32,7 @@ import org.apache.commons.math4.rng.UniformRandomProvider; */ public class UniformRealDistribution extends AbstractRealDistribution { /** Serializable version identifier. */ - private static final long serialVersionUID = 20120109L; + private static final long serialVersionUID = 20160311L; /** Lower bound of this distribution (inclusive). */ private final double lower; /** Upper bound of this distribution (exclusive). */ @@ -43,53 +41,21 @@ public class UniformRealDistribution extends AbstractRealDistribution { /** * Create a standard uniform real distribution with lower bound (inclusive) * equal to zero and upper bound (exclusive) equal to one. - * <p> - * <b>Note:</b> this constructor will implicitly create an instance of - * {@link Well19937c} as random generator to be used for sampling only (see - * {@link #sample()} and {@link #sample(int)}). In case no sampling is - * needed for the created distribution, it is advised to pass {@code null} - * as random generator via the appropriate constructors to avoid the - * additional initialisation overhead. */ public UniformRealDistribution() { this(0, 1); } /** - * Create a uniform real distribution using the given lower and upper - * bounds. - * <p> - * <b>Note:</b> this constructor will implicitly create an instance of - * {@link Well19937c} as random generator to be used for sampling only (see - * {@link #sample()} and {@link #sample(int)}). In case no sampling is - * needed for the created distribution, it is advised to pass {@code null} - * as random generator via the appropriate constructors to avoid the - * additional initialisation overhead. - * - * @param lower Lower bound of this distribution (inclusive). - * @param upper Upper bound of this distribution (exclusive). - * @throws NumberIsTooLargeException if {@code lower >= upper}. - */ - public UniformRealDistribution(double lower, double upper) - throws NumberIsTooLargeException { - this(new Well19937c(), lower, upper); - } - - /** * Creates a uniform distribution. * - * @param rng Random number generator. * @param lower Lower bound of this distribution (inclusive). * @param upper Upper bound of this distribution (exclusive). * @throws NumberIsTooLargeException if {@code lower >= upper}. - * @since 3.1 */ - @Deprecated - public UniformRealDistribution(RandomGenerator rng, - double lower, + public UniformRealDistribution(double lower, double upper) throws NumberIsTooLargeException { - super(rng); if (lower >= upper) { throw new NumberIsTooLargeException( LocalizedFormats.LOWER_BOUND_NOT_BELOW_UPPER_BOUND, @@ -207,7 +173,7 @@ public class UniformRealDistribution extends AbstractRealDistribution { /** {@inheritDoc} */ @Override public double sample() { - final double u = random.nextDouble(); + final double u = rng.nextDouble(); return u * upper + (1 - u) * lower; } }; http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java b/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java index 893501e..844bf4a 100644 --- a/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java +++ b/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java @@ -20,8 +20,6 @@ package org.apache.commons.math4.distribution; import org.apache.commons.math4.exception.NotStrictlyPositiveException; import org.apache.commons.math4.exception.OutOfRangeException; import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; import org.apache.commons.math4.special.Gamma; import org.apache.commons.math4.util.FastMath; @@ -33,7 +31,8 @@ import org.apache.commons.math4.util.FastMath; * * @see <a href="http://en.wikipedia.org/wiki/Weibull_distribution";>Weibull distribution (Wikipedia)</a> * @see <a href="http://mathworld.wolfram.com/WeibullDistribution.html";>Weibull distribution (MathWorld)</a> - * @since 1.1 (changed to concrete class in 3.0) + * + * @since 1.1 */ public class WeibullDistribution extends AbstractRealDistribution { /** @@ -42,7 +41,7 @@ public class WeibullDistribution extends AbstractRealDistribution { */ public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9; /** Serializable version identifier. */ - private static final long serialVersionUID = 8589540077390120676L; + private static final long serialVersionUID = 20160311L; /** The shape parameter. */ private final double shape; /** The scale parameter. */ @@ -59,15 +58,7 @@ public class WeibullDistribution extends AbstractRealDistribution { private boolean numericalVarianceIsCalculated = false; /** - * Create a Weibull distribution with the given shape and scale and a - * location equal to zero. - * <p> - * <b>Note:</b> this constructor will implicitly create an instance of - * {@link Well19937c} as random generator to be used for sampling only (see - * {@link #sample()} and {@link #sample(int)}). In case no sampling is - * needed for the created distribution, it is advised to pass {@code null} - * as random generator via the appropriate constructors to avoid the - * additional initialisation overhead. + * Creates a distribution. * * @param alpha Shape parameter. * @param beta Scale parameter. @@ -80,63 +71,19 @@ public class WeibullDistribution extends AbstractRealDistribution { } /** - * Create a Weibull distribution with the given shape, scale and inverse - * cumulative probability accuracy and a location equal to zero. - * <p> - * <b>Note:</b> this constructor will implicitly create an instance of - * {@link Well19937c} as random generator to be used for sampling only (see - * {@link #sample()} and {@link #sample(int)}). In case no sampling is - * needed for the created distribution, it is advised to pass {@code null} - * as random generator via the appropriate constructors to avoid the - * additional initialisation overhead. - * - * @param alpha Shape parameter. - * @param beta Scale parameter. - * @param inverseCumAccuracy Maximum absolute error in inverse - * cumulative probability estimates - * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). - * @throws NotStrictlyPositiveException if {@code alpha <= 0} or - * {@code beta <= 0}. - * @since 2.1 - */ - public WeibullDistribution(double alpha, double beta, - double inverseCumAccuracy) { - this(new Well19937c(), alpha, beta, inverseCumAccuracy); - } - - /** - * Creates a Weibull distribution. - * - * @param rng Random number generator. - * @param alpha Shape parameter. - * @param beta Scale parameter. - * @throws NotStrictlyPositiveException if {@code alpha <= 0} or {@code beta <= 0}. - * @since 3.3 - */ - public WeibullDistribution(RandomGenerator rng, double alpha, double beta) - throws NotStrictlyPositiveException { - this(rng, alpha, beta, DEFAULT_INVERSE_ABSOLUTE_ACCURACY); - } - - /** - * Creates a Weibull distribution. + * Creates a distribution. * - * @param rng Random number generator. * @param alpha Shape parameter. * @param beta Scale parameter. * @param inverseCumAccuracy Maximum absolute error in inverse * cumulative probability estimates * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). * @throws NotStrictlyPositiveException if {@code alpha <= 0} or {@code beta <= 0}. - * @since 3.1 */ - public WeibullDistribution(RandomGenerator rng, - double alpha, + public WeibullDistribution(double alpha, double beta, double inverseCumAccuracy) throws NotStrictlyPositiveException { - super(rng); - if (alpha <= 0) { throw new NotStrictlyPositiveException(LocalizedFormats.SHAPE, alpha); http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/random/EmpiricalDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/random/EmpiricalDistribution.java b/src/main/java/org/apache/commons/math4/random/EmpiricalDistribution.java index 6d2722e..926ad09 100644 --- a/src/main/java/org/apache/commons/math4/random/EmpiricalDistribution.java +++ b/src/main/java/org/apache/commons/math4/random/EmpiricalDistribution.java @@ -41,6 +41,8 @@ import org.apache.commons.math4.exception.NotStrictlyPositiveException; import org.apache.commons.math4.exception.util.LocalizedFormats; import org.apache.commons.math4.stat.descriptive.StatisticalSummary; import org.apache.commons.math4.stat.descriptive.SummaryStatistics; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.MathUtils; @@ -112,6 +114,7 @@ public class EmpiricalDistribution extends AbstractRealDistribution { private static final long serialVersionUID = 5729073523949762654L; /** RandomDataGenerator instance to use in repeated calls to getNext() */ + @Deprecated protected final RandomDataGenerator randomData; /** List of SummaryStatistics objects characterizing the bins */ @@ -152,8 +155,13 @@ public class EmpiricalDistribution extends AbstractRealDistribution { * @throws NotStrictlyPositiveException if {@code binCount <= 0}. */ public EmpiricalDistribution(int binCount) { - this(binCount, new RandomDataGenerator()); - } + if (binCount <= 0) { + throw new NotStrictlyPositiveException(binCount); + } + this.binCount = binCount; + binStats = new ArrayList<SummaryStatistics>(); + randomData = null; // XXX remove + } /** * Creates a new EmpiricalDistribution with the specified bin count using the @@ -164,8 +172,9 @@ public class EmpiricalDistribution extends AbstractRealDistribution { * @throws NotStrictlyPositiveException if {@code binCount <= 0}. * @since 3.0 */ + @Deprecated public EmpiricalDistribution(int binCount, RandomGenerator generator) { - this(binCount, new RandomDataGenerator(generator)); + this(binCount, new RandomDataGenerator(generator)); } /** @@ -175,8 +184,9 @@ public class EmpiricalDistribution extends AbstractRealDistribution { * @param generator random data generator (may be null, resulting in default JDK generator) * @since 3.0 */ + @Deprecated public EmpiricalDistribution(RandomGenerator generator) { - this(DEFAULT_BIN_COUNT, generator); + this(DEFAULT_BIN_COUNT, generator); } /** @@ -187,9 +197,9 @@ public class EmpiricalDistribution extends AbstractRealDistribution { * @param randomData Random data generator. * @throws NotStrictlyPositiveException if {@code binCount <= 0}. */ + @Deprecated private EmpiricalDistribution(int binCount, RandomDataGenerator randomData) { - super(randomData.getRandomGenerator()); if (binCount <= 0) { throw new NotStrictlyPositiveException(binCount); } @@ -452,12 +462,11 @@ public class EmpiricalDistribution extends AbstractRealDistribution { * @return the random value. * @throws MathIllegalStateException if the distribution has not been loaded */ + @Deprecated public double getNextValue() throws MathIllegalStateException { - if (!loaded) { throw new MathIllegalStateException(LocalizedFormats.DISTRIBUTION_NOT_LOADED); } - return sample(); } @@ -552,7 +561,9 @@ public class EmpiricalDistribution extends AbstractRealDistribution { * * @param seed random generator seed * @since 3.0 + * XXX REMOVE */ + @Deprecated public void reSeed(long seed) { randomData.reSeed(seed); } @@ -736,10 +747,20 @@ public class EmpiricalDistribution extends AbstractRealDistribution { * @since 3.1 */ @Override + @Deprecated public void reseedRandomGenerator(long seed) { randomData.reSeed(seed); } + /**{@inheritDoc} */ + @Override + public RealDistribution.Sampler createSampler(final UniformRandomProvider rng) { + if (!loaded) { + throw new MathIllegalStateException(LocalizedFormats.DISTRIBUTION_NOT_LOADED); + } + return super.createSampler(rng); + } + /** * The probability of bin i. * @@ -808,9 +829,8 @@ public class EmpiricalDistribution extends AbstractRealDistribution { if (bStats.getN() == 1 || bStats.getVariance() == 0) { return new ConstantRealDistribution(bStats.getMean()); } else { - return new NormalDistribution(randomData.getRandomGenerator(), - bStats.getMean(), bStats.getStandardDeviation(), - NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY); + return new NormalDistribution(bStats.getMean(), bStats.getStandardDeviation(), + NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY); } } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/random/RandomDataGenerator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/random/RandomDataGenerator.java b/src/main/java/org/apache/commons/math4/random/RandomDataGenerator.java index 7488a5f..d66808d 100644 --- a/src/main/java/org/apache/commons/math4/random/RandomDataGenerator.java +++ b/src/main/java/org/apache/commons/math4/random/RandomDataGenerator.java @@ -18,6 +18,9 @@ package org.apache.commons.math4.random; import java.io.Serializable; +import java.io.IOException; +import java.io.ObjectOutputStream; +import java.io.ObjectInputStream; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; @@ -46,6 +49,8 @@ import org.apache.commons.math4.exception.NotStrictlyPositiveException; import org.apache.commons.math4.exception.NumberIsTooLargeException; import org.apache.commons.math4.exception.OutOfRangeException; import org.apache.commons.math4.exception.util.LocalizedFormats; +import org.apache.commons.math4.rng.RandomSource; +import org.apache.commons.math4.rng.UniformRandomProvider; import org.apache.commons.math4.util.MathArrays; /** @@ -115,8 +120,14 @@ public class RandomDataGenerator implements Serializable { private static final long serialVersionUID = -626730818244969716L; /** underlying random number generator */ + @Deprecated private RandomGenerator rand = null; + /** Underlying random number generator. */ + private transient UniformRandomProvider randomProvider = null; + /** Underlying source of randomness. */ + private final RandomSource randomSource; + /** underlying secure random number generator */ private RandomGenerator secRand = null; @@ -129,6 +140,7 @@ public class RandomDataGenerator implements Serializable { * The generator is initialized and seeded on first use.</p> */ public RandomDataGenerator() { + randomSource = RandomSource.WELL_19937_C; } /** @@ -138,8 +150,20 @@ public class RandomDataGenerator implements Serializable { * @param rand the source of (non-secure) random data * (may be null, resulting in the default generator) */ + @Deprecated public RandomDataGenerator(RandomGenerator rand) { this.rand = rand; + randomSource = RandomSource.WELL_19937_C; + } + + /** + * Creates a new instance. + * + * @param source Source of (non-secure) random data. + * If {@code null}, {@link RandomSource#WELL_19937_C} will be used. + */ + public RandomDataGenerator(RandomSource source) { + randomSource = source == null ? RandomSource.WELL_19937_C : source; } /** @@ -491,8 +515,7 @@ public class RandomDataGenerator implements Serializable { * @throws NotStrictlyPositiveException if {@code mean <= 0}. */ public double nextExponential(double mean) throws NotStrictlyPositiveException { - return new ExponentialDistribution(getRandomGenerator(), mean, - ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).sample(); + return new ExponentialDistribution(mean, ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).createSampler(getRandomProvider()).sample(); } /** @@ -518,8 +541,7 @@ public class RandomDataGenerator implements Serializable { * {@code scale <= 0}. */ public double nextGamma(double shape, double scale) throws NotStrictlyPositiveException { - return new GammaDistribution(getRandomGenerator(),shape, scale, - GammaDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).sample(); + return new GammaDistribution(shape, scale, GammaDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).createSampler(getRandomProvider()).sample(); } /** @@ -535,8 +557,7 @@ public class RandomDataGenerator implements Serializable { * @throws NotPositiveException if {@code numberOfSuccesses < 0}. */ public int nextHypergeometric(int populationSize, int numberOfSuccesses, int sampleSize) throws NotPositiveException, NotStrictlyPositiveException, NumberIsTooLargeException { - return new HypergeometricDistribution(getRandomGenerator(),populationSize, - numberOfSuccesses, sampleSize).sample(); + return new HypergeometricDistribution(getRandomGenerator(), populationSize, numberOfSuccesses, sampleSize).sample(); } /** @@ -561,8 +582,7 @@ public class RandomDataGenerator implements Serializable { * @throws NotStrictlyPositiveException if {@code df <= 0} */ public double nextT(double df) throws NotStrictlyPositiveException { - return new TDistribution(getRandomGenerator(), df, - TDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).sample(); + return new TDistribution(df, TDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).createSampler(getRandomProvider()).sample(); } /** @@ -575,8 +595,7 @@ public class RandomDataGenerator implements Serializable { * {@code scale <= 0}. */ public double nextWeibull(double shape, double scale) throws NotStrictlyPositiveException { - return new WeibullDistribution(getRandomGenerator(), shape, scale, - WeibullDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).sample(); + return new WeibullDistribution(shape, scale, WeibullDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).createSampler(getRandomProvider()).sample(); } /** @@ -600,8 +619,7 @@ public class RandomDataGenerator implements Serializable { * @return random value sampled from the beta(alpha, beta) distribution */ public double nextBeta(double alpha, double beta) { - return new BetaDistribution(getRandomGenerator(), alpha, beta, - BetaDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).sample(); + return new BetaDistribution(alpha, beta, BetaDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).createSampler(getRandomProvider()).sample(); } /** @@ -623,8 +641,7 @@ public class RandomDataGenerator implements Serializable { * @return random value sampled from the Cauchy(median, scale) distribution */ public double nextCauchy(double median, double scale) { - return new CauchyDistribution(getRandomGenerator(), median, scale, - CauchyDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).sample(); + return new CauchyDistribution(median, scale, CauchyDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).createSampler(getRandomProvider()).sample(); } /** @@ -634,8 +651,7 @@ public class RandomDataGenerator implements Serializable { * @return random value sampled from the ChiSquare(df) distribution */ public double nextChiSquare(double df) { - return new ChiSquaredDistribution(getRandomGenerator(), df, - ChiSquaredDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).sample(); + return new ChiSquaredDistribution(df, ChiSquaredDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).createSampler(getRandomProvider()).sample(); } /** @@ -648,8 +664,7 @@ public class RandomDataGenerator implements Serializable { * {@code numeratorDf <= 0} or {@code denominatorDf <= 0}. */ public double nextF(double numeratorDf, double denominatorDf) throws NotStrictlyPositiveException { - return new FDistribution(getRandomGenerator(), numeratorDf, denominatorDf, - FDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).sample(); + return new FDistribution(numeratorDf, denominatorDf, FDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY).createSampler(getRandomProvider()).sample(); } /** @@ -830,7 +845,8 @@ public class RandomDataGenerator implements Serializable { * @param seed the seed value to use */ public void reSeed(long seed) { - getRandomGenerator().setSeed(seed); + randomProvider = RandomSource.create(randomSource, seed); + getRandomGenerator().setSeed(seed); } /** @@ -861,7 +877,7 @@ public class RandomDataGenerator implements Serializable { * {@code System.currentTimeMillis() + System.identityHashCode(this))}. */ public void reSeed() { - getRandomGenerator().setSeed(System.currentTimeMillis() + System.identityHashCode(this)); + reSeed(System.currentTimeMillis() + System.identityHashCode(this)); } /** @@ -896,6 +912,7 @@ public class RandomDataGenerator implements Serializable { * @return the Random used to generate random data * @since 3.2 */ + @Deprecated public RandomGenerator getRandomGenerator() { if (rand == null) { initRan(); @@ -904,9 +921,23 @@ public class RandomDataGenerator implements Serializable { } /** + * @return the generator used to generate non-secure random data. + * + * XXX TODO: method cannot be "private" because of its use in "ValueServer" in "DIGEST_MODE". + * "ValueServer" should be fixed to not use the internals of another class! + */ + UniformRandomProvider getRandomProvider() { + if (randomProvider == null) { + randomProvider = RandomSource.create(randomSource); + } + return randomProvider; + } + + /** * Sets the default generator to a {@link Well19937c} generator seeded with * {@code System.currentTimeMillis() + System.identityHashCode(this))}. */ + @Deprecated private void initRan() { rand = new Well19937c(System.currentTimeMillis() + System.identityHashCode(this)); } @@ -928,4 +959,42 @@ public class RandomDataGenerator implements Serializable { } return secRand; } + + /** + * @param out Output stream. + * @throws IOException if an error occurs. + */ + private void writeObject(ObjectOutputStream out) + throws IOException { + // Write non-transient fields. + out.defaultWriteObject(); + + if (randomProvider != null) { + // Save state of "randomProvider". + out.writeObject(RandomSource.saveState(randomProvider)); + } else { + out.writeObject(null); + } + } + + /** + * @param in Input stream. + * @throws IOException if an error occurs. + * @throws ClassNotFoundException if an error occurs. + */ + private void readObject(ObjectInputStream in) + throws IOException, + ClassNotFoundException { + // Read non-transient fields. + in.defaultReadObject(); + + // Read "randomProvider" state (can be null). + final Object state = in.readObject(); + if (state != null) { + // Recreate "randomProvider" from serialized info. + randomProvider = RandomSource.create(randomSource); + // And restore its state. + RandomSource.restoreState(randomProvider, (RandomSource.State) state); + } + } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/random/ValueServer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/random/ValueServer.java b/src/main/java/org/apache/commons/math4/random/ValueServer.java index de9118a..9e32035 100644 --- a/src/main/java/org/apache/commons/math4/random/ValueServer.java +++ b/src/main/java/org/apache/commons/math4/random/ValueServer.java @@ -202,7 +202,7 @@ public class ValueServer { * @throws ZeroException if URL contains no data */ public void computeDistribution(int binCount) throws NullArgumentException, IOException, ZeroException { - empiricalDistribution = new EmpiricalDistribution(binCount, randomData.getRandomGenerator()); + empiricalDistribution = new EmpiricalDistribution(binCount); empiricalDistribution.load(valuesFileURL); mu = empiricalDistribution.getSampleStats().getMean(); sigma = empiricalDistribution.getSampleStats().getStandardDeviation(); @@ -372,7 +372,7 @@ public class ValueServer { (empiricalDistribution.getBinStats().size() == 0)) { throw new MathIllegalStateException(LocalizedFormats.DIGEST_NOT_INITIALIZED); } - return empiricalDistribution.getNextValue(); + return empiricalDistribution.createSampler(randomData.getRandomProvider()).sample(); } /** http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/stat/inference/ChiSquareTest.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/stat/inference/ChiSquareTest.java b/src/main/java/org/apache/commons/math4/stat/inference/ChiSquareTest.java index fead59e..add6c01 100644 --- a/src/main/java/org/apache/commons/math4/stat/inference/ChiSquareTest.java +++ b/src/main/java/org/apache/commons/math4/stat/inference/ChiSquareTest.java @@ -157,7 +157,7 @@ public class ChiSquareTest { // pass a null rng to avoid unneeded overhead as we will not sample from this distribution final ChiSquaredDistribution distribution = - new ChiSquaredDistribution(null, expected.length - 1.0); + new ChiSquaredDistribution(expected.length - 1.0); return 1.0 - distribution.cumulativeProbability(chiSquare(expected, observed)); } @@ -510,7 +510,7 @@ public class ChiSquareTest { // pass a null rng to avoid unneeded overhead as we will not sample from this distribution final ChiSquaredDistribution distribution = - new ChiSquaredDistribution(null, (double) observed1.length - 1); + new ChiSquaredDistribution((double) observed1.length - 1); return 1 - distribution.cumulativeProbability( chiSquareDataSetsComparison(observed1, observed2)); http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/stat/inference/GTest.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/stat/inference/GTest.java b/src/main/java/org/apache/commons/math4/stat/inference/GTest.java index 2495804..0ee009d 100644 --- a/src/main/java/org/apache/commons/math4/stat/inference/GTest.java +++ b/src/main/java/org/apache/commons/math4/stat/inference/GTest.java @@ -154,7 +154,7 @@ public class GTest { // pass a null rng to avoid unneeded overhead as we will not sample from this distribution final ChiSquaredDistribution distribution = - new ChiSquaredDistribution(null, expected.length - 1.0); + new ChiSquaredDistribution(expected.length - 1.0); return 1.0 - distribution.cumulativeProbability(g(expected, observed)); } @@ -185,7 +185,7 @@ public class GTest { // pass a null rng to avoid unneeded overhead as we will not sample from this distribution final ChiSquaredDistribution distribution = - new ChiSquaredDistribution(null, expected.length - 2.0); + new ChiSquaredDistribution(expected.length - 2.0); return 1.0 - distribution.cumulativeProbability(g(expected, observed)); } @@ -475,7 +475,7 @@ public class GTest { // pass a null rng to avoid unneeded overhead as we will not sample from this distribution final ChiSquaredDistribution distribution = - new ChiSquaredDistribution(null, (double) observed1.length - 1); + new ChiSquaredDistribution((double) observed1.length - 1); return 1 - distribution.cumulativeProbability( gDataSetsComparison(observed1, observed2)); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/stat/inference/KolmogorovSmirnovTest.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/stat/inference/KolmogorovSmirnovTest.java b/src/main/java/org/apache/commons/math4/stat/inference/KolmogorovSmirnovTest.java index 04296a3..b75de0e 100644 --- a/src/main/java/org/apache/commons/math4/stat/inference/KolmogorovSmirnovTest.java +++ b/src/main/java/org/apache/commons/math4/stat/inference/KolmogorovSmirnovTest.java @@ -23,6 +23,7 @@ import java.util.HashSet; import org.apache.commons.math4.distribution.EnumeratedRealDistribution; import org.apache.commons.math4.distribution.RealDistribution; +import org.apache.commons.math4.distribution.AbstractRealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; import org.apache.commons.math4.exception.InsufficientDataException; import org.apache.commons.math4.exception.MathArithmeticException; @@ -39,9 +40,8 @@ import org.apache.commons.math4.linear.Array2DRowFieldMatrix; import org.apache.commons.math4.linear.FieldMatrix; import org.apache.commons.math4.linear.MatrixUtils; import org.apache.commons.math4.linear.RealMatrix; -import org.apache.commons.math4.random.JDKRandomGenerator; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; +import org.apache.commons.math4.rng.RandomSource; +import org.apache.commons.math4.rng.UniformRandomProvider; import org.apache.commons.math4.util.CombinatoricsUtils; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.MathArrays; @@ -145,14 +145,14 @@ public class KolmogorovSmirnovTest { @Deprecated protected static final int MONTE_CARLO_ITERATIONS = 1000000; - /** Random data generator used by {@link #monteCarloP(double, int, int, boolean, int)} */ - private final RandomGenerator rng; + @Deprecated + private final UniformRandomProvider rng; /** * Construct a KolmogorovSmirnovTest instance with a default random data generator. */ public KolmogorovSmirnovTest() { - rng = new Well19937c(); + rng = RandomSource.create(RandomSource.WELL_19937_C); } /** @@ -163,8 +163,9 @@ public class KolmogorovSmirnovTest { * @param rng random data generator used by {@link #monteCarloP(double, int, int, boolean, int)} */ @Deprecated - public KolmogorovSmirnovTest(RandomGenerator rng) { - this.rng = rng; + public KolmogorovSmirnovTest(RandomSource source, + long seed) { + rng = RandomSource.create(source, seed); } /** @@ -419,7 +420,7 @@ public class KolmogorovSmirnovTest { final double[] combined = new double[xLength + yLength]; System.arraycopy(x, 0, combined, 0, xLength); System.arraycopy(y, 0, combined, xLength, yLength); - final EnumeratedRealDistribution dist = new EnumeratedRealDistribution(rng, combined); + final RealDistribution.Sampler sampler = new EnumeratedRealDistribution(combined).createSampler(rng); final long d = integralKolmogorovSmirnovStatistic(x, y); int greaterCount = 0; int equalCount = 0; @@ -427,8 +428,8 @@ public class KolmogorovSmirnovTest { double[] curY; long curD; for (int i = 0; i < iterations; i++) { - curX = dist.sample(xLength); - curY = dist.sample(yLength); + curX = AbstractRealDistribution.sample(xLength, sampler); + curY = AbstractRealDistribution.sample(yLength, sampler); curD = integralKolmogorovSmirnovStatistic(curX, curY); if (curD > d) { greaterCount++; @@ -1041,7 +1042,7 @@ public class KolmogorovSmirnovTest { * @param numberOfTrueValues number of {@code true} values the boolean array should finally have * @param rng random data generator */ - static void fillBooleanArrayRandomlyWithFixedNumberTrueValues(final boolean[] b, final int numberOfTrueValues, final RandomGenerator rng) { + private static void fillBooleanArrayRandomlyWithFixedNumberTrueValues(final boolean[] b, final int numberOfTrueValues, final UniformRandomProvider rng) { Arrays.fill(b, true); for (int k = numberOfTrueValues; k < b.length; k++) { final int r = rng.nextInt(k + 1); @@ -1154,16 +1155,16 @@ public class KolmogorovSmirnovTest { // Add jitter using a fixed seed (so same arguments always give same results), // low-initialization-overhead generator - final RealDistribution dist = - new UniformRealDistribution(new JDKRandomGenerator(100), -minDelta, minDelta); + final RealDistribution.Sampler sampler = + new UniformRealDistribution(-minDelta, minDelta).createSampler(RandomSource.create(RandomSource.JDK, 100)); // It is theoretically possible that jitter does not break ties, so repeat // until all ties are gone. Bound the loop and throw MIE if bound is exceeded. int ct = 0; boolean ties = true; do { - jitter(x, dist); - jitter(y, dist); + jitter(x, sampler); + jitter(y, sampler); ties = hasTies(x, y); ct++; } while (ties && ct < 1000); @@ -1202,13 +1203,16 @@ public class KolmogorovSmirnovTest { * values are overwritten with the result of applying jitter.</p> * * @param data input/output data array - entries overwritten by the method - * @param dist probability distribution to sample for jitter values + * @param sampler probability distribution to sample for jitter values * @throws NullPointerException if either of the parameters is null */ - private static void jitter(double[] data, RealDistribution dist) { + private static void jitter(double[] data, RealDistribution.Sampler sampler) { for (int i = 0; i < data.length; i++) { - data[i] += dist.sample(); + final double d = sampler.sample(); + System.out.println("d=" + d); // XXX + data[i] += d; } + System.out.println(); // XXX } /** http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/stat/inference/MannWhitneyUTest.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/stat/inference/MannWhitneyUTest.java b/src/main/java/org/apache/commons/math4/stat/inference/MannWhitneyUTest.java index 3fa34a3..4452816 100644 --- a/src/main/java/org/apache/commons/math4/stat/inference/MannWhitneyUTest.java +++ b/src/main/java/org/apache/commons/math4/stat/inference/MannWhitneyUTest.java @@ -182,7 +182,7 @@ public class MannWhitneyUTest { // No try-catch or advertised exception because args are valid // pass a null rng to avoid unneeded overhead as we will not sample from this distribution - final NormalDistribution standardNormal = new NormalDistribution(null, 0, 1); + final NormalDistribution standardNormal = new NormalDistribution(0, 1); return 2 * standardNormal.cumulativeProbability(z); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/stat/inference/OneWayAnova.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/stat/inference/OneWayAnova.java b/src/main/java/org/apache/commons/math4/stat/inference/OneWayAnova.java index 90f4e96..1befaa2 100644 --- a/src/main/java/org/apache/commons/math4/stat/inference/OneWayAnova.java +++ b/src/main/java/org/apache/commons/math4/stat/inference/OneWayAnova.java @@ -127,7 +127,7 @@ public class OneWayAnova { final AnovaStats a = anovaStats(categoryData); // No try-catch or advertised exception because args are valid // pass a null rng to avoid unneeded overhead as we will not sample from this distribution - final FDistribution fdist = new FDistribution(null, a.dfbg, a.dfwg); + final FDistribution fdist = new FDistribution(a.dfbg, a.dfwg); return 1.0 - fdist.cumulativeProbability(a.F); } @@ -169,7 +169,7 @@ public class OneWayAnova { final AnovaStats a = anovaStats(categoryData, allowOneElementData); // pass a null rng to avoid unneeded overhead as we will not sample from this distribution - final FDistribution fdist = new FDistribution(null, a.dfbg, a.dfwg); + final FDistribution fdist = new FDistribution(a.dfbg, a.dfwg); return 1.0 - fdist.cumulativeProbability(a.F); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/stat/inference/TTest.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/stat/inference/TTest.java b/src/main/java/org/apache/commons/math4/stat/inference/TTest.java index 2168099..577ac29 100644 --- a/src/main/java/org/apache/commons/math4/stat/inference/TTest.java +++ b/src/main/java/org/apache/commons/math4/stat/inference/TTest.java @@ -1058,7 +1058,7 @@ public class TTest { final double t = FastMath.abs(t(m, mu, v, n)); // pass a null rng to avoid unneeded overhead as we will not sample from this distribution - final TDistribution distribution = new TDistribution(null, n - 1); + final TDistribution distribution = new TDistribution(n - 1); return 2.0 * distribution.cumulativeProbability(-t); } @@ -1088,7 +1088,7 @@ public class TTest { final double t = FastMath.abs(t(m1, m2, v1, v2, n1, n2)); final double degreesOfFreedom = df(v1, v2, n1, n2); // pass a null rng to avoid unneeded overhead as we will not sample from this distribution - final TDistribution distribution = new TDistribution(null, degreesOfFreedom); + final TDistribution distribution = new TDistribution(degreesOfFreedom); return 2.0 * distribution.cumulativeProbability(-t); } @@ -1118,7 +1118,7 @@ public class TTest { final double t = FastMath.abs(homoscedasticT(m1, m2, v1, v2, n1, n2)); final double degreesOfFreedom = n1 + n2 - 2; // pass a null rng to avoid unneeded overhead as we will not sample from this distribution - final TDistribution distribution = new TDistribution(null, degreesOfFreedom); + final TDistribution distribution = new TDistribution(degreesOfFreedom); return 2.0 * distribution.cumulativeProbability(-t); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/main/java/org/apache/commons/math4/stat/inference/WilcoxonSignedRankTest.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/stat/inference/WilcoxonSignedRankTest.java b/src/main/java/org/apache/commons/math4/stat/inference/WilcoxonSignedRankTest.java index 2bd303c..537d1c4 100644 --- a/src/main/java/org/apache/commons/math4/stat/inference/WilcoxonSignedRankTest.java +++ b/src/main/java/org/apache/commons/math4/stat/inference/WilcoxonSignedRankTest.java @@ -254,7 +254,7 @@ public class WilcoxonSignedRankTest { // No try-catch or advertised exception because args are valid // pass a null rng to avoid unneeded overhead as we will not sample from this distribution - final NormalDistribution standardNormal = new NormalDistribution(null, 0, 1); + final NormalDistribution standardNormal = new NormalDistribution(0, 1); return 2*standardNormal.cumulativeProbability(z); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/analysis/interpolation/AkimaSplineInterpolatorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/analysis/interpolation/AkimaSplineInterpolatorTest.java b/src/test/java/org/apache/commons/math4/analysis/interpolation/AkimaSplineInterpolatorTest.java index 15e4281..9eeb33a 100644 --- a/src/test/java/org/apache/commons/math4/analysis/interpolation/AkimaSplineInterpolatorTest.java +++ b/src/test/java/org/apache/commons/math4/analysis/interpolation/AkimaSplineInterpolatorTest.java @@ -20,13 +20,14 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import org.apache.commons.math4.analysis.UnivariateFunction; +import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.NonMonotonicSequenceException; import org.apache.commons.math4.exception.NullArgumentException; import org.apache.commons.math4.exception.NumberIsTooSmallException; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.Precision; import org.junit.Assert; @@ -212,9 +213,9 @@ public class AkimaSplineInterpolatorTest assertTrue( Precision.equals( expected, actual ) ); } - final RandomGenerator rng = new Well19937c( 1234567L ); // "tol" depends on the seed. - final UniformRealDistribution distX = - new UniformRealDistribution( rng, xValues[0], xValues[xValues.length - 1] ); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_C, 1234567L); // "tol" depends on the seed. + final RealDistribution.Sampler distX = + new UniformRealDistribution(xValues[0], xValues[xValues.length - 1]).createSampler(rng); double sumError = 0; for ( int i = 0; i < numberOfSamples; i++ ) http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunctionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunctionTest.java b/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunctionTest.java index 0ec77aa..105cf70 100644 --- a/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunctionTest.java +++ b/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunctionTest.java @@ -17,12 +17,13 @@ package org.apache.commons.math4.analysis.interpolation; import org.apache.commons.math4.analysis.BivariateFunction; +import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.MathIllegalArgumentException; import org.apache.commons.math4.exception.OutOfRangeException; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.Precision; import org.junit.Assert; @@ -360,9 +361,9 @@ public final class BicubicInterpolatingFunctionTest { } } - final RandomGenerator rng = new Well19937c(1234567L); - final UniformRealDistribution distX = new UniformRealDistribution(rng, xValues[0], xValues[xValues.length - 1]); - final UniformRealDistribution distY = new UniformRealDistribution(rng, yValues[0], yValues[yValues.length - 1]); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_C, 1234567L); + final RealDistribution.Sampler distX = new UniformRealDistribution(xValues[0], xValues[xValues.length - 1]).createSampler(rng); + final RealDistribution.Sampler distY = new UniformRealDistribution(yValues[0], yValues[yValues.length - 1]).createSampler(rng); double sumError = 0; for (int i = 0; i < numberOfSamples; i++) { http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatorTest.java b/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatorTest.java index 6a2a9d7..f88ec55 100644 --- a/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatorTest.java +++ b/src/test/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatorTest.java @@ -17,11 +17,12 @@ package org.apache.commons.math4.analysis.interpolation; import org.apache.commons.math4.analysis.BivariateFunction; +import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.MathIllegalArgumentException; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.junit.Assert; import org.junit.Test; @@ -146,9 +147,9 @@ public final class BicubicInterpolatorTest { final BicubicInterpolatingFunction p = interpolator.interpolate(xval, yval, zval); double x, y; - final RandomGenerator rng = new Well19937c(); - final UniformRealDistribution distX = new UniformRealDistribution(rng, xval[0], xval[xval.length - 1]); - final UniformRealDistribution distY = new UniformRealDistribution(rng, yval[0], yval[yval.length - 1]); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_C); + final RealDistribution.Sampler distX = new UniformRealDistribution(xval[0], xval[xval.length - 1]).createSampler(rng); + final RealDistribution.Sampler distY = new UniformRealDistribution(yval[0], yval[yval.length - 1]).createSampler(rng); int count = 0; while (true) { http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java b/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java index c6701b3..48ff9a0 100644 --- a/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java +++ b/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java @@ -17,13 +17,14 @@ package org.apache.commons.math4.analysis.interpolation; import org.apache.commons.math4.analysis.BivariateFunction; +import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.InsufficientDataException; import org.apache.commons.math4.exception.NonMonotonicSequenceException; import org.apache.commons.math4.exception.NullArgumentException; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.Precision; import org.junit.Assert; @@ -175,7 +176,7 @@ public final class PiecewiseBicubicSplineInterpolatingFunctionTest { final double maximumY = 10; final int numberOfSamples = 100; - final double interpolationTolerance = 2e-14; + final double interpolationTolerance = 1e-13; final double maxTolerance = 6e-14; // Function values @@ -250,9 +251,9 @@ public final class PiecewiseBicubicSplineInterpolatingFunctionTest { } } - final RandomGenerator rng = new Well19937c(1234567L); - final UniformRealDistribution distX = new UniformRealDistribution(rng, xValues[0], xValues[xValues.length - 1]); - final UniformRealDistribution distY = new UniformRealDistribution(rng, yValues[0], yValues[yValues.length - 1]); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_C, 1234567L); + final RealDistribution.Sampler distX = new UniformRealDistribution(xValues[0], xValues[xValues.length - 1]).createSampler(rng); + final RealDistribution.Sampler distY = new UniformRealDistribution(yValues[0], yValues[yValues.length - 1]).createSampler(rng); double sumError = 0; for (int i = 0; i < numberOfSamples; i++) { http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java b/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java index 1645294..69bd8b4 100644 --- a/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java +++ b/src/test/java/org/apache/commons/math4/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java @@ -17,13 +17,14 @@ package org.apache.commons.math4.analysis.interpolation; import org.apache.commons.math4.analysis.BivariateFunction; +import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.InsufficientDataException; import org.apache.commons.math4.exception.NonMonotonicSequenceException; import org.apache.commons.math4.exception.NullArgumentException; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.junit.Assert; import org.junit.Test; @@ -157,9 +158,9 @@ public final class PiecewiseBicubicSplineInterpolatorTest { BivariateFunction p = interpolator.interpolate(xval, yval, zval); double x, y; - final RandomGenerator rng = new Well19937c(1234567L); // "tol" depends on the seed. - final UniformRealDistribution distX = new UniformRealDistribution( rng, xval[0], xval[xval.length - 1] ); - final UniformRealDistribution distY = new UniformRealDistribution( rng, yval[0], yval[yval.length - 1] ); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_C, 1234567L); + final RealDistribution.Sampler distX = new UniformRealDistribution(xval[0], xval[xval.length - 1]).createSampler(rng); + final RealDistribution.Sampler distY = new UniformRealDistribution(yval[0], yval[yval.length - 1]).createSampler(rng); final int numSamples = 50; final double tol = 2e-14; @@ -209,9 +210,9 @@ public final class PiecewiseBicubicSplineInterpolatorTest { BivariateFunction p = interpolator.interpolate(xval, yval, zval); double x, y; - final RandomGenerator rng = new Well19937c(1234567L); // "tol" depends on the seed. - final UniformRealDistribution distX = new UniformRealDistribution( rng, xval[0], xval[xval.length - 1] ); - final UniformRealDistribution distY = new UniformRealDistribution( rng, yval[0], yval[yval.length - 1] ); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_C, 1234567L); + final RealDistribution.Sampler distX = new UniformRealDistribution(xval[0], xval[xval.length - 1]).createSampler(rng); + final RealDistribution.Sampler distY = new UniformRealDistribution(yval[0], yval[yval.length - 1]).createSampler(rng); final int numSamples = 50; final double tol = 5e-13; http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/analysis/interpolation/TricubicInterpolatingFunctionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/analysis/interpolation/TricubicInterpolatingFunctionTest.java b/src/test/java/org/apache/commons/math4/analysis/interpolation/TricubicInterpolatingFunctionTest.java index 44f06a0..deac81f 100644 --- a/src/test/java/org/apache/commons/math4/analysis/interpolation/TricubicInterpolatingFunctionTest.java +++ b/src/test/java/org/apache/commons/math4/analysis/interpolation/TricubicInterpolatingFunctionTest.java @@ -17,11 +17,12 @@ package org.apache.commons.math4.analysis.interpolation; import org.apache.commons.math4.analysis.TrivariateFunction; +import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.MathIllegalArgumentException; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.Precision; import org.junit.Assert; @@ -379,10 +380,10 @@ public final class TricubicInterpolatingFunctionTest { } } - final RandomGenerator rng = new Well19937c(1234567L); - final UniformRealDistribution distX = new UniformRealDistribution(rng, xValues[0], xValues[xValues.length - 1]); - final UniformRealDistribution distY = new UniformRealDistribution(rng, yValues[0], yValues[yValues.length - 1]); - final UniformRealDistribution distZ = new UniformRealDistribution(rng, zValues[0], zValues[zValues.length - 1]); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_C, 1234568L); + final RealDistribution.Sampler distX = new UniformRealDistribution(xValues[0], xValues[xValues.length - 1]).createSampler(rng); + final RealDistribution.Sampler distY = new UniformRealDistribution(yValues[0], yValues[yValues.length - 1]).createSampler(rng); + final RealDistribution.Sampler distZ = new UniformRealDistribution(zValues[0], zValues[zValues.length - 1]).createSampler(rng); double sumError = 0; for (int i = 0; i < numberOfSamples; i++) { http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/distribution/AbstractRealDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/AbstractRealDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/AbstractRealDistributionTest.java index cff0c08..449f4a6 100644 --- a/src/test/java/org/apache/commons/math4/distribution/AbstractRealDistributionTest.java +++ b/src/test/java/org/apache/commons/math4/distribution/AbstractRealDistributionTest.java @@ -35,7 +35,7 @@ public class AbstractRealDistributionTest { final double x3 = 3.0; final double p12 = 0.5; final AbstractRealDistribution distribution; - distribution = new AbstractRealDistribution(null) { + distribution = new AbstractRealDistribution() { private static final long serialVersionUID = 1L; @Override @@ -119,7 +119,7 @@ public class AbstractRealDistributionTest { final double p12 = 1.0 / 3.0; final double p23 = 2.0 / 3.0; final AbstractRealDistribution distribution; - distribution = new AbstractRealDistribution(null) { + distribution = new AbstractRealDistribution() { private static final long serialVersionUID = 1L; @Override http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java index 373271d..5127503 100644 --- a/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java +++ b/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java @@ -346,8 +346,6 @@ public class BetaDistributionTest { public void testGoodnessOfFit() { final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_A, 123456789L); - final RandomGenerator random = new Well19937a(0x237db1db907b089fL); - final int numSamples = 1000; final double level = 0.01; for (final double alpha : alphaBetas) { @@ -360,7 +358,7 @@ public class BetaDistributionTest { Assert.assertFalse("G goodness-of-fit test rejected null at alpha = " + level, gTest(betaDistribution, observed) < level); Assert.assertFalse("KS goodness-of-fit test rejected null at alpha = " + level, - new KolmogorovSmirnovTest(random).kolmogorovSmirnovTest(betaDistribution, observed) < level); + new KolmogorovSmirnovTest(RandomSource.JDK, 3448845623L).kolmogorovSmirnovTest(betaDistribution, observed) < level); } } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java index 211a670..a2c7706 100644 --- a/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java +++ b/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java @@ -84,15 +84,6 @@ public class ConstantRealDistributionTest extends RealDistributionAbstractTest { @Test @Override - public void testSampling() { - ConstantRealDistribution dist = new ConstantRealDistribution(0); - for (int i = 0; i < 10; i++) { - Assert.assertEquals(0, dist.sample(), 0); - } - } - - @Test - @Override public void testSampler() { final double value = 12.345; final RealDistribution.Sampler sampler = new ConstantRealDistribution(value).createSampler(null); http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/distribution/EnumeratedRealDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/EnumeratedRealDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/EnumeratedRealDistributionTest.java index 0300e5e..7cfebf7 100644 --- a/src/test/java/org/apache/commons/math4/distribution/EnumeratedRealDistributionTest.java +++ b/src/test/java/org/apache/commons/math4/distribution/EnumeratedRealDistributionTest.java @@ -30,6 +30,7 @@ import org.apache.commons.math4.exception.NotFiniteNumberException; import org.apache.commons.math4.exception.NotPositiveException; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.Pair; +import org.apache.commons.math4.rng.UniformRandomProvider; import org.apache.commons.math4.rng.RandomSource; import org.junit.Assert; import org.junit.Test; @@ -197,7 +198,8 @@ public class EnumeratedRealDistributionTest { List<Pair<Object,Double>> list = new ArrayList<Pair<Object, Double>>(); list.add(new Pair<Object, Double>(new Object() {}, new Double(0))); list.add(new Pair<Object, Double>(new Object() {}, new Double(1))); - Assert.assertEquals(1, new EnumeratedDistribution<Object>(list).sample(1).length); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_512_A); + Assert.assertEquals(1, new EnumeratedDistribution<Object>(list).createSampler(rng).sample(1).length); } @Test http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/distribution/LevyDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/LevyDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/LevyDistributionTest.java index d0af056..659e418 100644 --- a/src/test/java/org/apache/commons/math4/distribution/LevyDistributionTest.java +++ b/src/test/java/org/apache/commons/math4/distribution/LevyDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.math4.distribution; import org.apache.commons.math4.distribution.LevyDistribution; -import org.apache.commons.math4.random.Well19937a; import org.apache.commons.math4.util.Precision; import org.junit.Assert; import org.junit.Test; @@ -41,7 +40,7 @@ public class LevyDistributionTest extends RealDistributionAbstractTest { @Override public LevyDistribution makeDistribution() { - return new LevyDistribution(new Well19937a(0xc5a5506bbb17e57al), 1.2, 0.4); + return new LevyDistribution(1.2, 0.4); } @Override http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/distribution/RealDistributionAbstractTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/RealDistributionAbstractTest.java b/src/test/java/org/apache/commons/math4/distribution/RealDistributionAbstractTest.java index 61d01ff..7d9db82 100644 --- a/src/test/java/org/apache/commons/math4/distribution/RealDistributionAbstractTest.java +++ b/src/test/java/org/apache/commons/math4/distribution/RealDistributionAbstractTest.java @@ -327,22 +327,6 @@ public abstract class RealDistributionAbstractTest { * Test sampling */ @Test - public void testSampling() { - final int sampleSize = 1000; - distribution.reseedRandomGenerator(1000); // Use fixed seed - double[] sample = distribution.sample(sampleSize); - double[] quartiles = TestUtils.getDistributionQuartiles(distribution); - double[] expected = {250, 250, 250, 250}; - long[] counts = new long[4]; - for (int i = 0; i < sampleSize; i++) { - TestUtils.updateCounts(sample[i], counts, quartiles); - } - TestUtils.assertChiSquareAccept(expected, counts, 0.001); - } - - - // New design - @Test public void testSampler() { final int sampleSize = 1000; final RealDistribution.Sampler sampler = @@ -403,16 +387,18 @@ public abstract class RealDistributionAbstractTest { ClassNotFoundException { // Construct a distribution and initialize its internal random // generator, using a fixed seed for deterministic results. - distribution.reseedRandomGenerator(123); - distribution.sample(); + final long seed = 123; + RandomSource source = RandomSource.WELL_512_A; + RealDistribution.Sampler origSampler = distribution.createSampler(RandomSource.create(source, seed)); // Clone the distribution. final RealDistribution cloned = deepClone(); + RealDistribution.Sampler clonedSampler = cloned.createSampler(RandomSource.create(source, seed)); // Make sure they still produce the same samples. - final double s1 = distribution.sample(); - final double s2 = cloned.sample(); - Assert.assertEquals(s1, s2, 0d); + Assert.assertEquals(origSampler.sample(), + clonedSampler.sample(), + 0d); } //------------------ Getters / Setters for test instance data ----------- http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/filter/KalmanFilterTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/filter/KalmanFilterTest.java b/src/test/java/org/apache/commons/math4/filter/KalmanFilterTest.java index 99d73c5..2db564d 100644 --- a/src/test/java/org/apache/commons/math4/filter/KalmanFilterTest.java +++ b/src/test/java/org/apache/commons/math4/filter/KalmanFilterTest.java @@ -14,6 +14,7 @@ package org.apache.commons.math4.filter; +import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.NormalDistribution; import org.apache.commons.math4.filter.DefaultMeasurementModel; import org.apache.commons.math4.filter.DefaultProcessModel; @@ -26,9 +27,10 @@ import org.apache.commons.math4.linear.MatrixDimensionMismatchException; import org.apache.commons.math4.linear.MatrixUtils; import org.apache.commons.math4.linear.RealMatrix; import org.apache.commons.math4.linear.RealVector; -import org.apache.commons.math4.random.JDKRandomGenerator; import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well19937c; +import org.apache.commons.math4.random.JDKRandomGenerator; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.Precision; import org.junit.Assert; @@ -392,8 +394,8 @@ public class KalmanFilterTest { final MeasurementModel mm = new DefaultMeasurementModel(H, R); final KalmanFilter filter = new KalmanFilter(pm, mm); - final RandomGenerator rng = new Well19937c(1000); - final NormalDistribution dist = new NormalDistribution(rng, 0, measurementNoise); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_C, 1000); + final RealDistribution.Sampler dist = new NormalDistribution(0, measurementNoise).createSampler(rng); for (int i = 0; i < iterations; i++) { // get the "real" cannonball position http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java b/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java index 6198eb7..5c0ebd9 100644 --- a/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java +++ b/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java @@ -262,7 +262,7 @@ public class LevenbergMarquardtOptimizerTest final double ySigma = 15; final double radius = 111.111; // The test is extremely sensitive to the seed. - final long seed = 59421061L; + final long seed = 59321761412L; final RandomCirclePointGenerator factory = new RandomCirclePointGenerator(xCenter, yCenter, radius, xSigma, ySigma, http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java b/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java index 8bc8569..59dd8af 100644 --- a/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java +++ b/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java @@ -20,8 +20,8 @@ import org.apache.commons.math4.distribution.NormalDistribution; import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; import org.apache.commons.math4.geometry.euclidean.twod.Vector2D; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well44497b; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.MathUtils; @@ -30,11 +30,11 @@ import org.apache.commons.math4.util.MathUtils; */ public class RandomCirclePointGenerator { /** RNG for the x-coordinate of the center. */ - private final RealDistribution cX; + private final RealDistribution.Sampler cX; /** RNG for the y-coordinate of the center. */ - private final RealDistribution cY; + private final RealDistribution.Sampler cY; /** RNG for the parametric position of the point. */ - private final RealDistribution tP; + private final RealDistribution.Sampler tP; /** Radius of the circle. */ private final double radius; @@ -52,13 +52,11 @@ public class RandomCirclePointGenerator { double xSigma, double ySigma, long seed) { - final RandomGenerator rng = new Well44497b(seed); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_44497_B, seed); this.radius = radius; - cX = new NormalDistribution(rng, x, xSigma, - NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY); - cY = new NormalDistribution(rng, y, ySigma, - NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY); - tP = new UniformRealDistribution(rng, 0, MathUtils.TWO_PI); + cX = new NormalDistribution(x, xSigma).createSampler(rng); + cY = new NormalDistribution(y, ySigma).createSampler(rng); + tP = new UniformRealDistribution(0, MathUtils.TWO_PI).createSampler(rng); } /** http://git-wip-us.apache.org/repos/asf/commons-math/blob/9867d9f2/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomStraightLinePointGenerator.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomStraightLinePointGenerator.java b/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomStraightLinePointGenerator.java index 024f561..beff240 100644 --- a/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomStraightLinePointGenerator.java +++ b/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomStraightLinePointGenerator.java @@ -22,8 +22,8 @@ import java.awt.geom.Point2D; import org.apache.commons.math4.distribution.NormalDistribution; import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; -import org.apache.commons.math4.random.RandomGenerator; -import org.apache.commons.math4.random.Well44497b; +import org.apache.commons.math4.rng.UniformRandomProvider; +import org.apache.commons.math4.rng.RandomSource; /** * Factory for generating a cloud of points that approximate a straight line. @@ -34,9 +34,9 @@ public class RandomStraightLinePointGenerator { /** Intercept. */ private final double intercept; /** RNG for the x-coordinate. */ - private final RealDistribution x; + private final RealDistribution.Sampler x; /** RNG for the error on the y-coordinate. */ - private final RealDistribution error; + private final RealDistribution.Sampler error; /** * The generator will create a cloud of points whose x-coordinates @@ -61,12 +61,11 @@ public class RandomStraightLinePointGenerator { double lo, double hi, long seed) { - final RandomGenerator rng = new Well44497b(seed); + final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_44497_B, seed); slope = a; intercept = b; - error = new NormalDistribution(rng, 0, sigma, - NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY); - x = new UniformRealDistribution(rng, lo, hi); + error = new NormalDistribution(0, sigma).createSampler(rng); + x = new UniformRealDistribution(lo, hi).createSampler(rng); } /**
