Change the ChebHash and MonteCarloHash APIs to accept a function-space similarity rather than a similarity for discrete vectors. This is a fix for issue #19.

Author: kernelmethod

src/function_hashing/chebhash.jl

@@ -11,29 +11,50 @@ Typedefs
 ========================#
 
 # B = basis, which is a Symbol (e.g. :Chebyshev)
-struct ChebHash{B, H<:LSHFunction, I<:RealInterval}
+struct ChebHash{B, F<:SimilarityFunction, H<:LSHFunction, I<:RealInterval}
+    # Discrete-space hash function used after extracting Chebyshev polynomial
+    # coefficients from the input function.
     discrete_hashfn :: H
 
     # Interval over which all input functions are defined.
     interval :: I
+
+    ### Internal ChebHash constructors
+    function ChebHash{B,F}(
+                hashfn::H,
+                interval::I
+            ) where {B, F<:SimilarityFunction, H<:LSHFunction, I<:RealInterval}
+
+        new{B,F,H,I}(hashfn, interval)
+    end
 end
 
 ### External ChebHash constructors
-ChebHash{S}(hashfn::H, interval::I) where {S, H<:LSHFunction, I<:RealInterval} =
-    ChebHash{S,H,I}(hashfn, interval)
-
 ChebHash(similarity, args...; kws...) =
     ChebHash(SimilarityFunction(similarity), args...; kws...)
 
-function ChebHash(::SimilarityFunction{S},
-                  args...;
-                  interval::RealInterval = @interval(-1 ≤ x ≤ 1),
-                  kws...) where S
-
-    discrete_hashfn = LSHFunction(S, args...; kws...)
-    ChebHash{:Chebyshev}(discrete_hashfn, interval)
+for (discrete_sim, fn_sim) in zip([ℓ2, cossim], [L2, cossim])
+    quote
+        # Add an implementation of ChebHash that dispatches on the similarity
+        # function fn_sim
+        function ChebHash(sim::SimilarityFunction{$fn_sim},
+                          args...;
+                          interval::RealInterval = @interval(-1 ≤ x ≤ 1),
+                          kws...) where S
+
+            discrete_hashfn = LSHFunction($discrete_sim, args...; kws...)
+            ChebHash{:Chebyshev,typeof(sim)}(discrete_hashfn, interval)
+        end
+    end |> eval
 end
 
+# Implementation of ChebHash for invalid similarity functions. Just throws
+# a TypeError. Necessary because otherwise the first external ChebHash
+# constructor will go into an infinite loop when it receives an invalid
+# similarity function.
+ChebHash(sim::SimilarityFunction, args...; kws...) =
+    ErrorException("similarity must be ℓ2 or cossim") |> throw
+
 #========================
 Helper functions for ChebHash
 ========================#
@@ -76,8 +97,7 @@ LSHFunction API compliance
 n_hashes(hashfn::ChebHash) =
     n_hashes(hashfn.discrete_hashfn)
 
-similarity(hashfn::ChebHash) =
-    similarity(hashfn.discrete_hashfn)
+similarity(::ChebHash{T,SimilarityFunction{F}}) where {T,F} = F
 
 hashtype(hashfn::ChebHash) =
     hashtype(hashfn.discrete_hashfn)

src/function_hashing/monte_carlo.jl

@@ -8,7 +8,9 @@ MonteCarloHash for hashing function spaces.
 Typedefs
 ========================#
 
-struct MonteCarloHash{H <: LSHFunction, D, T, S} <: LSHFunction
+struct MonteCarloHash{F, H <: LSHFunction, D, T, S} <: LSHFunction
+    similarity :: F
+
     discrete_hashfn :: H
     μ :: D
 
@@ -28,14 +30,18 @@ struct MonteCarloHash{H <: LSHFunction, D, T, S} <: LSHFunction
     sample_points :: Vector{S}
 
     ### Internal constructors
-    function MonteCarloHash(discrete_hashfn::H, μ, volume, p, n_samples) where {H<:LSHFunction}
+    function MonteCarloHash(similarity::F, discrete_hashfn::H, μ, volume,
+                            p, n_samples) where {F, H<:LSHFunction}
         sample_points = [μ() for ii = 1:n_samples]
 
         T = eltype(μ())
         volume = T(volume)
         p = T(p)
 
-        new{H,typeof(μ),T,eltype(sample_points)}(discrete_hashfn, μ, volume, p, n_samples, sample_points)
+        new{F,H,typeof(μ),T,eltype(sample_points)}(
+            similarity, discrete_hashfn, μ, volume,
+            p, n_samples, sample_points
+        )
     end
 end
 
@@ -45,15 +51,16 @@ end
 MonteCarloHash(similarity, args...; kws...) =
     MonteCarloHash(SimilarityFunction(similarity), args...; kws...)
 
-for (simfn,p) in zip([ℓ1,ℓ2,cossim], [1,2,2])
+for (simfn, fn_space_simfn, p) in zip([ℓ1,ℓ2,cossim], [L1,L2,cossim], [1,2,2])
     quote
-        # Create implementation of MonteCarloHash for current similarity function
-        # and order of L^p space
-        function MonteCarloHash(sim::SimilarityFunction{$simfn}, μ, args...;
+        # Add dispatch for case in which we specify the similarity function
+        # to be $fn_space_simfn
+        function MonteCarloHash(sim::SimilarityFunction{$fn_space_simfn}, μ, args...;
                                 n_samples::Int64=1024, volume=1.0, kws...)
 
             discrete_hashfn = LSHFunction($simfn, args...; kws...)
-            MonteCarloHash(discrete_hashfn, μ, volume, $p, n_samples)
+            MonteCarloHash($fn_space_simfn, discrete_hashfn, μ, volume,
+                           $p, n_samples)
         end
     end |> eval
 end
@@ -75,8 +82,7 @@ LSHFunction API compliance
 hashtype(hashfn::MonteCarloHash) =
     hashtype(hashfn.discrete_hashfn)
 
-similarity(hashfn::MonteCarloHash) =
-    similarity(hashfn.discrete_hashfn)
+similarity(hashfn::MonteCarloHash) = hashfn.similarity
 
 n_hashes(hashfn::MonteCarloHash) =
     n_hashes(hashfn.discrete_hashfn)

test/function_hashing/test_chebhash.jl

@@ -19,12 +19,26 @@ Tests
         @test n_hashes(hashfn) == 5
         @test hashtype(hashfn) == hashtype(LSHFunction(cossim))
 
-        # Hash L^2([-1,1]) over L^p distance
-        hashfn = ChebHash(ℓ1)
+        # Hash L^2([-1,1]) over L^2 distance
+        hashfn = ChebHash(L2)
 
         @test n_hashes(hashfn) == 1
-        @test similarity(hashfn) == ℓ1
-        @test hashtype(hashfn) == hashtype(LSHFunction(ℓ1))
+        @test similarity(hashfn) == L2
+        @test hashtype(hashfn) == hashtype(LSHFunction(ℓ2))
+    end
+
+    @testset "Provide invalid similarity" begin
+        # When we pass in a similarity that is not supported by ChebHash
+        # we should receive an error.
+        @test_throws(ErrorException, ChebHash((x,y) -> abs(x-y)))
+        @test_throws(ErrorException, ChebHash(ℓ1))
+        @test_throws(ErrorException, ChebHash(L1))
+        @test_throws(ErrorException, ChebHash(ℓ2))
+
+        # Construct a hash function (with valid similarity_ in the same
+        # manner as we did above in case the ChebHash API ever changes.
+        # This ensures that we won't forget to update these tests.
+        _ = ChebHash(L2)
     end
 
     #==========
@@ -97,7 +111,7 @@ Tests
         ### Hash two functions with L^2 distance ≈ 0
         f(x) = 0.0
         g(x) = (-0.5 ≤ x ≤ 0.5) ? 1e-3 : 0.0
-        hashfn = ChebHash(ℓ2, 1024)
+        hashfn = ChebHash(L2, 1024)
 
         @test embedded_similarity(hashfn, f, g) ≈ 1e-3
 
@@ -115,7 +129,7 @@ Tests
 
     @testset "Hash L^2 distance (nontrivial inputs)" begin
         interval = LSHFunctions.@interval(-1.0 ≤ x ≤ 1.0)
-        hashfn = ChebHash(ℓ2, 1024; interval=interval)
+        hashfn = ChebHash(L2, 1024; interval=interval)
 
         trig_function_test() = begin
             f = ShiftedSine(π, π * rand())

test/function_hashing/test_monte_carlo.jl

@@ -21,10 +21,10 @@ Tests
         @test hashtype(hashfn) == hashtype(LSHFunction(cossim))
 
         # Hash L^1([0,1]) over L^1 distance
-        hashfn = MonteCarloHash(ℓ1, μ, 10)
+        hashfn = MonteCarloHash(L1, μ, 10)
 
         @test n_hashes(hashfn) == 10
-        @test similarity(hashfn) == ℓ1
+        @test similarity(hashfn) == L1
         @test hashtype(hashfn) == hashtype(LSHFunction(ℓ1))
     end
 
@@ -75,7 +75,7 @@ Tests
         # you can map them into R^N isomorphically
         N = 4
         μ() = N * rand()
-        hashfn = MonteCarloHash(ℓ1, μ, 1024; volume = N)
+        hashfn = MonteCarloHash(L1, μ, 1024; volume = N)
 
         @test let success = true, ii = 1
             while success && ii ≤ 128