STATISTICS-80: Variance Implementation #52

ani5rudh · 2023-08-19T03:23:51Z

No description provided.

…into ani5rudh/STATISTICS-79

codecov-commenter · 2023-08-19T07:15:59Z

Codecov Report

Merging #52 (c094d35) into master (d886ade) will decrease coverage by 0.01%.
Report is 3 commits behind head on master.
The diff coverage is 100.00%.

@@             Coverage Diff              @@
##             master      #52      +/-   ##
============================================
- Coverage     99.80%   99.80%   -0.01%     
  Complexity     1599     1599              
============================================
  Files            64       64              
  Lines          4015     4011       -4     
  Branches        726      724       -2     
============================================
- Hits           4007     4003       -4     
  Misses            4        4              
  Partials          4        4

Files Changed	Coverage Δ
...stics/inference/KolmogorovSmirnovDistribution.java	`100.00% <100.00%> (ø)`

📣 We’re building smart automated test selection to slash your CI/CD build times. Learn more

kinow

Didn't have time to go through the tests, leaving a few comments, but found no blockers so far. Great work @ani5rudh ! 👏

...criptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java

kinow · 2023-08-19T08:11:38Z

...statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java

+ * American Statistician, vol. 37, no. 3 (1983) pp. 242-247.</li></ul>
+ *
+ * Note that adding values using {@code accept} and then executing {@code getAsDouble} will
+ * sometimes give a different, less accurate, result than executing


Are we able to say anything more about accuracy? Maybe the papers linked above have something we could add here?

At $work we are using @tdunning's tdigest (a Python port based on it) for one-pass algorithms, where researchers are validating the computation and accuracy of statistics. They used both the paper and also notes from the javadocs that talk about the performance/accuracy tradeoff in the algorithm. e.g. https://github.com/tdunning/t-digest/blob/72acae1e14962795888efc941516c2b4503a86af/core/src/main/java/com/tdunning/math/stats/TDigest.java#L34 & https://github.com/tdunning/t-digest/blob/72acae1e14962795888efc941516c2b4503a86af/core/src/main/java/com/tdunning/math/stats/ScaleFunction.java#L21

Maybe we don't need to be very specific here, and we can just expand a bit more and quote the article authors?

BTW, this can be a follow-up issue, no need to block this PR for that, nor the other tasks needed for GSoC, I think.

I'll go through the papers once again and see if I can add some more information regarding accuracy. 👍

kinow · 2023-08-19T08:16:14Z

...statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java

+        } else {
+            squaredDevSum = accum - (accum2 * accum2 / n);
+        }
+        return StorelessSampleVariance.create(squaredDevSum, mean, n, accum2 + (mean * n));


I started reading the paper but ran out of time to verify the code here, but from the javadocs I think it is based on this one?

West's algorithm is used in the accept(double d) method for updating the value of the statistic.
The two-pass algorithm used in the of(double... values) method is :

This formula is from the paper/report titled - Algorithms for computing the sample variance : analysis and recommendations

Thanks for the explanation. I had a look at SumOfSquaredDeviations#accept and it looks correct to me!

…5rudh/STATISTICS-80

kinow

Looks good to me. Reviewed implemented code and javadocs. Executed tests on my IDE, coverage looks great, couldn't find anything to suggest changing in the tests. Left a comment about docs for accuracy, but that's it from me. Thanks @ani5rudh !

kinow · 2023-08-20T08:43:28Z

...statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java

+        if (accum2Squared == Double.POSITIVE_INFINITY) {
+            squaredDevSum = Double.POSITIVE_INFINITY;
+        } else {
+            squaredDevSum = accum - (accum2 * accum2 / n);


I think here (accum2 * accum2 / n) could be simplified to (accum2Squared / n).

Had a look at the part of the paper you highlighted, @ani5rudh , and this looks correct to me! Great work!

kinow · 2023-08-20T08:45:34Z

...statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java

+        } else {
+            squaredDevSum = accum - (accum2 * accum2 / n);
+        }
+        return StorelessSampleVariance.create(squaredDevSum, mean, n, accum2 + (mean * n));


Thanks for the explanation. I had a look at SumOfSquaredDeviations#accept and it looks correct to me!

aherbert

I think there is some work to do on consolidating the same test data that is used here and in the MeanTest. The stream of data can use the raw data. Each Test class can then derive an expected result. For the test data that includes non-finite values then I think we can simply use DoubleStream for the mean and use NaN for the variance.

I found a bug in the Mean implementation which we should fix outside of this PR.

aherbert · 2023-08-22T10:40:07Z

...tistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/FirstMoment.java

 * multiple threads access an instance of this class concurrently, and at least
- * one of the threads invokes the <code>increment()</code> or
- * <code>clear()</code> method, it must be synchronized externally.
+ * one of the threads invokes the <code>accept()</code> or


To prevent these types of error we should change this to a javadoc link. The links will be verified by the javadoc tool. E.g

/* * ... * one of the threads invokes the {@link java.util.function.DoubleConsumer#accept(double) accept} * or {@link DoubleStatisticAccumulator#combine(DoubleStatistic) combine} method, it must * be synchronized externally. * ... */

aherbert · 2023-08-22T11:19:24Z

...criptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java

+ * provides the necessary partitioning, isolation, and merging of results for
+ * safe and efficient parallel execution.
+ */
+class SumOfSquaredDeviations implements DoubleStatistic, DoubleStatisticAccumulator<SumOfSquaredDeviations> {


I understand that this has been created by composition as the DoubleStatisticAccumulator interface cannot be implemented with different type arguments. However this is an internal class. Thus we could drop the implementation of DoubleStatisticAccumulator (keeping the actual implementation) and change this class to extend FirstMoment. This should allow simpler inheritance structure for the higher order moments. What we are working towards is computing statistics using the moments (Wikipedia):

RawFirstMoment // SumOfDeviations is a precursor to central moment SumOfDeviations2 -> Variance SumOfDeviations3 -> Skewness SumOfDeviations4 -> Kurtosis // Optional SumOfDeviations5 -> Hyperskewness SumOfDeviations6 -> Hypertailedness

In this case inheritance for the sum of deviations makes sense. The actual public statistic implementations that use the sum of deviations will avoid the inheritance.

Once we get into implementing an aggregator class then different statistics should be able to share the same underlying implementation of the sum of deviations.

aherbert · 2023-08-22T11:21:49Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+        if (n == 1) {
+            return BigDecimal.ZERO.doubleValue();
+        }
+        double mean = TestHelper.computeExpectedMean(values);


This helper method should return the raw BigDecimal. Then you can convert it by rounding.

BigDecimal mean = TestHelper.computeExpectedMean(values).round(MathContext.DECIMAL128);

aherbert · 2023-08-22T11:23:15Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+        double mean = TestHelper.computeExpectedMean(values);
+        BigDecimal bd = BigDecimal.ZERO;
+        for (double value : values) {
+            BigDecimal bdDiff = BigDecimal.valueOf(value)


Do not use BigDecimal.valueOf. This uses a text representation of the double. To get the exact representation you should use new BigDecimal.

Note: Computing the BigDecimal mean should be done outside the loop.

aherbert · 2023-08-22T11:30:29Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+            BigDecimal bdDiff = BigDecimal.valueOf(value)
+                    .subtract(BigDecimal.valueOf(mean));
+            bdDiff = bdDiff.multiply(bdDiff);
+            bd = bd.add(bdDiff);


It may be more efficient to use bdDiff.pow(2). This internally can use BigInteger.square and can factor out the common power of 2 in the underlying integer.

aherbert · 2023-08-22T14:08:33Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+        for (double value : values) {
+            var.accept(value);
+        }
+        TestHelper.assertEquals(expected, var.getAsDouble(), 7, () -> "variance");


These ULP values may have to be lowered when you correct the computation of the expected variance. Using BigDecimal.valueOf(double) may have introduced quite a difference.

aherbert · 2023-08-22T14:13:24Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+        }
+    }
+
+    static Stream<Arguments> testVariance() {


It may be better here to use MeanTest (since the data is the same):

static Stream<Arguments> testVariance() { return MeanTest.testMean(); }

My preferred option would be to move the stream method to a new class: TestData with static Stream<double[]> testValues(). Note that you do not have to use JUnit Arguments when the test method only has one argument. You can simply stream the objects. JUnit will map the stream elements to the test argument.

Note: When I made the above change I also had the extra test case for Mean included. That fails:

Double.MAX_VALUE, Double.MAX_VALUE, -Double.MAX_VALUE expected: Infinity actual: NaN

This highlights that we really should reuse the same data on all the statistics, and it should be in one place.

aherbert · 2023-08-22T14:22:22Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+            testParallelStreamNonFinite(TestHelper.shuffle(rng, values), expected);
+        }
+    }
+    static Stream<Arguments> testVarianceNonFinite() {


Add a newline above this method.

Add a comment that the data should be the same as MeanTest.testMeanNonFinite. Given that all the expected values are NaN you could reuse MeanTest:

static Stream<Arguments> testVarianceNonFinite() { // Reuse the Mean data; we ignore the expected mean as the variance is always NaN return MeanTest.testMeanNonFinite(); }

These could also be moved to a TestData class. The expected value for the mean can be computed using DoubleStream since that will return the correct non-finite value from the sum divided by the length.

aherbert · 2023-08-22T14:26:52Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+        TestHelper.assertEquals(expected, actual, 2, () -> "array of arrays combined variance");
+    }
+
+    static Stream<Arguments> testCombine() {


Move this data to TestData.testCombineValues. This will have to use a Stream of Arguments.

aherbert · 2023-08-22T14:28:33Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+        Assertions.assertEquals(expected, actual, "array of arrays combined variance non-finite");
+    }
+
+    static Stream<Arguments> testCombineNonFinite() {


Once again, this is a duplicate of the data in MeanTest. The expected value is always NaN. So we can move the data to a TestData class.

- Refactor accept and combine methods.

…into ani5rudh/STATISTICS-80

…5rudh/STATISTICS-80 # Conflicts: # commons-statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java # commons-statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java # commons-statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/MeanTest.java # commons-statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestHelper.java # commons-statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

kinow · 2023-09-05T21:23:27Z

...atistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestHelper.java

     * Helper function to compute the expected value of Mean using BigDecimal.
     * @param values Values.
-     * @return Mean of values.
+     * @return Mean of values rounded to <a href = "https://en.wikipedia.org/wiki/Decimal128_floating-point_format"> DECIMAL128 precision.


The <a> tag looks malformed to me, but if that renders valid Javadoc & HTML then I guess that's OK.

It opens a webpage in my IDE so the href is OK. But it should have a </a> tag. Note that testing with:

mvn javadoc:test-javadoc

errors as there are no public or protected test classes. So this link is just for internal use only.

aherbert

I think we can simplify the inheritance of the internal classes by dropping the interfaces implementation. We still keep the methods, but without the interface definition we can have separate methods for each class so the SumOfSquaredDeviations can compute the mean.

There are some other changes to consolidate the test cases in the TestData class.

aherbert · 2023-09-05T20:01:08Z

...criptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java

+ * {@link DoubleStatisticAccumulator#combine(DoubleStatistic) combine} method, it must be synchronized externally.
 *
- * <p>However, it is safe to use <code>accept()</code> and <code>combine()</code>
+ * <p>However, it is safe to use {@link java.util.function.DoubleConsumer#accept(double) accept} and {@link DoubleStatisticAccumulator#combine(DoubleStatistic) combine}


Wrap this to 100 or 120 character width

aherbert · 2023-09-05T20:10:06Z

...statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestData.java

+import java.util.stream.Stream;
+import org.junit.jupiter.params.provider.Arguments;
+
+final class TestData {


Class and methods should have some comments.

aherbert · 2023-09-05T20:11:47Z

...statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestData.java

+        );
+    }
+
+    static Stream<Arguments> testValuesNonFinite() {


The expected value should not be in this method. You are always using NaN so this is not helpful. Each statistic should be able to compute the expected value for the data that has non-finite values. For example the min/max/mean may return an infinity but the variance would be NaN.

aherbert · 2023-09-05T20:13:38Z

...statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/MeanTest.java

-    @MethodSource(value = "testCombineNonFinite")
+    @MethodSource(value = {"org.apache.commons.statistics.descriptive.TestData#testCombineNonFinite", "testCombineMeanNonFinite"})
    void testCombineRandomOrderNonFinite(double[][] values, double expected) {
        UniformRandomProvider rng = TestHelper.createRNG();


I do not think we should have expected value in this stream method. Why are these cases needed for mean and not for any other stat. Can these cases be moved to the TestData class?

You can just have a second method to compute the expected mean for non-finite cases. IIUC it should just be the mean of the stream of values:

Arrays.stream(values).flatMapToDouble(Arrays::stream).average().orElse(Double.NaN)

aherbert · 2023-09-05T20:39:09Z

...statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java

        double squaredDevSum;
        for (final double value : values) {
-            dev = value - mean;
+            dev = value * 0.5 - mean * 0.5;


Why protect from overflow here when immediately you square the result?

I removed this and the failing test case is: {MAX, MAX, -MAX}.

This is similar to {2, 2, -2} which has a mean of 2/3 and a variance of 3.5555. So rescaled by 2^1023 squared the variance would be 3.5555 * (2^1023)^2. This is a large overflow. Your scaling down is protecting computing the deviation from the mean, but the deviation squared is infinite and the rest of the computation cannot be saved.

I think your overflow detection can be done on the accum value and not accum2. We can document that if the sum of squared deviations from the mean overflows then the variance is returned as infinity. So we use the formula as defined (comments removed for brevity):

for (final double value : values) { dev = value - mean; accum += dev * dev; accum2 += dev; } final double accum2Squared = accum2 * accum2; final long n = values.length; if (accum == Double.POSITIVE_INFINITY) { squaredDevSum = Double.POSITIVE_INFINITY; } else { squaredDevSum = accum - (accum2Squared / n); }

aherbert · 2023-09-05T21:56:21Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+    static double computeExpectedVariance(double[] values) {
+        long n = values.length;
+        if (n == 1) {
+            return BigDecimal.ZERO.doubleValue();


Just return zero here

aherbert · 2023-09-05T22:21:20Z

...istics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

+        Assertions.assertEquals(expected, actual, "array of arrays combined variance non-finite");
+    }
+
+    static Stream<Arguments> testCombineVarianceNonFinite() {


Again, these are not the same as the MeanTest. So we are missing cases in one or the other. Please consolidate them to TestData.

aherbert · 2023-09-05T22:26:53Z

...criptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java

+            final double sqDiffOfMean = diffOfMean * diffOfMean;
+            squaredDevSum += other.squaredDevSum + sqDiffOfMean * ((double) (oldN * otherN) / (oldN + otherN));
+        }
+        super.combine(other.getFirstMoment());


No need to create a copy instance here. Just use: super.combine(other)

aherbert · 2023-09-05T22:30:52Z

...criptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java

+        if (oldN == 0) {
+            squaredDevSum = other.squaredDevSum;
+        } else if (otherN != 0) {
+            final double diffOfMean = other.getFirstMoment().getAsDouble() - m1;


Avoid creating a copy instance of the FirstMoment. Instead drop the implementation of the statistic interfaces (these are internal classes so do not require them):

// In FirstMoment: double getFirstMoment() { if (Double.isFinite(m1)) { return n == 0 ? Double.NaN : m1; } // A non-finite value must have been encountered, return nonFiniteValue which represents m1. return nonFiniteValue; } // In SumOfSquaredDeviations: final double diffOfMean = other.getFirstMoment() - m1

aherbert · 2023-09-05T22:41:21Z

...criptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java

+ * provides the necessary partitioning, isolation, and merging of results for
+ * safe and efficient parallel execution.
+ */
+class SumOfSquaredDeviations extends FirstMoment implements DoubleStatistic {


I think we should drop the implementation of DoubleStatistic. You could just implement DoubleConsumer in FirstMoment and drop the implementation of DoubleStaticticAccumilator. You then do not have to overload getAsDouble through the hierarchy. You can have typed methods for combine and specific methods for the stat:

FirstMoment implements DoubleConsumer: void accept(double) FirstMoment combine(FirstMoment); double getFirstMoment() SumOfSquaredDeviations extends FirstMoment: SumOfSquaredDeviations combine(SumOfSquareDeviations); double getSumOfSquaredDeviations();

This allows the SumOfSquareDeviations to call super.combine(other) and getFirstMoment() directly without creating copy instances.

- Refactor accept and combine methods.

- Refactor of() method to better handle overflow. - Drop the implementation of the statistic and accumulator interfaces.

…5rudh/STATISTICS-80 # Conflicts: # commons-statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java # commons-statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java # commons-statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/MeanTest.java # commons-statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestData.java # commons-statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestHelper.java # commons-statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/VarianceTest.java

aherbert

This is looking good. I've made a few suggestions to change the description of the TestData methods to be more generic. You have referenced the accept and of methods but the data could be used to test other statistic methods. So we should make the intended purpose of the data more clear.

aherbert · 2023-09-06T18:51:54Z

...criptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java

-    FirstMoment getFirstMoment() {
-        return new FirstMoment(m1, n, super.getNonFiniteValue(), dev, nDev);
+    public double getSumOfSquaredDeviations() {
+        return Double.isFinite(super.getFirstMoment()) ? squaredDevSum : Double.NaN;


No need for super here

aherbert · 2023-09-06T18:57:37Z

...criptive/src/main/java/org/apache/commons/statistics/descriptive/SumOfSquaredDeviations.java

-            final double diffOfMean = other.getFirstMoment().getAsDouble() - m1;
+            final double diffOfMean = other.getFirstMoment() - m1;
            final double sqDiffOfMean = diffOfMean * diffOfMean;
            squaredDevSum += other.squaredDevSum + sqDiffOfMean * ((double) (oldN * otherN) / (oldN + otherN));


This is a product of two longs so it could have integer overflow. The sum could also overflow but the sizes involved make that unlikely. I think this should be made safe by using:

(((double) oldN * otherN) / ((double) oldN + otherN))

aherbert · 2023-09-06T19:02:43Z

...statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java

    public static Variance of(double... values) {
        final double mean = Mean.of(values).getAsDouble();
+        if (!Double.isFinite(mean)) {
+            return StorelessSampleVariance.create(Math.abs(mean), mean, values.length, Math.abs(mean));


Correction

return StorelessSampleVariance.create(Math.abs(mean), mean, values.length, mean);

The second value is a proxy for the non-finite sum of the values, so we should not use abs.

aherbert · 2023-09-06T19:03:28Z

...statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java

        final long n = values.length;
        // The sum of squared deviations is accum - (accum2 * accum2 / n).
        // To prevent squaredDevSum from spuriously attaining a NaN value
        // when accum2Squared (which implies accum is also infinite) is infinite, assign it


This comment is now out-of-date.

You should also update the method javadoc with the case: if the sum of the squared deviations from the mean is infinite, the variance is NaN.

aherbert · 2023-09-06T19:09:22Z

...statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestData.java

    private TestData() {}

+    /**
+     * Function which supplies data to test the <code>accept()</code> and <code>of()</code> methods.


supplies a test data for a statistic in a single array.

aherbert · 2023-09-06T19:09:52Z

...statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestData.java


-    static Stream<Arguments> testValuesNonFinite() {
+    /**
+     * Function which supplies data with non-finite values to test the <code>accept()</code> and <code>of()</code> methods.


supplies a test data for a statistic in a single array. Each case will contain at least 1 non-finite value.

aherbert · 2023-09-06T19:10:49Z

...statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestData.java

    }

+    /**
+     * Function which supplies data to test the <code>combine()</code> method.


supplies a test data for a statistic in as a pair of double[] arrays.

aherbert · 2023-09-06T19:12:25Z

...statistics-descriptive/src/test/java/org/apache/commons/statistics/descriptive/TestData.java


-    static Stream<Arguments> testCombineNonFinite() {
+    /**
+     * Function which supplies data with non-finite values to test the <code>combine()</code> method.


supplies a test data for a statistic in as a pair of double[] arrays. Each case will contain at least 1 non-finite value.

- Better handle overflow in combine() method.

aherbert · 2023-09-07T14:52:04Z

...statistics-descriptive/src/main/java/org/apache/commons/statistics/descriptive/Variance.java

     *     <li>the input array is empty,</li>
     *     <li>any of the values is <code>NaN</code>, or</li>
     *     <li>an infinite value of either sign is encountered</li>
+     *     <li>if the sum of the squared deviations from the mean is infinite</li>


Your or is now on the wrong line

Ohh I'd forgotten to notice this, I'll change it.

ani5rudh added 4 commits August 11, 2023 14:02

STATISTICS-79: Mean Implementation

bcbc515

STATISTICS-79: Mean Implementation

7f7d9eb

Merge branch 'master' of https://github.com/apache/commons-statistics …

d101ebc

…into ani5rudh/STATISTICS-79

STATISTICS-80: Variance Implementation

39b82e0

kinow reviewed Aug 19, 2023

View reviewed changes

ani5rudh added 3 commits August 19, 2023 20:40

STATISTICS-80: Variance Implementation

3f7f250

Update javadocs.

14efe6c

Merge remote-tracking branch 'origin/ani5rudh/STATISTICS-80' into ani…

ddaeb1f

…5rudh/STATISTICS-80

kinow reviewed Aug 20, 2023

View reviewed changes

aherbert requested changes Aug 22, 2023

View reviewed changes

ani5rudh added 5 commits August 27, 2023 22:20

STATISTICS-80: Variance Implementation

d69d931

Update javadocs.

91e7c13

- Refactor common testcases to a new class TestData.

0e82878

- Refactor accept and combine methods.

Merge branch 'master' of https://github.com/apache/commons-statistics …

94f8162

…into ani5rudh/STATISTICS-80

kinow reviewed Sep 5, 2023

View reviewed changes

aherbert requested changes Sep 5, 2023

View reviewed changes

aherbert and others added 11 commits September 5, 2023 23:52

Add the observed ULP difference to the assert message

7ef4703

STATISTICS-80: Variance Implementation

ccb93b8

Update javadocs.

0205c00

- Refactor common testcases to a new class TestData.

6227306

- Refactor accept and combine methods.

STATISTICS-79: Mean Implementation

e26dd9d

STATISTICS-80: Variance Implementation

b255161

Update javadocs.

8ec25b1

Consolidate test cases for non-finites.

f292070

- Refactor of() method to better handle overflow. - Drop the implementation of the statistic and accumulator interfaces.

Reduce the ULP tolerance.

f0fcb43

Remove unused methods.

71baf75

aherbert requested changes Sep 6, 2023

View reviewed changes

Update javadocs.

1a5b6c1

- Better handle overflow in combine() method.

aherbert requested changes Sep 7, 2023

View reviewed changes

ani5rudh added 2 commits September 7, 2023 20:44

Update javadocs.

7ec7601

Update javadocs.

c094d35

aherbert merged commit 8564fc9 into apache:master Sep 7, 2023

STATISTICS-80: Variance Implementation #52

STATISTICS-80: Variance Implementation #52

Uh oh!

Conversation

ani5rudh commented Aug 19, 2023

Uh oh!

codecov-commenter commented Aug 19, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

kinow left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

kinow left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

aherbert left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

aherbert left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

codecov-commenter commented Aug 19, 2023 •

edited

Loading