Complete the renaming of the package from 'LSH.jl' to 'LSHFunctions.jl'.

The Julia General registry requires that modules names (a) are at least five letters long; and (b) end in a lowercase letter, except with admin approval. While it's possible that we'll eventually be able to alias 'LSH' to 'LSHFunctions' or some such, for now it seems that the best course of action is simply to rename the module to LSHFunctions. This will have the additional benefit of creating a naming scheme for future packages, e.g. LSHTables.

Squashed commit of the following:

commit 2f6284f
Author: kernelmethod <[email protected]>
Date:   Mon Jan 20 14:58:29 2020 -0700

    Change from the LSH module to LSHFunctions in the documentation.

commit 89dbc40
Author: kernelmethod <[email protected]>
Date:   Mon Jan 20 14:30:07 2020 -0700

    Remove remaining references to the LSH package/module, and replace them with references to the LSHFunctions package/module.

commit 7531cb1
Author: kernelmethod <[email protected]>
Date:   Mon Jan 20 14:27:25 2020 -0700

    Remove usages of the LSH module / package in the tests, and replaced them with LSHFunctions.

commit b754fc7
Author: kernelmethod <[email protected]>
Date:   Mon Jan 20 14:19:04 2020 -0700

    Change the register_similarity! macro to generate LSHFunctions.LSHFunction and LSHFunctions.lsh_family, rather than LSH.LSHFunction and LSHFunctions.lsh_family.

commit f5b80bc
Author: kernelmethod <[email protected]>
Date:   Mon Jan 20 14:15:32 2020 -0700

    Rename LSH.jl to LSHFunctions.jl.

Author: kernelmethod

docs/make.jl

@@ -5,12 +5,12 @@ Pkg.activate(); Pkg.instantiate()
 
 pushfirst!(LOAD_PATH, joinpath(@__DIR__, ".."))
 
-using Documenter, LSH
+using Documenter, LSHFunctions
 
 makedocs(
     sitename = "LSHFunctions.jl",
     format   = Documenter.HTML(),
-    modules  = [LSH],
+    modules  = [LSHFunctions],
     pages    = ["Home" => "index.md",
                 "The LSHFunction API" => "lshfunction_api.md",
                 "Similarity functions" => [

docs/src/faq.md

@@ -7,7 +7,7 @@ The reason for computing multiple hashes is that every LSH function provides (at
 
 In fact, the situation can be much more dire than that. If your data are highly structured, it is likely that each of your hashes will place data points into a tiny handful of buckets -- even just one bucket. For instance, in the snippet below we have a dataset of 100 points that all have very high cosine similarity with one another. If we only create a single hash function when we call [`SimHash`](@ref), then it's very likely that all of the data points will have the same hash.
 
-```jldoctest; setup = :(using LSH, Random; Random.seed!(0))
+```jldoctest; setup = :(using LSHFunctions, Random; Random.seed!(0))
 julia> hashfn = SimHash();
 
 julia> data = ones(10, 100);  # Each column is a data point
@@ -24,7 +24,7 @@ julia> unique(hashes)
 The solution to this is to generate multiple hash functions, and combine each of the hashes we compute for an input into a single key. In the snippet below, we create 20 hash functions with [`SimHash`](@ref). Each hash computed in `map(x -> hashfn(x), eachcol(data))` is a length-20 `BitArray`.
 
 
-```jldoctest; setup = :(using LSH, Random; Random.seed!(0))
+```jldoctest; setup = :(using LSHFunctions, Random; Random.seed!(0))
 julia> hashfn = SimHash(20);
 
 julia> data = ones(10,100);  # Each column is a data point

docs/src/full_api.md

@@ -29,14 +29,14 @@ MIPSHash
 ## Similarity functions
 
 ```@autodocs
-Modules = [LSH]
+Modules = [LSHFunctions]
 Private = false
 Pages = ["similarities.jl"]
 ```
 
 ## Private interface
 
 ```@autodocs
-Modules = [LSH]
+Modules = [LSHFunctions]
 Public = false
 ```

docs/src/lshfunction_api.md

@@ -17,7 +17,7 @@ LSHFunction(similarity, n_hashes::Integer=1; kws...)
 For instance, in the snippet below we create a single hash function corresponding to cosine similarity:
 
 ```jldoctest
-julia> using LSH
+julia> using LSHFunctions
 
 julia> hashfn = LSHFunction(cossim);
 
@@ -37,7 +37,7 @@ As another example, following code snippet creates 10 hash functions for inner p
 - `maxnorm`: an upper bound on the norm of the data points we're hashing, and a required parameter for [`SignALSH`](@ref).
 
 ```jldoctest
-julia> using LSH
+julia> using LSHFunctions
 
 julia> hashfn = LSHFunction(inner_prod, 10; dtype=Float64, maxnorm=5.0);
 
@@ -64,7 +64,7 @@ julia> hashfn.maxnorm
 
 If you want to know what hash function will be created for a given similarity, you can use [`lsh_family`](@ref):
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> lsh_family(jaccard)
 MinHash
 
@@ -77,7 +77,7 @@ LSHFunctions.jl provides a few common utility functions that you can use across
 
 - [`n_hashes`](@ref): returns the number of hash functions computed by an [`LSHFunction`](@ref).
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = LSHFunction(jaccard);
 
 julia> n_hashes(hashfn)
@@ -96,7 +96,7 @@ julia> length(hashes)
 
 - [`similarity`](@ref): returns the similarity function for which the input [`LSHFunction`](@ref) is locality-sensitive:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = LSHFunction(cossim);
 
 julia> similarity(hashfn)
@@ -105,7 +105,7 @@ cossim (generic function with 2 methods)
 
 - [`hashtype`](@ref): returns the type of hash computed by the input hash function. Note that in practice `hashfn(x)` (or [`index_hash(hashfn,x)`](@ref) and [`query_hash(hashfn,x)`](@ref) for an [`AsymmetricLSHFunction`](@ref)) will return an array of hashes, one for each hash function you generated. [`hashtype`](@ref) is the data type of each element of `hashfn(x)`.
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = LSHFunction(cossim, 5);
 
 julia> hashtype(hashfn)
@@ -122,7 +122,7 @@ true
 
 - [`collision_probability`](@ref): returns the probability of collision for two inputs with a given similarity. For instance, the probability that a single MinHash hash function causes a collision between inputs `A` and `B` is equal to [`jaccard(A,B)`](@ref jaccard):
 
-  ```jldoctest; setup = :(using LSH)
+  ```jldoctest; setup = :(using LSHFunctions)
   julia> hashfn = MinHash();
 
   julia> A = Set(["a", "b", "c"]);
@@ -137,7 +137,7 @@ true
 
   We often want to compute the probability that not just one hash collides, but that multiple hashes collide simultaneously. You can calculate this using the `n_hashes` keyword argument. If left unspecified, then [`collision_probability`](@ref) will use [`n_hashes(hashfn)`](@ref n_hashes) hash functions to compute the probability.
 
-  ```jldoctest; setup = :(using LSH)
+  ```jldoctest; setup = :(using LSHFunctions)
   julia> hashfn = MinHash(5);
 
   julia> A = Set(["a", "b", "c"]);

docs/src/similarities/cosine.md

@@ -13,7 +13,7 @@ Concretely, cosine similarity is computed as
 where ``\left\langle\cdot,\cdot\right\rangle`` is an inner product (e.g., dot product) and ``\|\cdot\|`` is the norm derived from that inner product. ``\text{cossim}(x,y)`` goes from ``-1`` to ``1``, where ``-1`` corresponds to low similarity and ``1`` corresponds to high similarity. To calculate cosine similarity, you can use the [`cossim`](@ref) function exported from the `LSH` module:
 
 ```jldoctest
-julia> using LSH, LinearAlgebra
+julia> using LSHFunctions, LinearAlgebra
 
 julia> x = [5, 3, -1, 1];  # norm(x) == 6
 
@@ -29,7 +29,7 @@ true
 ## SimHash
 *SimHash*[^1][^2] is a family of LSH functions for hashing with respect to cosine similarity. You can generate a new hash function from this family by calling [`SimHash`](@ref):
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = SimHash();
 
 julia> n_hashes(hashfn)
@@ -43,7 +43,7 @@ julia> n_hashes(hashfn)
 
 Once constructed, you can start hashing vectors by calling `hashfn(x)`:
 
-```jldoctest; setup = :(using LSH, Random; Random.seed!(0)), output = false
+```jldoctest; setup = :(using LSHFunctions, Random; Random.seed!(0)), output = false
 hashfn = SimHash(100)
 
 # x and y have high cosine similarity since they point in the same direction
@@ -65,7 +65,7 @@ true
 
 Note that [`SimHash`](@ref) is a one-bit hash function. As a result, `hashfn(x)` returns a `BitArray`:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = SimHash();
 
 julia> n_hashes(hashfn)
@@ -82,7 +82,7 @@ julia> length(hashes)
 
 Since a single-bit hash doesn't do much to reduce the cost of similarity search, you usually want to generate multiple hash functions at once. For instance, in the snippet below we sample 10 hash functions, so that `hashfn(x)` is a length-10 `BitArray`:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = SimHash(10);
 
 julia> n_hashes(hashfn)
@@ -101,10 +101,10 @@ The probability of a hash collision (for a single hash) is
 where ``\theta = \text{arccos}(\text{cossim}(x,y))`` is the angle between ``x`` and ``y``. This collision probability is shown in the plot below.
 
 ```@eval
-using PyPlot, LSH
+using PyPlot, LSHFunctions
 hashfn = SimHash()
 x = range(-1, 1; length=1024)
-y = [LSH.single_hash_collision_probability(hashfn, xii) for xii in x]
+y = [LSHFunctions.single_hash_collision_probability(hashfn, xii) for xii in x]
 
 plot(x, y)
 title("Probability of hash collision for SimHash")

src/LSHBase.jl

@@ -79,7 +79,7 @@ Compute the probability of hash collision between two inputs with similarity `si
 # Examples
 The probability that a single MinHash hash function causes a hash collision between inputs `A` and `B` is equal to `jaccard(A,B)`:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = MinHash();
 
 julia> A = Set(["a", "b", "c"]);
@@ -95,7 +95,7 @@ julia> collision_probability(hashfn, jaccard(A,B); n_hashes=1)
 
 If our [`MinHash`](@ref) struct keeps track of `N` hash functions simultaneously, then the probability of collision is `jaccard(A,B)^N`:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = MinHash(10);
 
 julia> A = Set(["a", "b", "c"]);
@@ -153,7 +153,7 @@ Computes the probability of a hash collision between two inputs `x` and `y` for
 # Examples
 The following snippet computes the probability of collision between two sets `A` and `B` for a single MinHash. For MinHash, this probability is just equal to the Jaccard similarity between `A` and `B`.
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = MinHash();
 
 julia> A = Set(["a", "b", "c"]);
@@ -171,7 +171,7 @@ true
 
 We can use the `n_hashes` argument to specify the probability that `n_hashes` MinHash hash functions simultaneously collide. If left unspecified, then we'll simply use `n_hashes(hashfn)` as the number of hash functions:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = MinHash(10);
 
 julia> A = Set(["a", "b", "c"]);
@@ -200,7 +200,7 @@ Returns the similarity function that `hashfn` hashes on.
 - `hashfn::AbstractLSHFunction`: the hash function whose similarity we would like to retrieve.
 
 # Examples
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = LSHFunction(cossim);
 
 julia> similarity(hashfn) == cossim
@@ -220,7 +220,7 @@ function similarity end
 Returns the type of hash generated by a hash function.
 
 # Examples
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = LSHFunction(cossim);
 
 julia> hashtype(hashfn)
@@ -240,7 +240,7 @@ function hashtype end
 Return the number of hashes computed by `hashfn`.
 
 # Examples
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = SimHash();
 
 julia> n_hashes(hashfn)

src/LSH.jl renamed to src/LSHFunctions.jl

@@ -1,4 +1,4 @@
-module LSH
+module LSHFunctions
 
 using Distributions, LinearAlgebra, SparseArrays
 

src/function_hashing/chebhash.jl

@@ -27,7 +27,7 @@ ChebHash(similarity, args...; kws...) =
 
 function ChebHash(::SimilarityFunction{S},
                   args...;
-                  interval::RealInterval = LSH.@interval(-1 ≤ x ≤ 1),
+                  interval::RealInterval = LSHFunctions.@interval(-1 ≤ x ≤ 1),
                   kws...) where S
 
     discrete_hashfn = LSHFunction(S, args...; kws...)

src/hashes/lphash.jl

@@ -114,7 +114,7 @@ Constructs a locality-sensitive hash for ``\\ell^$($power)`` distance (``\\|x -
 # Examples
 Construct an `$($hashfn)` with the number of hash functions you want to generate:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = $($hashfn)(128);
 
 julia> hashfn.power == $($power) &&
@@ -125,7 +125,7 @@ true
 
 After creating a hash function, you can compute hashes with `hashfn(x)`:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = $($hashfn)(20);
 
 julia> x = rand(4);

src/hashes/lshfunction.jl

@@ -21,15 +21,15 @@ Register `hashfn` to the `LSH` module as the default locality-sensitive hash fun
 # Examples
 Create a custom implementation of cosine similarity called `my_cossim`, and associate it with `SimHash`:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> using LinearAlgebra: dot, norm
 
 julia> my_cossim(x,y) = dot(x,y) / (norm(x) * norm(y));
 
 julia> hashfn = LSHFunction(my_cossim);
 ERROR: MethodError: no method matching LSHFunction(::typeof(my_cossim))
 
-julia> LSH.@register_similarity!(my_cossim, SimHash);
+julia> LSHFunctions.@register_similarity!(my_cossim, SimHash);
 
 julia> hashfn = LSHFunction(my_cossim);
 
@@ -38,8 +38,8 @@ true
 ```
 """
 macro register_similarity!(similarity, hashfn)
-    lshfn = :(LSH.LSHFunction)
-    lshfam = :(LSH.lsh_family)
+    lshfn = :(LSHFunctions.LSHFunction)
+    lshfam = :(LSHFunctions.lsh_family)
 
     quote
         local similarity = $(esc(similarity))
@@ -113,7 +113,7 @@ Returns a subtype of `LSH.LSHFunction` that hashes the similarity function `simi
 # Examples
 In the snippet below, we construct `$(lsh_family(cossim))` (the default hash function corresponding to cosine similarity) using `LSHFunction()`:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = LSHFunction(cossim);
 
 julia> typeof(hashfn) <: $(lsh_family(cossim)) <: LSHFunction
@@ -122,7 +122,7 @@ true
 
 We can provide arguments and keyword parameters corresponding to the hash function that we construct:
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> hashfn = LSHFunction(inner_prod, 100; dtype=Float64, maxnorm=10);
 
 julia> n_hashes(hashfn) == 100 &&
@@ -154,7 +154,7 @@ help?> SignALSH
 
 # Examples
 
-```jldoctest; setup = :(using LSH)
+```jldoctest; setup = :(using LSHFunctions)
 julia> lsh_family(cossim)
 SimHash