Change hashtype() so that the output is the dtype of h[idx] (where h is a list of hashes computed by an LSHFunction).

Author: kernelmethod

src/hashes/lphash.jl

@@ -180,7 +180,7 @@ LSHFunction and SymmetricLSHFunction API compliance
 ========================#
 
 n_hashes(h::LpHash) = length(h.shift)
-hashtype(::LpHash) = Vector{Int32}
+hashtype(::LpHash) = Int32
 
 # See Section 3.2 of the reference
 function single_hash_collision_probability(hashfn::LpHash, sim::Real)

src/hashes/minhash.jl

@@ -137,8 +137,8 @@ end
 #========================
 LSHFunction and SymmetricLSHFunction API compliance
 ========================#
-n_hashes(hashfn :: MinHash) = length(hashfn.mappings)
-hashtype(:: MinHash{T, I}) where {T, I} = I
+n_hashes(hashfn::MinHash) = length(hashfn.mappings)
+hashtype(::MinHash{T, I}) where {T, I} = I
 similarity(::MinHash) = jaccard
 
 single_hash_collision_probability(::MinHash, sim) = sim

src/hashes/mips_hash.jl

@@ -233,4 +233,4 @@ query_hash(hashfn::MIPSHash, x) = MIPSHash_Q(hashfn, x)
 similarity(::MIPSHash) = inner_prod
 
 n_hashes(hashfn::MIPSHash) = length(hashfn.shift)
-hashtype(::MIPSHash) = Vector{Int32}
+hashtype(::MIPSHash) = Int32

src/hashes/sign_alsh.jl

@@ -205,4 +205,4 @@ query_hash(h::SignALSH, x) = SignALSH_Q(h, x)
 
 n_hashes(h::SignALSH) = size(h.coeff_A, 1)
 similarity(::SignALSH) = inner_prod
-hashtype(::SignALSH) = BitArray{1}
+hashtype(::SignALSH) = Bool

src/hashes/simhash.jl

@@ -120,7 +120,7 @@ current_max_input_size(hashfn::SimHash) = size(hashfn.coeff, 1)
 LSHFunction and SymmetricLSHFunction API compliance
 ========================#
 
-hashtype(::SimHash) = BitArray{1}
+hashtype(::SimHash) = Bool
 n_hashes(hashfn::SimHash) = size(hashfn.coeff, 2)
 similarity(::SimHash) = cossim
 single_hash_collision_probability(::SimHash, sim::Real) = (1 - acos(sim) / π)

src/tables/table.jl

@@ -20,6 +20,8 @@ end
 # Outer constructors
 function LSHTable(hashfn; valtype=Any, unique_values=false, entrytype=Vector)
 	htype = hashtype(hashfn)
+    htype = (htype == Bool) ? BitArray{1} : Vector{htype}
+
 	vtype, etype, ltype = begin
 		if entrytype <: Vector
 			vtype = (valtype <: eltype(entrytype)) ? valtype : eltype(entrytype)

test/hashes/test_lphash.jl

@@ -16,6 +16,7 @@ Tests
         @test L1_hash.r == 2
         @test L1_hash.power == 1
         @test similarity(L1_hash) == ℓ1
+        @test hashtype(L1_hash) == Int32
 
         # Construct a hash for L^2 distance
         L2_hash = L2Hash(12; r = 3.4)
@@ -57,7 +58,7 @@ Tests
 
         # Test 1: Vector{Float64} -> Vector{Int32}
         hashes = hashfn(randn(5))
-        @test Vector{eltype(hashes)} == hashtype(hashfn)
+        @test eltype(hashes) == hashtype(hashfn)
         @test isa(hashes, Vector{Int32})
 
         # Test 2: Matrix{Float64} -> Matrix{Int32}

test/hashes/test_minhash.jl

@@ -56,19 +56,21 @@ Tests
 
         dataset = shuffle(symbols)[1:10]
         hashes = hashfn(dataset)
-        hashes_match = true
 
-        for (hash, mapping) in zip(hashes, hashfn.mappings)
-            if !hashes_match
-                break
-            end
+        @test eltype(hashes) == hashtype(hashfn)
 
-            # Compute MinHash manually
-            expected_hash = minimum(mapping[x] for x in dataset)
-            hashes_match &= (hash == expected_hash)
-        end
+        @test let hashes_match = true
+            for (hash, mapping) in zip(hashes, hashfn.mappings)
+                if !hashes_match
+                    break
+                end
 
-        @test hashes_match
+                # Compute MinHash manually
+                expected_hash = minimum(mapping[x] for x in dataset)
+                hashes_match &= (hash == expected_hash)
+            end
+            hashes_match
+        end
     end
 
     @testset "Collision probabilities correlated with Jaccard similarity" begin

test/hashes/test_mips_hash.jl

@@ -15,7 +15,7 @@ Tests
         hashfn = MIPSHash(; maxnorm=1)
 
         @test n_hashes(hashfn) == 1
-        @test hashtype(hashfn) == Vector{Int32}
+        @test hashtype(hashfn) == Int32
         @test similarity(hashfn) == inner_prod
         @test isa(hashfn, MIPSHash{Float32})    # Default dtype should be Float32
         @test isa(hashfn, LSH.AsymmetricLSHFunction)
@@ -63,8 +63,8 @@ Tests
 
         @test isa(p_hashes, Matrix{Int32})
         @test isa(q_hashes, Matrix{Int32})
-        @test Vector{eltype(p_hashes)} == hashtype(hashfn)
-        @test Vector{eltype(q_hashes)} == hashtype(hashfn)
+        @test hashtype(hashfn) == eltype(p_hashes)
+        @test hashtype(hashfn) == eltype(q_hashes)
 
         # Vector{Float64} -> Vector{Int32}
         x = randn(4)

test/hashes/test_sign_alsh.jl

@@ -13,7 +13,7 @@ Tests
         @test n_hashes(hashfn) == 1
         @test isa(hashfn, SignALSH{Float32})
         @test isa(hashfn, LSH.AsymmetricLSHFunction)
-        @test hashtype(hashfn) == BitArray{1}
+        @test hashtype(hashfn) == Bool
         @test similarity(hashfn) == inner_prod
 
         hashfn = SignALSH(32; maxnorm=1)
@@ -50,7 +50,7 @@ Tests
         qhashes = query_hash(hashfn, X)
 
         @test eltype(ihashes) == eltype(qhashes)
-        @test BitArray{1} == hashtype(hashfn)
+        @test hashtype(hashfn) == Bool
 
         # 1. Compute the indexing hashes manually
         norms = map(norm, eachcol(X))