[PATCH] 8178117: Add public state constructors for Int/Long/DoubleSummaryStatistics

[Peter Levart]

On 04/12/2017 04:41 PM, Peter Levart wrote:
> On 04/11/2017 10:48 PM, Chris Dennis wrote:
>> Color me confused… what would the javadoc on the parameter say? It 
>> could I guess have an @implNote documenting the meanings of the 
>> parameters… but then what use is it? The proposed API simply limits 
>> the precision with which a DoubleSummaryStatistic can be copied to be 
>> the same as the precision with which it can be “accessed”. That 
>> doesn’t seem an enormous problem since I suspect that bulk of usages 
>> would be to marshall a “finished” instance and therefore there is no 
>> real loss occuring. If we wanted to support arbitrary precision 
>> wouldn’t it be better to have a constructor variant that took a 
>> BigDecimal, and a matching getPreciseSum() that returned a BigDecimal?
>
> And how would you compute the value for BigDecimal getPreciseSum() so 
> that you could then set 3 internal double fields from BigDecimal 
> without loss of information? 


...perhaps we could use the BigDecimal getPreciseSum() together with 
getSum() to reconstruct the state. For exmaple:

     /**
      * Construct an instance with values obtained from another instance.
      *
      * @param count what was returned from another instance's {@link 
#getCount()}
      * @param sum what was returned from another instance's {@link 
#getSum()}
      * @param preciseSum what was returned from another instance's 
{@link #getPreciseSum()}
      * @param min what was returned from another instance's {@link 
#getMin()}
      * @param max what was returned from another instance's {@link 
#getMax()}
      */
     public DoubleSummaryStatistics(long count,
                                    double sum, BigDecimal preciseSum,
                                    double min, double max) {
         if (count < 0L) {
             throw new IllegalArgumentException("count < 0");
         } else if (count > 0L) {
             if (min > max) {
                 throw new IllegalArgumentException("min > max");
             }
             this.count = count;
             this.min = min;
             this.max = max;
             setSum(sum, preciseSum);
         }
     }

     /**
      * If {@link #getSum()} returns {@link Double#NaN} or {@link 
Double#POSITIVE_INFINITY}
      * or {@link Double#NEGATIVE_INFINITY}, then this method returns 
{@code null},
      * otherwise it returns a value that is a more precise 
representation of the
      * sum of values recorded and can be used in
      * {@link #DoubleSummaryStatistics(long, double, BigDecimal, 
double, double)}
      * to construct an object with internal state that closely 
resembles the state of
      * original object.
      *
      * @return a precise sum in BigDecimal form.
      */
     public final BigDecimal getPreciseSum() {
         double sum = getSum();
         if (Double.isNaN(sum) || Double.isInfinite(sum)) {
             return null;
         } else {
             return new BigDecimal(this.sum).add(
                 new BigDecimal(this.sumCompensation));
         }
     }

     private void setSum(double sum, BigDecimal preciseSum) {
         if (preciseSum == null) {
             if (!Double.isNaN(sum) && !Double.isInfinite(sum)) {
                 throw new IllegalArgumentException(
                     "preciseSum is null but sum is not a NaN and not 
Infinite");
             }
             this.sum = this.simpleSum = sum;
             this.sumCompensation = 0d;
         } else {
             if (Double.isNaN(sum) || Double.isInfinite(sum)) {
                 throw new IllegalArgumentException(
                     "preciseSum is non-null but sum is NaN or Infinite");
             }
             this.sum = this.simpleSum = preciseSum.doubleValue();
             this.sumCompensation = preciseSum.subtract(new 
BigDecimal(this.sum)).doubleValue();
         }
     }


Hm....


Regards, Peter