pmd fix: avoid assignment in operand

Author: aherbert

commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractContinuousDistribution.java

@@ -81,7 +81,8 @@ abstract class AbstractContinuousDistribution
     double getMedian() {
         double m = median;
         if (Double.isNaN(m)) {
-            median = m = inverseCumulativeProbability(0.5);
+            m = inverseCumulativeProbability(0.5);
+            median = m;
         }
         return m;
     }

commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistribution.java

@@ -59,7 +59,8 @@ abstract class AbstractDiscreteDistribution
     int getMedian() {
         long m = median;
         if (m == NO_MEDIAN) {
-            median = m = inverseCumulativeProbability(0.5);
+            m = inverseCumulativeProbability(0.5);
+            median = m;
         }
         return (int) m;
     }

commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/HypergeometricDistribution.java

@@ -484,7 +484,8 @@ private double[] getMidPoint() {
                 x--;
                 p1 = p0;
             }
-            midpoint = v = new double[] {x, p1};
+            v = new double[] {x, p1};
+            midpoint = v;
         }
         return v;
     }

commons-statistics-inference/src/main/java/org/apache/commons/statistics/inference/KolmogorovSmirnovTest.java

@@ -598,22 +598,24 @@ public TwoResult test(double[] x, double[] y) {
         final double d2 = significantTies ? computeD(tiesD[1], n, m, gcd) : d;
 
         final double p;
-        double p2;
+        final double p2;
 
         // Allow bootstrap estimation of the p-value
         if (method == PValueMethod.ESTIMATE) {
             p = estimateP(sx, sy, dnm);
             p2 = Double.NaN;
         } else {
             final boolean exact = method == PValueMethod.EXACT;
-            p = p2 = twoSampleP(dnm, n, m, gcd, d, exact);
+            p = twoSampleP(dnm, n, m, gcd, d, exact);
             if (significantTies) {
                 // Compute the upper bound on D.
                 // The p-value is also computed. The alternative is to save the options
                 // in the result with (upper dnm, n, m) and compute it on-demand.
                 // Note detection of whether the exact P computation is possible is based on
                 // n and m, thus this will use the same computation.
                 p2 = twoSampleP(tiesD[1], n, m, gcd, d2, exact);
+            } else {
+                p2 = p;
             }
         }
         return new TwoResult(d, sign[0], p, significantTies, d2, p2);

commons-statistics-inference/src/main/java/org/apache/commons/statistics/inference/MannWhitneyUTest.java

@@ -561,15 +561,17 @@ private static double[][][] getF(int m, int n, int k) {
                     for (int x = 0; x < m1; x++) {
                         f[x] = Arrays.copyOf(f[x], sn);
                         for (int y = n1; y < sn; y++) {
-                            final double[] b = f[x][y] = new double[sk];
+                            final double[] b = new double[sk];
+                            f[x][y] = b;
                             initialize(b);
                         }
                     }
                 }
                 if (growK) {
                     for (int x = 0; x < m1; x++) {
                         for (int y = 0; y < n1; y++) {
-                            final double[] b = f[x][y] = Arrays.copyOf(f[x][y], sk);
+                            final double[] b = Arrays.copyOf(f[x][y], sk);
+                            f[x][y] = b;
                             for (int z = k1; z < sk; z++) {
                                 b[z] = UNSET;
                             }
@@ -624,7 +626,8 @@ private static double fmnk(double[][][] f, int m, int n, int k) {
 
             // Recursion from formula (3):
             // f(m, n, k) = f(m-1, n, k-n) + f(m, n-1, k)
-            f[m][n][k] = fmnk = fmnk(f, m - 1, n, k - n) + fmnk(f, m, n - 1, k);
+            fmnk = fmnk(f, m - 1, n, k - n) + fmnk(f, m, n - 1, k);
+            f[m][n][k] = fmnk;
         }
         return fmnk;
     }

commons-statistics-inference/src/main/java/org/apache/commons/statistics/inference/UnconditionedExactTest.java

@@ -1084,7 +1084,8 @@ private static IntToDoubleFunction createLogBinomialCoefficients(int n) {
         // ignore: binom(n, 0) == binom(n, n) == 1
         int j = n - 1;
         for (int i = 1; i <= j; i++, j--) {
-            binom[i] = binom[j] = LogBinomialCoefficient.value(n, i);
+            binom[i] = LogBinomialCoefficient.value(n, i);
+            binom[j] = binom[i];
         }
         return k -> binom[k];
     }

commons-statistics-inference/src/main/java/org/apache/commons/statistics/inference/WilcoxonSignedRankTest.java

@@ -640,7 +640,8 @@ private static double computeCdf(int t, int n) {
         // Compute all u_n(t) up to t.
         final double[] u = new double[t + 1];
         // Initialize u_1(t) using base cases for recursion
-        u[0] = u[1] = 1;
+        u[0] = 1;
+        u[1] = 1;
 
         // Each u_n(t) is created using the current correct values for u_{n-1}(t)
         for (int nn = 2; nn < n + 1; nn++) {

commons-statistics-ranking/src/main/java/org/apache/commons/statistics/ranking/NaturalRanking.java

@@ -452,7 +452,8 @@ private IntUnaryOperator getRandomIntFunction() {
         IntUnaryOperator r = randomIntFunction;
         if (r == null) {
             // Default to a SplittableRandom
-            randomIntFunction = r = new SplittableRandom()::nextInt;
+            r = new SplittableRandom()::nextInt;
+            randomIntFunction = r;
         }
         return r;
     }