src/share/classes/java/util/stream/DoublePipeline.java

*** 377,401 ****
  
      @Override
      public final double sum() {
          /*
           * In the arrays allocated for the collect operation, index 0
!          * holds the high-order bits of the running sum and index 1
!          * holds the low-order bits of the sum computed via
!          * compensated summation.
           */
!         double[] summation = collect(() -> new double[2],
                                 (ll, d) -> {
                                     Collectors.sumWithCompensation(ll, d);
                                 },
                                 (ll, rr) -> {
                                     Collectors.sumWithCompensation(ll, rr[0]);
                                     Collectors.sumWithCompensation(ll, rr[1]);
                                 });
  
!         // Better error bounds to add both terms as the final sum
!         return summation[0] + summation[1];
      }
  
      @Override
      public final OptionalDouble min() {
          return reduce(Math::min);
--- 377,404 ----
  
      @Override
      public final double sum() {
          /*
           * In the arrays allocated for the collect operation, index 0
!          * holds the high-order bits of the running sum, index 1 holds
!          * the low-order bits of the sum computed via compensated
!          * summation, and index 2 holds the simple sum used to compute
!          * the proper result if the stream contains infinite values of
!          * the same sign.
           */
!         double[] summation = collect(() -> new double[3],
                                 (ll, d) -> {
                                     Collectors.sumWithCompensation(ll, d);
+                                    ll[2] += d;
                                 },
                                 (ll, rr) -> {
                                     Collectors.sumWithCompensation(ll, rr[0]);
                                     Collectors.sumWithCompensation(ll, rr[1]);
+                                    ll[2] += rr[2];
                                 });
  
!         return Collectors.computeFinalSum(summation);
      }
  
      @Override
      public final OptionalDouble min() {
          return reduce(Math::min);
*** 419,443 ****
      public final OptionalDouble average() {
          /*
           * In the arrays allocated for the collect operation, index 0
           * holds the high-order bits of the running sum, index 1 holds
           * the low-order bits of the sum computed via compensated
!          * summation, and index 2 holds the number of values seen.
           */
!         double[] avg = collect(() -> new double[3],
                                 (ll, d) -> {
                                     ll[2]++;
                                     Collectors.sumWithCompensation(ll, d);
                                 },
                                 (ll, rr) -> {
                                     Collectors.sumWithCompensation(ll, rr[0]);
                                     Collectors.sumWithCompensation(ll, rr[1]);
                                     ll[2] += rr[2];
                                 });
          return avg[2] > 0
!             // Better error bounds to add both terms as the final sum to compute average
!             ? OptionalDouble.of((avg[0] + avg[1]) / avg[2])
              : OptionalDouble.empty();
      }
  
      @Override
      public final long count() {
--- 422,448 ----
      public final OptionalDouble average() {
          /*
           * In the arrays allocated for the collect operation, index 0
           * holds the high-order bits of the running sum, index 1 holds
           * the low-order bits of the sum computed via compensated
!          * summation, index 2 holds the number of values seen, index 3
!          * holds the simple sum.
           */
!         double[] avg = collect(() -> new double[4],
                                 (ll, d) -> {
                                     ll[2]++;
                                     Collectors.sumWithCompensation(ll, d);
+                                    ll[3] += d;
                                 },
                                 (ll, rr) -> {
                                     Collectors.sumWithCompensation(ll, rr[0]);
                                     Collectors.sumWithCompensation(ll, rr[1]);
                                     ll[2] += rr[2];
+                                    ll[3] += rr[3];
                                 });
          return avg[2] > 0
!             ? OptionalDouble.of(Collectors.computeFinalSum(avg) / avg[2])
              : OptionalDouble.empty();
      }
  
      @Override
      public final long count() {