Something like that was what I was envisioning (of course the inability to 
represent NaN or infinity with a BigDecimal is annoying). To me this approach 
really only breaks down when you stop using an actual iteration to perform the 
computation… as long as a “sum” in some form is part of the internal state then 
this still works.

> On Apr 12, 2017, at 12:27 PM, Peter Levart <peter.lev...@gmail.com> wrote:
> 
> 
> 
> 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
> 

Reply via email to