[
https://issues.apache.org/jira/browse/STATISTICS-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17746037#comment-17746037
]
Anirudh Joshi commented on STATISTICS-77:
-----------------------------------------
{quote}Will that work?
{quote}
That would depend on the implementation. Not all implementations may be
meaningfully combined. For instance, lets take the example of the {{Sum}} class
above. Lets say we have 2 implementations, say, {{SimpleSum}} that just
accumulates the sum using '+' operator and a {{KahanSum}} (CompensatedSum) that
accumulates the sum using the {{[Kahan
Sum|https://en.wikipedia.org/wiki/Kahan_summation_algorithm]}} algorithm. Lets
say we have a {{SimpleSum}} instance *a* and {{KahanSum}} instance {*}b{*}. One
could argue merging {{a}} to {{b}} ({{{}SimpleSum{}}} --> {{KahanSum)}} may be
disallowed since this would result in loss of precision in {{{}b{}}}. On the
other hand merging {{b}} to {{a}} ({{{}KahanSum{}}} --> {{{}SimpleSum{}}}) may
be allowed since {{b}} computes and can supply a higher precision sum than
{{{}a{}}}.
{code:java}
final Sum a = Sum.create(Type.SIMPLE); // Create an instance that uses
SimpleSum implementation.
a.accept(1);
final Sum b = Sum.create(Type.KAHAN); // Create an instance that uses
CompensatedSum implementation.
b.accept(2);
// Disallowed. Throws IllegalArgumentException / UnsupportedOperationException.
final double disallow = b.combine(a).getAsDouble();
// Allowed. Updates a.sum = a.sum + b.getAsDouble()
final double allow = a.combine(b).getAsDouble();{code}
> Implement Sum
> -------------
>
> Key: STATISTICS-77
> URL: https://issues.apache.org/jira/browse/STATISTICS-77
> Project: Commons Statistics
> Issue Type: Sub-task
> Components: descriptive
> Reporter: Anirudh Joshi
> Priority: Minor
> Labels: gsoc, gsoc2023
>
> This implementation uses {{commons-numbers}}
> [Sum|https://github.com/apache/commons-numbers/blob/master/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/Sum.java]
> as the underlying implementation.
> This may be further expanded to include various other Sum implementations
> like [Kahan Sum|https://en.wikipedia.org/wiki/Kahan_summation_algorithm],
> {{Neumaier Sum}} (Two sum method) etc. with the option for the users to
> choose an implementation. However, before beginning the implementation of
> various other algorithms it may be worthwhile to discuss and investigate the
> relative speed of the current Sum implementation compared to
> {{DoubleStream.sum}} through JMH benchmarks.
> When we know the different speeds, it would be more clear if the user should
> have a choice for this statistic, e.g.
> * When using {{DoubleStream.sum}} is too slow and it would be nice to have a
> simple sum variation.
> * When the sum has a lot of cancellation and {{DoubleStream.sum}} suffers
> from random walk around zero.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
