MinHasher32

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def approxCount(sig: Array[Byte]): Long

seems to work, but experimental and not generic yet

final def asInstanceOf[T0]: T0

def assertNotZero(v: Array[Byte]): Unit

def buckets(sig: Array[Byte]): List[Long]

Bucket keys to use for quickly finding other similar items via locality sensitive hashing

def buildArray(left: Array[Byte], right: Array[Byte])(fn: (Int, Int) ⇒ Int): Array[Byte]

Decode two signatures into hash values, combine them somehow, and produce a new array

def buildArray(fn: ⇒ Int): Array[Byte]

Initialize a byte array by generating hash values

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val estimatedThreshold: Double

useful for understanding the effects of numBands and numRows

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

val hashFunctions: IndexedSeq[MurmurHash128]

We always use a 128 bit hash function, so the number of hash functions is different (and usually smaller) than the number of hashes in the signature.

def hashSize: Int

the number of bytes used for each hash in the signature

def init(fn: (MurmurHash128) ⇒ (Long, Long)): Array[Byte]

Create a signature for an arbitrary value

def init(value: String): Array[Byte]

Create a signature for a single String value

def init(value: Long): Array[Byte]

Create a signature for a single Long value

final def isInstanceOf[T0]: Boolean

def isNonZero(v: Array[Byte]): Boolean

def maxHash: Int

Maximum value the hash can take on (not 2*hashSize because of signed types)

final def ne(arg0: AnyRef): Boolean

def nonZeroOption(v: Array[Byte]): Option[Array[Byte]]

final def notify(): Unit

final def notifyAll(): Unit

val numBands: Int

For explanation of the "bands" and "rows" see Ullman and Rajaraman

val numBytes: Int

val numHashes: Int

val numRows: Int

def pickBands(threshold: Double, hashes: Int): Int

numerically solve the inverse of estimatedThreshold, given numBands*numRows

def plus(left: Array[Byte], right: Array[Byte]): Array[Byte]

Set union

def probabilityOfInclusion(sim: Double): Double

useful for understanding the effects of numBands and numRows

val seed: Int

This seed could be anything

def similarity(left: Array[Byte], right: Array[Byte]): Double

Esimate jaccard similarity (size of union / size of intersection)

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

val zero: Array[Byte]

Signature for empty set, needed to be a proper Monoid

def sum(vs: TraversableOnce[Array[Byte]]): Array[Byte]