/** * Murmur3 64-bit variant. This is essentially MSB 8 bytes of Murmur3 128-bit variant. * * @param data - input byte array * @return - hashcode */ public static long hash64(byte[] data) { return hash64(data, 0, data.length, DEFAULT_SEED); }
/** * Murmur3 32-bit variant. * * @param data - input byte array * @return - hashcode */ public static int hash32(byte[] data) { return hash32(data, 0, data.length, DEFAULT_SEED); }
public static long hash64(int data) { long k1 = Integer.reverseBytes(data) & (-1L >>> 32); int length = Integer.BYTES; long hash = DEFAULT_SEED; k1 *= C1; k1 = Long.rotateLeft(k1, R1); k1 *= C2; hash ^= k1; // finalization hash ^= length; hash = fmix64(hash); return hash; }
/** * Murmur3 128-bit variant. * * @param data - input byte array * @return - hashcode (2 longs) */ public static long[] hash128(byte[] data) { return hash128(data, 0, data.length, DEFAULT_SEED); }
/** * Murmur3 128-bit variant. * * @param data - input byte array * @return - hashcode (2 longs) */ public static long[] hash128(byte[] data) { return hash128(data, 0, data.length, DEFAULT_SEED); }
/** * Murmur3 32-bit variant. */ public static int hash32(long l0, long l1, int seed) { int hash = seed; final long r0 = Long.reverseBytes(l0); final long r1 = Long.reverseBytes(l1); hash = mix32((int) r0, hash); hash = mix32((int) (r0 >>> 32), hash); hash = mix32((int) (r1), hash); hash = mix32((int) (r1 >>> 32), hash); return fmix32(Long.BYTES * 2, hash); }
private static long hash2(byte[] bytes) { final int PRIME = 1366661; return Murmur3.hash64(bytes, 0, bytes.length, PRIME); } }
/** * Murmur3 32-bit variant. * * @param data - input byte array * @param length - length of array * @return - hashcode */ public static int hash32(byte[] data, int length) { return hash32(data, 0, length, DEFAULT_SEED); }
public static long hash64(short data) { long hash = DEFAULT_SEED; long k1 = 0; k1 ^= ((long) data & 0xff) << 8; k1 ^= ((long)((data & 0xFF00) >> 8) & 0xff); k1 *= C1; k1 = Long.rotateLeft(k1, R1); k1 *= C2; hash ^= k1; // finalization hash ^= Short.BYTES; hash = fmix64(hash); return hash; }
/** * Murmur3 128-bit variant. * * @param data - input byte array * @return - hashcode (2 longs) */ public static long[] hash128(byte[] data) { return hash128(data, data.length, DEFAULT_SEED); }
private static long hash1(byte[] bytes) { final int PRIME = 104729; // Same as hash64's default seed. return Murmur3.hash64(bytes, 0, bytes.length, PRIME); }
/** * Murmur3 32-bit variant. * * @param data - input byte array * @param length - length of array * @param seed - seed. (default 0) * @return - hashcode */ public static int hash32(byte[] data, int length, int seed) { return hash32(data, 0, length, seed); }
public static long hash64(long data) { long hash = DEFAULT_SEED; long k = Long.reverseBytes(data); int length = Long.BYTES; // mix functions k *= C1; k = Long.rotateLeft(k, R1); k *= C2; hash ^= k; hash = Long.rotateLeft(hash, R2) * M + N1; // finalization hash ^= length; hash = fmix64(hash); return hash; }
private static long hash2(byte[] bytes) { final int PRIME = 1366661; return Murmur3.hash64(bytes, 0, bytes.length, PRIME); } }
public static int hash32(long l0, long l1) { return hash32(l0, l1, DEFAULT_SEED); }
hash = fmix64(hash);
public static long hash64(byte[] data, int offset, int length) { return hash64(data, offset, length, DEFAULT_SEED); }
public static int calculateLongHashCode(long key) { return Murmur3.hash32(key); }