Merge pull request jOOQ#387 from Lu-Jichen/issue360

implementation of issue 360

Author: lukaseder

jOOL-java-8/src/main/java/org/jooq/lambda/Agg.java

@@ -23,6 +23,9 @@
 
 import java.util.*;
 import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.TreeSet;
 import java.util.function.*;
 import java.util.stream.Collector;
 import java.util.stream.Stream;
@@ -1076,4 +1079,149 @@ private static int percentileIndex(double percentile, int size) {
             s -> s.map(Objects::toString).orElse("")
         );
     }
+
+
+    //CS304 Issue link: https://github.com/jOOQ/jOOL/issues/360
+
+    /**
+     * Calculate the variance of objects with mapping function from object to double value,
+     * with given list, size and mapping function.
+     *
+     * <p><pre>
+     *     This function is based on the definition of standard deviation:
+     *     First, calculate the sum of value of all objects and the average value;
+     *     Second, calculate the sum of square of difference between each objects and average;
+     *     Third, use sum of variance divide size to obtain variance of all objects.
+     * </pre>
+     *
+     * @param function mapping function from object to double value
+     * @param l        a list containing all the objects
+     * @param size     the size of the list in collector
+     * @return the variance value
+     * @version 1.0
+     * @author Jichen Lu
+     * @date 2021-04-25
+     */
+    private static <T> double getVariance(
+            Function<? super T, Double> function,
+            ArrayList<T> l, int size) {
+        double sum = 0.0;
+        double average;
+        double sumVariance = 0.0;
+        double variance;
+        for (T o : l) {
+            double temp = function.apply(o);
+            sum += temp;
+        }
+        average = sum / size;
+        for (T o : l) {
+            double temp = Math.pow(function.apply(o) - average, 2);
+            sumVariance += temp;
+        }
+        variance = sumVariance / size;
+        return variance;
+    }
+
+
+    //CS304 Issue link: https://github.com/jOOQ/jOOL/issues/360
+
+    /**
+     * Calculate the variance of the given object collectors,
+     * based on the mapping function from object to double number.
+     *
+     * <p><pre> Usage of aggregation function stddevBy():
+     * The mapping function is a function mapping the objects to a double value, for instance:
+     * {@code
+     * Function<Integer, Double> mapping = e -> Double.valueOf(e);
+     * }
+     * The specific usage of stddevBy is like:
+     * {@code
+     * Seq.of(1, 1, 1, 1).collect(Agg.stddevBy(mapping));
+     * }
+     * Besides, self defined class is also allowed with mapping function:
+     * {@code
+     * Seq.of(new Node(1), new Node(1), new Node(1), new Node(1)).collect(Agg.stddevBy(mapping1));
+     * }
+     * </pre>
+     *
+     * @param function mapping function from object to double value
+     * @return the stddev value
+     * @version 1.0
+     * @author Jichen Lu
+     * @date 2021-04-25
+     */
+    public static <T> Collector<T, ?, Optional<Double>> stddevBy(
+            Function<? super T,
+                    Double> function) {
+        return Collector.of(
+                (Supplier<ArrayList<T>>) ArrayList::new,
+                ArrayList::add,
+                (l1, l2) -> {
+                    l1.addAll(l2);
+                    return l1;
+                },
+                l -> {
+                    int size = l.size();
+                    if (size == 0) {
+                        return Optional.empty();
+                    }
+                    double variance = getVariance(function, l, size);
+                    double stddev;
+
+
+                    stddev = Math.sqrt(variance);
+
+                    return Optional.of(stddev);
+                }
+        );
+    }
+
+
+    //CS304 Issue link: https://github.com/jOOQ/jOOL/issues/360
+
+    /**
+     * Calculate the variance of the given object collectors,
+     * based on the mapping function from object to double number.
+     *
+     * <p><pre> Usage of aggregation function varianceBy():
+     * The mapping function is a function mapping the objects to a double value, for instance:
+     * {@code
+     * Function<Integer, Double> mapping = e -> Double.valueOf(e);
+     * }
+     * The specific usage of varianceBy is like:
+     * {@code
+     * Seq.of(1, 1, 1, 1).collect(Agg.varianceBy(mapping));
+     * }
+     * Besides, self defined class is also allowed with mapping function:
+     * {@code
+     * Seq.of(new Node(1), new Node(1), new Node(1), new Node(1)).collect(Agg.varianceBy(mapping1));
+     * }
+     * </pre>
+     *
+     * @param function mapping function from object to double value
+     * @return the stddev value
+     * @version 1.0
+     * @author Jichen Lu
+     * @date 2021-04-25
+     */
+    public static <T> Collector<T, ?, Optional<Double>> varianceBy(
+            Function<? super T,
+                    Double> function) {
+        return Collector.of(
+                (Supplier<ArrayList<T>>) ArrayList::new,
+                ArrayList::add,
+                (l1, l2) -> {
+                    l1.addAll(l2);
+                    return l1;
+                },
+                l -> {
+                    int size = l.size();
+                    if (size == 0) {
+                        return Optional.empty();
+                    }
+                    double variance = getVariance(function, l, size);
+                    return Optional.of(variance);
+                }
+        );
+    }
 }

jOOL-java-8/src/test/java/org/jooq/lambda/CollectorTests.java

@@ -22,6 +22,9 @@
 import static org.jooq.lambda.tuple.Tuple.tuple;
 import static org.junit.Assert.assertEquals;
 
+import java.text.DecimalFormat;
+import java.util.Optional;
+import java.util.function.Function;
 import java.util.Comparator;
 import java.util.Optional;
 import java.util.function.Supplier;
@@ -1309,4 +1312,74 @@ public void testDropping() {
         assertEquals(Seq.of().toList(), Seq.of(1, 2, 3, 4, 5).collect(Agg.dropping(6)).toList());
         assertEquals(Seq.of("c", "d").toList(), Seq.of("a", "b", "c", "d").collect(Agg.dropping(2)).toList());
     }
+
+    //CS304 (manually written) Issue link: https://github.com/jOOQ/jOOL/issues/360
+
+    /**
+     * Test the Seq with numbers.
+     *
+     * @result The result will be the standard deviation and variance.
+     */
+    @Test
+    public void testStddevAndVarianceWithNumber() {
+        DecimalFormat df = new java.text.DecimalFormat("#.000");
+
+        Function<Integer, Double> mapping = Double::valueOf;
+
+        assertEquals(Optional.empty(), Seq.<Integer>of().collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.empty(), Seq.<Integer>of().collect(Agg.stddevBy(mapping)));
+        assertEquals(Optional.of(0.0), Seq.of(1).collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.of(0.0), Seq.of(1).collect(Agg.stddevBy(mapping)));
+        assertEquals(Optional.of(0.0), Seq.of(1, 1, 1, 1).collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.of(0.0), Seq.of(1, 1, 1, 1).collect(Agg.stddevBy(mapping)));
+        assertEquals(Optional.of(1.0), Seq.of(1, 1, 3, 3).collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.of(1.0), Seq.of(1, 1, 3, 3).collect(Agg.stddevBy(mapping)));
+        assertEquals(Optional.of(1.250), Seq.of(1, 2, 3, 4).collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.of(1.118), Optional.of(Double.parseDouble(df.format(Seq.of(1, 2, 3, 4).collect(Agg.stddevBy(mapping)).get()))));
+
+
+    }
+
+    //CS304 (manually written) Issue link: https://github.com/jOOQ/jOOL/issues/360
+
+    /**
+     * Test the Seq with numbers.
+     *
+     * @result The result will be the standard deviation and variance.
+     */
+    @Test
+    public void testStddevAndVarianceWithObject() {
+        DecimalFormat df = new java.text.DecimalFormat("#.000");
+
+        class Node {
+            final int value;
+
+            Node(int value) {
+                this.value = value;
+            }
+
+            public Double function() {
+                return (double) value;
+            }
+
+            public int getValue() {
+                return this.value;
+            }
+        }
+        Function<Node, Double> mapping = e -> (double) e.getValue();
+
+        assertEquals(Optional.empty(), Seq.<Node>of().collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.empty(), Seq.<Node>of().collect(Agg.stddevBy(mapping)));
+        assertEquals(Optional.of(0.0), Seq.of(new Node(1)).collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.of(0.0), Seq.of(new Node(1)).collect(Agg.stddevBy(mapping)));
+        assertEquals(Optional.of(0.0), Seq.of(new Node(1), new Node(1), new Node(1), new Node(1)).collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.of(0.0), Seq.of(new Node(1), new Node(1), new Node(1), new Node(1)).collect(Agg.stddevBy(mapping)));
+        assertEquals(Optional.of(1.0), Seq.of(new Node(1), new Node(1), new Node(3), new Node(3)).collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.of(1.0), Seq.of(new Node(1), new Node(1), new Node(3), new Node(3)).collect(Agg.stddevBy(mapping)));
+        assertEquals(Optional.of(1.250), Seq.of(new Node(1), new Node(2), new Node(3), new Node(4)).collect(Agg.varianceBy(mapping)));
+        assertEquals(Optional.of(1.118), Optional.of(Double.parseDouble(df.format(Seq.of(new Node(1), new Node(2), new Node(3), new Node(4)).collect(Agg.stddevBy(mapping)).get()))));
+
+    }
+
+
 }