This is an automated email from the ASF dual-hosted git repository.

aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-math.git


The following commit(s) were added to refs/heads/master by this push:
     new aa58ab0  Updated tests to use factory constructors for Statistics 
distributions
aa58ab0 is described below

commit aa58ab0fd6229532ef29302342f9086f5e1a8dc8
Author: aherbert <aherb...@apache.org>
AuthorDate: Wed Oct 13 14:20:47 2021 +0100

    Updated tests to use factory constructors for Statistics distributions
---
 .../analysis/interpolation/AkimaSplineInterpolatorTest.java  |  2 +-
 .../interpolation/BicubicInterpolatingFunctionTest.java      |  4 ++--
 .../analysis/interpolation/BicubicInterpolatorTest.java      |  4 ++--
 .../PiecewiseBicubicSplineInterpolatingFunctionTest.java     |  4 ++--
 .../PiecewiseBicubicSplineInterpolatorTest.java              |  8 ++++----
 .../interpolation/TricubicInterpolatingFunctionTest.java     |  6 +++---
 .../math4/legacy/distribution/EmpiricalDistributionTest.java |  8 ++++----
 .../distribution/MultivariateNormalDistributionTest.java     |  2 +-
 .../math4/legacy/fitting/PolynomialCurveFitterTest.java      |  2 +-
 .../commons/math4/legacy/fitting/SimpleCurveFitterTest.java  |  2 +-
 .../fitting/leastsquares/RandomCirclePointGenerator.java     |  6 +++---
 .../leastsquares/RandomStraightLinePointGenerator.java       |  4 ++--
 .../commons/math4/legacy/linear/EigenDecompositionTest.java  |  2 +-
 .../math4/legacy/linear/HessenbergTransformerTest.java       |  2 +-
 .../commons/math4/legacy/linear/SchurTransformerTest.java    |  2 +-
 .../legacy/stat/correlation/PearsonsCorrelationTest.java     |  2 +-
 .../stat/descriptive/AggregateSummaryStatisticsTest.java     |  6 +++---
 .../legacy/stat/descriptive/ResizableDoubleArrayTest.java    |  4 ++--
 .../stat/descriptive/UnivariateStatisticAbstractTest.java    |  4 ++--
 .../legacy/stat/descriptive/rank/PSquarePercentileTest.java  |  8 ++++----
 .../math4/legacy/stat/descriptive/rank/PercentileTest.java   |  2 +-
 .../math4/legacy/stat/inference/InferenceTestUtilsTest.java  |  2 +-
 .../legacy/stat/inference/KolmogorovSmirnovTestTest.java     | 12 ++++++------
 .../stat/regression/GLSMultipleLinearRegressionTest.java     |  2 +-
 24 files changed, 50 insertions(+), 50 deletions(-)

diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolatorTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolatorTest.java
index 518242d..f10f58a 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolatorTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolatorTest.java
@@ -220,7 +220,7 @@ public class AkimaSplineInterpolatorTest {
 
         final UniformRandomProvider rng = 
RandomSource.WELL_19937_C.create(1234567L); // "tol" depends on the seed.
         final ContinuousDistribution.Sampler distX =
-            new UniformContinuousDistribution(xValues[0], 
xValues[xValues.length - 1]).createSampler(rng);
+            UniformContinuousDistribution.of(xValues[0], 
xValues[xValues.length - 1]).createSampler(rng);
 
         double sumError = 0;
         for (int i = 0; i < numberOfSamples; i++) {
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatingFunctionTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatingFunctionTest.java
index 1c08d3a..a974ab2 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatingFunctionTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatingFunctionTest.java
@@ -360,8 +360,8 @@ public final class BicubicInterpolatingFunctionTest {
         }
 
         final UniformRandomProvider rng = 
RandomSource.WELL_19937_C.create(1234567L);
-        final ContinuousDistribution.Sampler distX = new 
UniformContinuousDistribution(xValues[0], xValues[xValues.length - 
1]).createSampler(rng);
-        final ContinuousDistribution.Sampler distY = new 
UniformContinuousDistribution(yValues[0], yValues[yValues.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distX = 
UniformContinuousDistribution.of(xValues[0], xValues[xValues.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distY = 
UniformContinuousDistribution.of(yValues[0], yValues[yValues.length - 
1]).createSampler(rng);
 
         double sumError = 0;
         for (int i = 0; i < numberOfSamples; i++) {
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatorTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatorTest.java
index 14f2234..6e2058c 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatorTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatorTest.java
@@ -147,8 +147,8 @@ public final class BicubicInterpolatorTest {
         final BicubicInterpolatingFunction p = interpolator.interpolate(xval, 
yval, zval);
 
         final UniformRandomProvider rng = RandomSource.WELL_19937_C.create();
-        final ContinuousDistribution.Sampler distX = new 
UniformContinuousDistribution(xval[0], xval[xval.length - 
1]).createSampler(rng);
-        final ContinuousDistribution.Sampler distY = new 
UniformContinuousDistribution(yval[0], yval[yval.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distX = 
UniformContinuousDistribution.of(xval[0], xval[xval.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distY = 
UniformContinuousDistribution.of(yval[0], yval[yval.length - 
1]).createSampler(rng);
 
         int count = 0;
         while (true) {
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java
index 6e2f386..71fa711 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java
@@ -252,8 +252,8 @@ public final class 
PiecewiseBicubicSplineInterpolatingFunctionTest {
         }
 
         final UniformRandomProvider rng = 
RandomSource.WELL_19937_C.create(1234567L);
-        final ContinuousDistribution.Sampler distX = new 
UniformContinuousDistribution(xValues[0], xValues[xValues.length - 
1]).createSampler(rng);
-        final ContinuousDistribution.Sampler distY = new 
UniformContinuousDistribution(yValues[0], yValues[yValues.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distX = 
UniformContinuousDistribution.of(xValues[0], xValues[xValues.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distY = 
UniformContinuousDistribution.of(yValues[0], yValues[yValues.length - 
1]).createSampler(rng);
 
         double sumError = 0;
         for (int i = 0; i < numberOfSamples; i++) {
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java
index eccb6d3..9c11618 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatorTest.java
@@ -160,8 +160,8 @@ public final class PiecewiseBicubicSplineInterpolatorTest {
         double y;
 
         final UniformRandomProvider rng = 
RandomSource.WELL_19937_C.create(1234567L);
-        final ContinuousDistribution.Sampler distX = new 
UniformContinuousDistribution(xval[0], xval[xval.length - 
1]).createSampler(rng);
-        final ContinuousDistribution.Sampler distY = new 
UniformContinuousDistribution(yval[0], yval[yval.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distX = 
UniformContinuousDistribution.of(xval[0], xval[xval.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distY = 
UniformContinuousDistribution.of(yval[0], yval[yval.length - 
1]).createSampler(rng);
 
         final int numSamples = 50;
         final double tol = 2e-14;
@@ -213,8 +213,8 @@ public final class PiecewiseBicubicSplineInterpolatorTest {
         double y;
 
         final UniformRandomProvider rng = 
RandomSource.WELL_19937_C.create(1234567L);
-        final ContinuousDistribution.Sampler distX = new 
UniformContinuousDistribution(xval[0], xval[xval.length - 
1]).createSampler(rng);
-        final ContinuousDistribution.Sampler distY = new 
UniformContinuousDistribution(yval[0], yval[yval.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distX = 
UniformContinuousDistribution.of(xval[0], xval[xval.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distY = 
UniformContinuousDistribution.of(yval[0], yval[yval.length - 
1]).createSampler(rng);
 
         final int numSamples = 50;
         final double tol = 5e-13;
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunctionTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunctionTest.java
index 23560e9..87f7036 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunctionTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunctionTest.java
@@ -381,9 +381,9 @@ public final class TricubicInterpolatingFunctionTest {
         }
 
         final UniformRandomProvider rng = 
RandomSource.WELL_19937_C.create(1234568L);
-        final ContinuousDistribution.Sampler distX = new 
UniformContinuousDistribution(xValues[0], xValues[xValues.length - 
1]).createSampler(rng);
-        final ContinuousDistribution.Sampler distY = new 
UniformContinuousDistribution(yValues[0], yValues[yValues.length - 
1]).createSampler(rng);
-        final ContinuousDistribution.Sampler distZ = new 
UniformContinuousDistribution(zValues[0], zValues[zValues.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distX = 
UniformContinuousDistribution.of(xValues[0], xValues[xValues.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distY = 
UniformContinuousDistribution.of(yValues[0], yValues[yValues.length - 
1]).createSampler(rng);
+        final ContinuousDistribution.Sampler distZ = 
UniformContinuousDistribution.of(zValues[0], zValues[zValues.length - 
1]).createSampler(rng);
 
         double sumError = 0;
         for (int i = 0; i < numberOfSamples; i++) {
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistributionTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistributionTest.java
index addd94a..a168e36 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistributionTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistributionTest.java
@@ -381,9 +381,9 @@ public final class EmpiricalDistributionTest extends 
RealDistributionAbstractTes
      */
     private ContinuousDistribution findKernel(double lower, double upper) {
         if (lower < 1) {
-            return new NormalDistribution(5d, 3.3166247903554);
+            return NormalDistribution.of(5d, 3.3166247903554);
         } else {
-            return new NormalDistribution((upper + lower + 1) / 2d, 
3.0276503540974917);
+            return NormalDistribution.of((upper + lower + 1) / 2d, 
3.0276503540974917);
         }
     }
 
@@ -392,7 +392,7 @@ public final class EmpiricalDistributionTest extends 
RealDistributionAbstractTes
         final double[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 
15};
         final EmpiricalDistribution dist =
             EmpiricalDistribution.from(5, data,
-                                       s -> new 
UniformContinuousDistribution(s.getMin(), s.getMax()));
+                                       s -> 
UniformContinuousDistribution.of(s.getMin(), s.getMax()));
         final ContinuousDistribution.Sampler sampler
             = dist.createSampler(RandomSource.WELL_19937_C.create(1000));
         // Kernels are uniform distributions on [1,3], [4,6], [7,9], [10,12], 
[13,15]
@@ -424,7 +424,7 @@ public final class EmpiricalDistributionTest extends 
RealDistributionAbstractTes
     public void testMath1431() {
         final UniformRandomProvider rng = 
RandomSource.WELL_19937_C.create(1000);
         final ContinuousDistribution.Sampler exponentialDistributionSampler
-            = new ExponentialDistribution(0.05).createSampler(rng);
+            = ExponentialDistribution.of(0.05).createSampler(rng);
         final double[] empiricalDataPoints = new double[3000];
         for (int i = 0; i < empiricalDataPoints.length; i++) {
             empiricalDataPoints[i] = exponentialDistributionSampler.sample();
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/MultivariateNormalDistributionTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/MultivariateNormalDistributionTest.java
index 0cf6d9e..31c5af4 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/MultivariateNormalDistributionTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/MultivariateNormalDistributionTest.java
@@ -144,7 +144,7 @@ public class MultivariateNormalDistributionTest {
 
         final MultivariateNormalDistribution multi = new 
MultivariateNormalDistribution(mu, sigma);
 
-        final NormalDistribution uni = new NormalDistribution(mu[0], 
sigma[0][0]);
+        final NormalDistribution uni = NormalDistribution.of(mu[0], 
sigma[0][0]);
         final Random rng = new Random();
         final int numCases = 100;
         final double tol = Math.ulp(1d);
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/PolynomialCurveFitterTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/PolynomialCurveFitterTest.java
index 64eaefa..79ec3cf 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/PolynomialCurveFitterTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/PolynomialCurveFitterTest.java
@@ -35,7 +35,7 @@ public class PolynomialCurveFitterTest {
     @Test
     public void testFit() {
         final ContinuousDistribution.Sampler rng
-            = new UniformContinuousDistribution(-100, 
100).createSampler(RandomSource.WELL_512_A.create(64925784252L));
+            = UniformContinuousDistribution.of(-100, 
100).createSampler(RandomSource.WELL_512_A.create(64925784252L));
         final double[] coeff = { 12.9, -3.4, 2.1 }; // 12.9 - 3.4 x + 2.1 x^2
         final PolynomialFunction f = new PolynomialFunction(coeff);
 
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/SimpleCurveFitterTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/SimpleCurveFitterTest.java
index c520196..e941412 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/SimpleCurveFitterTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/SimpleCurveFitterTest.java
@@ -34,7 +34,7 @@ public class SimpleCurveFitterTest {
     public void testPolynomialFit() {
         final Random randomizer = new Random(53882150042L);
         final ContinuousDistribution.Sampler rng
-            = new UniformContinuousDistribution(-100, 
100).createSampler(RandomSource.WELL_512_A.create(64925784253L));
+            = UniformContinuousDistribution.of(-100, 
100).createSampler(RandomSource.WELL_512_A.create(64925784253L));
 
         final double[] coeff = { 12.9, -3.4, 2.1 }; // 12.9 - 3.4 x + 2.1 x^2
         final PolynomialFunction f = new PolynomialFunction(coeff);
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomCirclePointGenerator.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomCirclePointGenerator.java
index 1e32e17..5437544 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomCirclePointGenerator.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomCirclePointGenerator.java
@@ -51,9 +51,9 @@ public class RandomCirclePointGenerator {
                                       double ySigma) {
         final UniformRandomProvider rng = RandomSource.WELL_44497_B.create();
         this.radius = radius;
-        cX = new NormalDistribution(x, xSigma).createSampler(rng);
-        cY = new NormalDistribution(y, ySigma).createSampler(rng);
-        tP = new UniformContinuousDistribution(0, 2 * 
Math.PI).createSampler(rng);
+        cX = NormalDistribution.of(x, xSigma).createSampler(rng);
+        cY = NormalDistribution.of(y, ySigma).createSampler(rng);
+        tP = UniformContinuousDistribution.of(0, 2 * 
Math.PI).createSampler(rng);
     }
 
     /**
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomStraightLinePointGenerator.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomStraightLinePointGenerator.java
index 7b35d4b..589f149 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomStraightLinePointGenerator.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomStraightLinePointGenerator.java
@@ -64,8 +64,8 @@ public class RandomStraightLinePointGenerator {
         final UniformRandomProvider rng = 
RandomSource.WELL_44497_B.create(seed);
         slope = a;
         intercept = b;
-        error = new NormalDistribution(0, sigma).createSampler(rng);
-        x = new UniformContinuousDistribution(lo, hi).createSampler(rng);
+        error = NormalDistribution.of(0, sigma).createSampler(rng);
+        x = UniformContinuousDistribution.of(lo, hi).createSampler(rng);
     }
 
     /**
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/EigenDecompositionTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/EigenDecompositionTest.java
index 8b7698b..092e48e 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/EigenDecompositionTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/EigenDecompositionTest.java
@@ -464,7 +464,7 @@ public class EigenDecompositionTest {
         for (int run = 0; run < 100; run++) {
             Random r = new Random(System.currentTimeMillis());
             ContinuousDistribution.Sampler dist
-                = new NormalDistribution(0.0, r.nextDouble() * 
5).createSampler(RandomSource.WELL_512_A.create(64925784252L));
+                = NormalDistribution.of(0.0, r.nextDouble() * 
5).createSampler(RandomSource.WELL_512_A.create(64925784252L));
 
             // matrix size
             int size = r.nextInt(20) + 4;
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/HessenbergTransformerTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/HessenbergTransformerTest.java
index 2ec49d3..ba7c485 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/HessenbergTransformerTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/HessenbergTransformerTest.java
@@ -111,7 +111,7 @@ public class HessenbergTransformerTest {
         for (int run = 0; run < 100; run++) {
             Random r = new Random(System.currentTimeMillis());
             ContinuousDistribution.Sampler dist
-                = new NormalDistribution(0.0, r.nextDouble() * 
5).createSampler(RandomSource.WELL_512_A.create(64925784252L));
+                = NormalDistribution.of(0.0, r.nextDouble() * 
5).createSampler(RandomSource.WELL_512_A.create(64925784252L));
 
             // matrix size
             int size = r.nextInt(20) + 4;
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/SchurTransformerTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/SchurTransformerTest.java
index 8085f0c..dd1f6d0 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/SchurTransformerTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/SchurTransformerTest.java
@@ -115,7 +115,7 @@ public class SchurTransformerTest {
         for (int run = 0; run < 100; run++) {
             Random r = new Random(System.currentTimeMillis());
             ContinuousDistribution.Sampler dist
-                = new NormalDistribution(0.0, r.nextDouble() * 
5).createSampler(RandomSource.WELL_512_A.create(64925784252L));
+                = NormalDistribution.of(0.0, r.nextDouble() * 
5).createSampler(RandomSource.WELL_512_A.create(64925784252L));
 
             // matrix size
             int size = r.nextInt(20) + 4;
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelationTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelationTest.java
index 130e867..1b503fe 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelationTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelationTest.java
@@ -228,7 +228,7 @@ public class PearsonsCorrelationTest {
      */
     @Test
     public void testStdErrorConsistency() {
-        TDistribution tDistribution = new TDistribution(45);
+        TDistribution tDistribution = TDistribution.of(45);
         RealMatrix matrix = createRealMatrix(swissData, 47, 5);
         PearsonsCorrelation corrInstance = new PearsonsCorrelation(matrix);
         RealMatrix rValues = corrInstance.getCorrelationMatrix();
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/AggregateSummaryStatisticsTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/AggregateSummaryStatisticsTest.java
index 23f1835..b8aebf8 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/AggregateSummaryStatisticsTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/AggregateSummaryStatisticsTest.java
@@ -283,9 +283,9 @@ public class AggregateSummaryStatisticsTest {
      */
     private double[] generateSample() {
         final DiscreteDistribution.Sampler size =
-            new UniformDiscreteDistribution(10, 
100).createSampler(RandomSource.WELL_512_A.create(327652));
+            UniformDiscreteDistribution.of(10, 
100).createSampler(RandomSource.WELL_512_A.create(327652));
         final ContinuousDistribution.Sampler randomData
-            = new UniformContinuousDistribution(-100, 
100).createSampler(RandomSource.WELL_512_A.create(64925784252L));
+            = UniformContinuousDistribution.of(-100, 
100).createSampler(RandomSource.WELL_512_A.create(64925784252L));
         final int sampleSize = size.sample();
         final double[] out = AbstractRealDistribution.sample(sampleSize, 
randomData);
         return out;
@@ -313,7 +313,7 @@ public class AggregateSummaryStatisticsTest {
                 next = length - 1;
             } else {
                 final DiscreteDistribution.Sampler sampler =
-                    new UniformDiscreteDistribution(cur, length - 
1).createSampler(RandomSource.WELL_512_A.create());
+                    UniformDiscreteDistribution.of(cur, length - 
1).createSampler(RandomSource.WELL_512_A.create());
                 next = sampler.sample();
             }
             final int subLength = next - cur + 1;
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/ResizableDoubleArrayTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/ResizableDoubleArrayTest.java
index 86a0734..abc6f5c 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/ResizableDoubleArrayTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/ResizableDoubleArrayTest.java
@@ -324,7 +324,7 @@ public class ResizableDoubleArrayTest extends 
DoubleArrayAbstractTest {
         Assert.assertEquals("Initial number of elements should be 0", 0, 
eDA2.getNumElements());
 
         final DiscreteDistribution.Sampler randomData =
-            new UniformDiscreteDistribution(100, 
1000).createSampler(RandomSource.WELL_19937_C.create());
+            UniformDiscreteDistribution.of(100, 
1000).createSampler(RandomSource.WELL_19937_C.create());
         final int iterations = randomData.sample();
 
         for( int i = 0; i < iterations; i++) {
@@ -346,7 +346,7 @@ public class ResizableDoubleArrayTest extends 
DoubleArrayAbstractTest {
         Assert.assertEquals("Initial number of elements should be 0", 0, 
eDA3.getNumElements() );
 
         final DiscreteDistribution.Sampler randomData =
-            new UniformDiscreteDistribution(100, 
3000).createSampler(RandomSource.WELL_19937_C.create());
+            UniformDiscreteDistribution.of(100, 
3000).createSampler(RandomSource.WELL_19937_C.create());
 
         final int iterations = randomData.sample();
 
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatisticAbstractTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatisticAbstractTest.java
index 9595af1..78fb1e6 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatisticAbstractTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatisticAbstractTest.java
@@ -178,7 +178,7 @@ public abstract class UnivariateStatisticAbstractTest {
         // Fill weights array with random int values between 1 and 5
         int[] intWeights = new int[len];
         final DiscreteDistribution.Sampler weightDist =
-            new UniformDiscreteDistribution(1, 
5).createSampler(RandomSource.WELL_512_A.create(234878544L));
+            UniformDiscreteDistribution.of(1, 
5).createSampler(RandomSource.WELL_512_A.create(234878544L));
         for (int i = 0; i < len; i++) {
             intWeights[i] = weightDist.sample();
             weights[i] = intWeights[i];
@@ -188,7 +188,7 @@ public abstract class UnivariateStatisticAbstractTest {
         // and fill valuesList with values from values array with
         // values[i] repeated weights[i] times, each i
         final ContinuousDistribution.Sampler valueDist =
-            new NormalDistribution(mu, 
sigma).createSampler(RandomSource.WELL_512_A.create(64925784252L));
+            NormalDistribution.of(mu, 
sigma).createSampler(RandomSource.WELL_512_A.create(64925784252L));
         List<Double> valuesList = new ArrayList<>();
         for (int i = 0; i < len; i++) {
             double value = valueDist.sample();
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentileTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentileTest.java
index e4955a9..a1c0ab9 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentileTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentileTest.java
@@ -762,9 +762,9 @@ public class PSquarePercentileTest extends
      */
     @Test
     public void testDistribution() {
-        doDistributionTest(new NormalDistribution(4000, 50));
-        doDistributionTest(new LogNormalDistribution(4000, 50));
-        // doDistributionTest((new ExponentialDistribution(4000));
-        // doDistributionTest(new GammaDistribution(5d,1d),0.1);
+        doDistributionTest(NormalDistribution.of(4000, 50));
+        doDistributionTest(LogNormalDistribution.of(4000, 50));
+        // doDistributionTest((ExponentialDistribution.of(4000));
+        // doDistributionTest(GammaDistribution.of(5d,1d),0.1);
     }
 }
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PercentileTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PercentileTest.java
index 7f8e026..25864c5 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PercentileTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PercentileTest.java
@@ -590,7 +590,7 @@ public class PercentileTest extends 
UnivariateStatisticAbstractTest{
     @Test
     public void testStoredVsDirect() {
         final ContinuousDistribution.Sampler sampler =
-            new NormalDistribution(4000, 
50).createSampler(RandomSource.JDK.create(Long.MAX_VALUE));
+            NormalDistribution.of(4000, 
50).createSampler(RandomSource.JDK.create(Long.MAX_VALUE));
 
         for (final int sampleSize : sampleSizes) {
             final double[] data = AbstractRealDistribution.sample(sampleSize, 
sampler);
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/InferenceTestUtilsTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/InferenceTestUtilsTest.java
index e75745a..1d14a31 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/InferenceTestUtilsTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/InferenceTestUtilsTest.java
@@ -527,7 +527,7 @@ public class InferenceTestUtilsTest {
 
     @Test
     public void testKSOneSample() throws Exception {
-       final NormalDistribution unitNormal = new NormalDistribution(0d, 1d);
+       final NormalDistribution unitNormal = NormalDistribution.of(0d, 1d);
        final double[] sample = KolmogorovSmirnovTestTest.gaussian;
        final double tol = 1e-10;
        Assert.assertEquals(0.3172069207622391, 
InferenceTestUtils.kolmogorovSmirnovTest(unitNormal, sample), tol);
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTestTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTestTest.java
index 4d63f13..a03b4ff 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTestTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTestTest.java
@@ -104,7 +104,7 @@ public class KolmogorovSmirnovTestTest {
     @Test
     public void testOneSampleGaussianGaussian() {
         final KolmogorovSmirnovTest test = new KolmogorovSmirnovTest();
-        final NormalDistribution unitNormal = new NormalDistribution(0d, 1d);
+        final NormalDistribution unitNormal = NormalDistribution.of(0d, 1d);
         // Uncomment to run exact test - takes about a minute. Same value is 
used in R tests and for
         // approx.
         // Assert.assertEquals(0.3172069207622391, 
test.kolmogorovSmirnovTest(unitNormal, gaussian,
@@ -118,7 +118,7 @@ public class KolmogorovSmirnovTestTest {
     @Test
     public void testOneSampleGaussianGaussianSmallSample() {
         final KolmogorovSmirnovTest test = new KolmogorovSmirnovTest();
-        final NormalDistribution unitNormal = new NormalDistribution(0d, 1d);
+        final NormalDistribution unitNormal = NormalDistribution.of(0d, 1d);
         final double[] shortGaussian = new double[50];
         System.arraycopy(gaussian, 0, shortGaussian, 0, 50);
         Assert.assertEquals(0.683736463728347, 
test.kolmogorovSmirnovTest(unitNormal, shortGaussian, false), TOLERANCE);
@@ -130,7 +130,7 @@ public class KolmogorovSmirnovTestTest {
     @Test
     public void testOneSampleGaussianUniform() {
         final KolmogorovSmirnovTest test = new KolmogorovSmirnovTest();
-        final NormalDistribution unitNormal = new NormalDistribution(0d, 1d);
+        final NormalDistribution unitNormal = NormalDistribution.of(0d, 1d);
         // Uncomment to run exact test - takes a long time. Same value is used 
in R tests and for
         // approx.
         // Assert.assertEquals(0.3172069207622391, 
test.kolmogorovSmirnovTest(unitNormal, uniform,
@@ -144,7 +144,7 @@ public class KolmogorovSmirnovTestTest {
     // @Test - takes about 6 seconds, uncomment for
     public void testOneSampleUniformUniform() {
         final KolmogorovSmirnovTest test = new KolmogorovSmirnovTest();
-        final UniformContinuousDistribution unif = new 
UniformContinuousDistribution(-0.5, 0.5);
+        final UniformContinuousDistribution unif = 
UniformContinuousDistribution.of(-0.5, 0.5);
         Assert.assertEquals(8.881784197001252E-16, 
test.kolmogorovSmirnovTest(unif, uniform, false), TOLERANCE);
         Assert.assertTrue(test.kolmogorovSmirnovTest(unif, uniform, 0.05));
         Assert.assertEquals(0.5400666982352942, 
test.kolmogorovSmirnovStatistic(unif, uniform), TOLERANCE);
@@ -154,7 +154,7 @@ public class KolmogorovSmirnovTestTest {
     @Test
     public void testOneSampleUniformUniformSmallSample() {
         final KolmogorovSmirnovTest test = new KolmogorovSmirnovTest();
-        final UniformContinuousDistribution unif = new 
UniformContinuousDistribution(-0.5, 0.5);
+        final UniformContinuousDistribution unif = 
UniformContinuousDistribution.of(-0.5, 0.5);
         final double[] shortUniform = new double[20];
         System.arraycopy(uniform, 0, shortUniform, 0, 20);
         Assert.assertEquals(4.117594598618268E-9, 
test.kolmogorovSmirnovTest(unif, shortUniform, false), TOLERANCE);
@@ -166,7 +166,7 @@ public class KolmogorovSmirnovTestTest {
     @Test
     public void testOneSampleUniformGaussian() {
         final KolmogorovSmirnovTest test = new KolmogorovSmirnovTest();
-        final UniformContinuousDistribution unif = new 
UniformContinuousDistribution(-0.5, 0.5);
+        final UniformContinuousDistribution unif = 
UniformContinuousDistribution.of(-0.5, 0.5);
         // Value was obtained via exact test, validated against R. Running 
exact test takes a long
         // time.
         Assert.assertEquals(4.9405812774239166E-11, 
test.kolmogorovSmirnovTest(unif, gaussian, false), TOLERANCE);
diff --git 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/GLSMultipleLinearRegressionTest.java
 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/GLSMultipleLinearRegressionTest.java
index 2c17783..b53d500 100644
--- 
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/GLSMultipleLinearRegressionTest.java
+++ 
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/GLSMultipleLinearRegressionTest.java
@@ -223,7 +223,7 @@ public class GLSMultipleLinearRegressionTest extends 
MultipleLinearRegressionAbs
     @Test
     public void testGLSEfficiency() {
         final UniformRandomProvider rg = RandomSource.MT.create();
-        final ContinuousDistribution.Sampler gauss = new NormalDistribution(0, 
1).createSampler(rg);
+        final ContinuousDistribution.Sampler gauss = NormalDistribution.of(0, 
1).createSampler(rg);
 
         // Assume model has 16 observations (will use Longley data).  Start by 
generating
         // non-constant variances for the 16 error terms.

Reply via email to