Add efficient SparseVector method for some metrics

[jlapeyre]

This PR makes the following efficient for SparseVector, partially addressing #5.

• bhattacharyya, bhattacharyya_coeff
• HellingerDist, which follow directly from the previous item
• non-weighted UnionMetrics. For example euclidean(v1, v2). Specifically a method for _evaluate(d::UnionMetrics, a::SparseVector, b::SparseVector, ::Nothing) is included.

julia> n = 1000; dens = 0.1; v1 = sprand(n, dens); v2 = sprand(n, dens);

julia> @btime bhattacharyya($v1, $v2)  # before this PR
  14.877 μs (0 allocations: 0 bytes)
2.098185998707887

julia> @btime bhattacharyya($v1, $v2)  # after this PR
  240.100 ns (0 allocations: 0 bytes)
2.098185998707887

julia> n = 100; dens = 0.1; v1 = sprand(n, dens); v2 = sprand(n, dens);

julia> @btime bhattacharyya($v1, $v2) # before this PR
  714.130 ns (0 allocations: 0 bytes)
1.251741974341252

julia> @btime bhattacharyya($v1, $v2)  # after this PR
  45.974 ns (0 allocations: 0 bytes)
1.251741974341252

EDIT: The method _binary_map_reduce1 mentioned below has been removed. The implementation has been simplified.

• The new method calls a method _binary_map_reduce1 which is also introduced in this PR. It is general enough to handle other similar use cases. I appended the 1 in (anticipation of several of these methods, in analogy to these functions in SparseArrays in the stdlib. Perhaps removing the 1 in the name until it is needed would be a good idea.

• The function _binary_map_reduce1 works at least if f(0, 0) == 0 and op(v, 0) == v, as well as some other cases noted in the code.

• The numbered functions linked to above are for binary maps, not for binary mapreduce. The reasons for implementing variants (those with numbers appended) is different. In the former case, it is because an output vector is built and the functions are split according to which inputs can produces a zero.

• Which functions like _binary_map_reduce1 to implement, and where to put them is to be decided. It may make sense to decide on some generally useful binary mapreduce helper functions and put them in SparseArrays. In the short term, I put one of them here. They are not in the API so they can easily be moved to another repo later.

I also tried this function

_bhattacharyya_coeff(x, y) = (sum(sqrt, x .* y), sum(x), sum(y))

This is also efficient for SparseVector because sum is efficient for a single SparseVector. Yesterday, I thought I found some cases in which it was faster than using _binary_map_reduce1, but I can't find them now. However, it is often within 10 or 20 percent as fast. It is much less complex, which makes it attractive. Also, sum uses pairwise summation, which is more accurate in general. Has Distances.jl consciously opted for speed over correctness? I can understand making this choice for image processing.

See also https://github.com/JuliaLang/julia/issues/43248

[jlapeyre]

In the original PR, two useless loops are executed in _binary_map_reduce1. I think it's better to use a more specialized mapreduce helper function in order to avoid this. The compiler has enough information to realize that repeated
one_nonz_count += 1 can be replaced by a single addition. But, I doubt it does this (@code_llvm shows the loops and operations) so the loops likely run.

I'll simplify the function.

[jlapeyre]

I added support for UnionMetrics. I tested most of the metrics at the cli for efficiency. I added a test in the test suite.

[codecov-commenter]

Codecov Report

Merging #235 (93fa138) into master (9e23809) will increase coverage by 0.17%.
The diff coverage is 100.00%.

@@            Coverage Diff             @@
##           master     #235      +/-   ##
==========================================
+ Coverage   97.39%   97.57%   +0.17%     
==========================================
  Files           8        8              
  Lines         806      865      +59     
==========================================
+ Hits          785      844      +59     
  Misses         21       21              

Impacted Files	Coverage Δ
src/Distances.jl	100.00% <ø> (ø)
src/bhattacharyya.jl	98.21% <100.00%> (+0.99%)	⬆️
src/metrics.jl	96.90% <100.00%> (+0.29%)	⬆️

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 9e23809...93fa138. Read the comment docs.

[jlapeyre]

These tests just convert dense matrices to sparse. EDIT: the following is done. More tests are needed to exercise code paths for different numbers of non-zeros.

[dkarrasch]

For nice code coverage, can you add a quick test with two sparse vectors of (i) different lengths and (ii) both of length 0, please? That should yield 100% diff coverage, and then we're ready to go IMO.

[jlapeyre]

different lengths
You mean different lengths so that an error is thrown, right ?

[dkarrasch]

Just a few (minor style) comments.

[dkarrasch]

Shall we leave a comment about assumptions underlying the sparse UnionMetric implementation? AFAIU, the only assumption is that eval_reduce(d, s, eval_op(d, 0, 0)) == s, right? Because you jump over zero pairs.

[jlapeyre]

the only assumption is that eval_reduce(d, s, eval_op(d, 0, 0)) == s

Yes, I think this is correct.