MurmurHash3

An implementation of Austin Appleby's MurmurHash 3 algorithm (MurmurHash3_x86_32). This object contains methods that hash values of various types as well as means to construct Hashing objects.

This algorithm is designed to generate well-distributed non-cryptographic hashes. It is designed to hash data in 32 bit chunks (ints).

The mix method needs to be called at each step to update the intermediate hash value. For the last chunk to incorporate into the hash mixLast may be used instead, which is slightly faster. Finally finalizeHash needs to be called to compute the final hash value.

This is based on the earlier MurmurHash3 code by Rex Kerr, but the MurmurHash3 algorithm was since changed by its creator Austin Appleby to remedy some weaknesses and improve performance. This represents the latest and supposedly final version of the algorithm (revision 136).

See also: https://github.com/aappleby/smhasher

Linear Supertypes

MurmurHash3, AnyRef, Any

Type Members

class ArrayHashing[T] extends Hashing[Array[T]]

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def arrayHash[T](a: Array[T]): Int
final def arrayHash[T](a: Array[T], seed: Int): Int

Compute the hash of an array.
Compute the hash of an array.

Definition Classes
MurmurHash3
def arrayHashing[T]: ArrayHashing[T]
final val arraySeed: Int(1007110753)
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bytesHash(data: Array[Byte]): Int
final def bytesHash(data: Array[Byte], seed: Int): Int

Compute the hash of a byte array.
Compute the hash of a byte array. Faster than arrayHash, because it hashes 4 bytes at once.

Definition Classes
MurmurHash3
def bytesHashing: Hashing[Array[Byte]]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def finalizeHash(hash: Int, length: Int): Int

Finalize a hash to incorporate the length and make sure all bits avalanche.
Finalize a hash to incorporate the length and make sure all bits avalanche.

Definition Classes
MurmurHash3
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def listHash(xs: collection.immutable.List[_], seed: Int): Int

Definition Classes
MurmurHash3
def mapHash(xs: Map[_, _]): Int
final val mapSeed: Int
final def mix(hash: Int, data: Int): Int

Mix in a block of data into an intermediate hash value.
Mix in a block of data into an intermediate hash value.

Definition Classes
MurmurHash3
final def mixLast(hash: Int, data: Int): Int

May optionally be used as the last mixing step.
May optionally be used as the last mixing step. Is a little bit faster than mix, as it does no further mixing of the resulting hash. For the last element this is not necessary as the hash is thoroughly mixed during finalization anyway.

Definition Classes
MurmurHash3
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def orderedHash(xs: TraversableOnce[Any]): Int
final def orderedHash(xs: TraversableOnce[Any], seed: Int): Int

Compute a hash that depends on the order of its arguments.
Compute a hash that depends on the order of its arguments.

Definition Classes
MurmurHash3
def orderedHashing: Hashing[TraversableOnce[Any]]
def productHash(x: Product): Int
final def productHash(x: Product, seed: Int): Int

Compute the hash of a product
Compute the hash of a product

Definition Classes
MurmurHash3
def productHashing: Hashing[Product]
final val productSeed: Int(-889275714)
def seqHash(xs: collection.Seq[_]): Int

To offer some potential for optimization.
final val seqSeed: Int
def setHash(xs: Set[_]): Int
final val setSeed: Int
def stringHash(x: String): Int
final def stringHash(str: String, seed: Int): Int

Compute the hash of a string
Compute the hash of a string

Definition Classes
MurmurHash3
def stringHashing: Hashing[String]
final val stringSeed: Int(-137723950)
final val symmetricSeed: Int(-1248659538)
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final val traversableSeed: Int(-415593707)
def unorderedHash(xs: TraversableOnce[Any]): Int
final def unorderedHash(xs: TraversableOnce[Any], seed: Int): Int

Compute a hash that is symmetric in its arguments - that is a hash where the order of appearance of elements does not matter.
Compute a hash that is symmetric in its arguments - that is a hash where the order of appearance of elements does not matter. This is useful for hashing sets, for example.

Definition Classes
MurmurHash3
def unorderedHashing: Hashing[TraversableOnce[Any]]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package hashing

object MurmurHash3 extends MurmurHash3

Type Members

class ArrayHashing[T] extends Hashing[Array[T]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def arrayHash[T](a: Array[T]): Int

final def arrayHash[T](a: Array[T], seed: Int): Int

def arrayHashing[T]: ArrayHashing[T]

final val arraySeed: Int(1007110753)

final def asInstanceOf[T0]: T0

def bytesHash(data: Array[Byte]): Int

final def bytesHash(data: Array[Byte], seed: Int): Int

def bytesHashing: Hashing[Array[Byte]]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def finalizeHash(hash: Int, length: Int): Int

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def listHash(xs: collection.immutable.List[_], seed: Int): Int

def mapHash(xs: Map[_, _]): Int

final val mapSeed: Int

final def mix(hash: Int, data: Int): Int

final def mixLast(hash: Int, data: Int): Int

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orderedHash(xs: TraversableOnce[Any]): Int

final def orderedHash(xs: TraversableOnce[Any], seed: Int): Int

def orderedHashing: Hashing[TraversableOnce[Any]]

def productHash(x: Product): Int

final def productHash(x: Product, seed: Int): Int

def productHashing: Hashing[Product]

final val productSeed: Int(-889275714)

def seqHash(xs: collection.Seq[_]): Int

final val seqSeed: Int

def setHash(xs: Set[_]): Int

final val setSeed: Int

def stringHash(x: String): Int

final def stringHash(str: String, seed: Int): Int

def stringHashing: Hashing[String]

final val stringSeed: Int(-137723950)

final val symmetricSeed: Int(-1248659538)

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

def toString(): String

final val traversableSeed: Int(-415593707)

def unorderedHash(xs: TraversableOnce[Any]): Int

final def unorderedHash(xs: TraversableOnce[Any], seed: Int): Int

def unorderedHashing: Hashing[TraversableOnce[Any]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from MurmurHash3

Inherited from AnyRef

Inherited from Any

Ungrouped