digest-murmurhash 0.2.3 → 0.3.0

data/ext/digest/murmurhash/murmurhash_aligned2.h

@@ -0,0 +1,13 @@
+#ifndef MURMURHASH_ALIGNED2_INCLUDED
+#  define MURMURHASH_ALIGNED2_INCLUDED
+
+#include "murmurhash.h"
+
+VALUE murmur_aligned2_finish(VALUE self);
+VALUE murmur_aligned2_to_i(VALUE self);
+VALUE murmur_aligned2_s_digest(int argc, VALUE *argv, VALUE klass);
+VALUE murmur_aligned2_s_hexdigest(int argc, VALUE *argv, VALUE klass);
+VALUE murmur_aligned2_s_rawdigest(int argc, VALUE *argv, VALUE klass);
+
+#endif /* ifndef MURMURHASH_ALIGNED2_INCLUDED */
+

data/ext/digest/murmurhash/murmurhash_neutral2.c

@@ -0,0 +1,87 @@
+/*
+ * MurmurHashNeutral2 (C) Austin Appleby
+ */
+
+#include "murmurhash_neutral2.h"
+
+uint32_t
+murmur_hash_process_neutral2(const char * key, uint32_t len, uint32_t seed)
+{
+	const uint32_t m = 0x5bd1e995;
+	const int r = 24;
+
+	uint32_t h = seed ^ len;
+
+	const unsigned char * data = (const unsigned char *)key;
+
+	while(len >= 4) {
+		uint32_t k;
+
+		k  = data[0];
+		k |= data[1] << 8;
+		k |= data[2] << 16;
+		k |= data[3] << 24;
+
+		k *= m; 
+		k ^= k >> r; 
+		k *= m;
+
+		h *= m;
+		h ^= k;
+
+		data += 4;
+		len -= 4;
+	}
+
+	switch(len) {
+	case 3: h ^= data[2] << 16;
+	case 2: h ^= data[1] << 8;
+	case 1: h ^= data[0];
+			h *= m;
+	};
+
+	h ^= h >> 13;
+	h *= m;
+	h ^= h >> 15;
+
+	return h;
+}
+
+VALUE
+murmur_neutral2_finish(VALUE self)
+{
+	uint8_t digest[4];
+	uint32_t h;
+
+	h = _murmur_finish32(self, murmur_hash_process_neutral2);
+	ASSINE_BY_ENDIAN_32(digest, h);
+	return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur_neutral2_to_i(VALUE self)
+{
+	return ULL2NUM(_murmur_finish32(self, murmur_hash_process_neutral2));
+}
+
+VALUE
+murmur_neutral2_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+	uint8_t digest[4];
+	uint64_t h;
+	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process_neutral2);
+	ASSINE_BY_ENDIAN_32(digest, h);
+	return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur_neutral2_s_hexdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return hexencode_str_new(murmur_neutral2_s_digest(argc, argv, klass));
+}
+
+VALUE
+murmur_neutral2_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process_neutral2));
+}

data/ext/digest/murmurhash/murmurhash_neutral2.h

@@ -0,0 +1,13 @@
+#ifndef MURMURHASH_NEUTRAL2_INCLUDED
+#  define MURMURHASH_NEUTRAL2_INCLUDED
+
+#include "murmurhash.h"
+
+VALUE murmur_neutral2_finish(VALUE self);
+VALUE murmur_neutral2_to_i(VALUE self);
+VALUE murmur_neutral2_s_digest(int argc, VALUE *argv, VALUE klass);
+VALUE murmur_neutral2_s_hexdigest(int argc, VALUE *argv, VALUE klass);
+VALUE murmur_neutral2_s_rawdigest(int argc, VALUE *argv, VALUE klass);
+
+#endif /* ifndef MURMURHASH_NEUTRAL2_INCLUDED */
+

data/lib/digest/murmurhash/version.rb

@@ -1,5 +1,5 @@
 module Digest
   class MurmurHash
-    VERSION = "0.2.3"
+    VERSION = "0.3.0"
   end
 end

data/spec/bench.rb

@@ -7,18 +7,13 @@ require 'digest/stringbuffer'
 require 'digest/murmurhash'
 require 'benchmark'
 
-class Prime37 < Digest::StringBuffer
-  def initialize
-    @prime = 37
-  end
-
-  def finish
-    result = 0
-    buffer.unpack("C*").each do |c|
-      result += (c * @prime)
-    end
-    [result & 0xffffffff].pack("N")
-  end
+@rands = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".split(//)
+def rand_str length
+  rand = "";
+  length.times {
+    rand << @rands.sample
+  }
+  rand
 end
 
 class Integer
@@ -27,12 +22,12 @@ class Integer
   end
 end
 
-def murmur_hash str
+def murmur_hash str, seed
   data = str.dup.unpack("C*")
   m = 0x5bd1e995
   r = 16
   length = str.bytesize
-  h = (length * m).to_32
+  h = (seed ^ (length * m).to_32).to_32
 
   while 4 <= length
     d = data.shift(4).pack("C*").unpack("I")[0]
@@ -62,34 +57,29 @@ def murmur_hash str
   h
 end
 
-@rands = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".split(//)
-def rand_str
-  rand = "";
-  20.times {
-    rand << @rands[rand(62)]
-  }
-  rand
-end
-
 n = 100000
 times_enum = n.times
 
 a = Array.new(n, 0)
 n.times do |i|
-  a[i] = rand_str
+  a[i] = rand_str 20
 end
-
+seed = rand(2**32)
+seed_str32 = [seed].pack("L")
+seed_str64 = [seed].pack("Q")
 c = Struct.new "Cases",
                :name,
                :func
 cases = [
-  c.new("pureRuby", proc{|x| murmur_hash x }),
-  c.new("Prime37", proc{|x| Prime37.digest x }),
-  c.new("MurmurHash1", proc{|x| Digest::MurmurHash1.rawdigest x }),
-  c.new("MurmurHash2", proc{|x| Digest::MurmurHash2.rawdigest x }),
-  c.new("MurmurHash2A", proc{|x| Digest::MurmurHash2A.rawdigest x }),
+  c.new("pureRuby", proc{|x| murmur_hash x, seed }),
+  c.new("MurmurHash1", proc{|x| Digest::MurmurHash1.rawdigest x, seed_str32 }),
+  c.new("MurmurHash2", proc{|x| Digest::MurmurHash2.rawdigest x, seed_str32 }),
+  c.new("MurmurHash2A", proc{|x| Digest::MurmurHash2A.rawdigest x, seed_str32 }),
+  c.new("MurmurHash64A", proc{|x| Digest::MurmurHash64A.rawdigest x, seed_str64 }),
+  c.new("MurmurHash64B", proc{|x| Digest::MurmurHash64B.rawdigest x, seed_str64 }),
+  c.new("MurmurHashNeutral2", proc{|x| Digest::MurmurHashNeutral2.rawdigest x, seed_str32 }),
+  c.new("MurmurHashAligned2", proc{|x| Digest::MurmurHashAligned2.rawdigest x, seed_str32 }),
 ]
-
 reals = {}
 confrict = {}
 confricts = {}

data/spec/digest_spec.rb

@@ -1,48 +1,68 @@
 require 'spec_helper'
 
-describe "Digest::MurmurHash1 and 2" do
-  let :all do
-    [MurmurHash1, MurmurHash2, MurmurHash2A]
+describe Digest::MurmurHash do
+  it "seed" do
+    all.each do |c|
+      m = c.new
+      expect(c::DEFAULT_SEED == m.seed).to be true
+    end
   end
 
-  it "initialize" do
-    expect(MurmurHash1.new).to be_a_kind_of(Digest::StringBuffer)
-    expect(MurmurHash2.new).to be_a_kind_of(Digest::StringBuffer)
-    expect(MurmurHash2A.new).to be_a_kind_of(Digest::StringBuffer)
+  it "seed=" do
+    all.each do |c|
+      m = c.new
+      m.update "murmurhash"
+      before_digest = m.hexdigest
+      m.seed = (c::DEFAULT_SEED.length == 4) ? seed32 : seed64
+      expect(c::DEFAULT_SEED != m.seed).to be true
+      expect(before_digest != m.hexdigest).to be true
+    end
   end
 
-  it "digest" do
-    expect(MurmurHash1.digest("a" * 1024)).to eq("\xa1\x52\x2e\x5f".force_encoding("ASCII-8BIT"))
-    expect(MurmurHash2.digest("a" * 1024)).to eq("\xd0\x0c\x31\x2f".force_encoding("ASCII-8BIT"))
-    expect(MurmurHash2A.digest("a" * 1024)).to eq("\xd5\x2d\xb1\x67".force_encoding("ASCII-8BIT"))
+  it "initialize" do
+    all.each do |c|
+      expect(c.new).to be_a_kind_of(Digest::StringBuffer)
+    end
   end
 
-  it "hexdigest" do
-    expect(MurmurHash1.hexdigest("a" * 1024)).to eq("a1522e5f")
-    expect(MurmurHash2.hexdigest("a" * 1024)).to eq("d00c312f")
-    expect(MurmurHash2A.hexdigest("a" * 1024)).to eq("d52db167")
+  it "digest and hexdigest" do
+    all.each do |c|
+      [:digest, :hexdigest].each do |method|
+        str = "a" * 1024
+        d = c.send(method, str)
+        d2 = c.send(method, str, (c::DEFAULT_SEED.length == 4) ? seed32 : seed64)
+        expect(d).to be_a_kind_of(String)
+        expect(d2).to be_a_kind_of(String)
+        expect(d.length).to be > 0
+        expect(d2.length).to be > 0
+        expect(d != d2).to be true
+      end
+    end
   end
 
   it "rawdigest" do
-    expect(MurmurHash1.rawdigest("a" * 1024)).to eq(0xa1522e5f)
-    expect(MurmurHash2.rawdigest("a" * 1024)).to eq(0xd00c312f)
-    expect(MurmurHash2A.rawdigest("a" * 1024)).to eq(0xd52db167)
+    all.each do |c|
+      str = "a" * 1024
+      d = c.rawdigest str
+      d2 = c.rawdigest str, (c::DEFAULT_SEED.length == 4) ? seed32 : seed64
+      expect(d).to be_a_kind_of(Integer)
+      expect(d2).to be_a_kind_of(Integer)
+      expect(d).to be > 0
+      expect(d2).to be > 0
+      expect(d != d2).to be true
+    end
   end
 
-  it "update and reset and hexdigest" do
-    {
-      MurmurHash1 => "c709abd5",
-      MurmurHash2 => "33f67c7e",
-      MurmurHash2A => "df25554b",
-    }.each do |c, should|
+  it "update and reset and hexdigest(32bit)" do
+    all.each do |c|
       murmur = c.new
       murmur.update("m").update("u").update("r")
       murmur << "m" << "u" << "r"
       murmur << "hash"
-      expect(murmur.hexdigest).to eq(should);
-      expect(murmur.hexdigest).to eq(should);
-      expect(murmur.hexdigest!).to eq(should);
-      expect(murmur.hexdigest).to eq("00000000");
+      hex = murmur.hexdigest
+      expect(murmur.hexdigest! == hex).to be true
+      reset_str = "0" * ((c::DEFAULT_SEED.length == 4) ? 8 : 16)
+      expect(murmur.hexdigest).to eq(reset_str)
     end
   end
 
@@ -69,14 +89,14 @@ describe "Digest::MurmurHash1 and 2" do
   end
 
   it "length" do
-    expect(MurmurHash1.new.length).to eq(4);
-    expect(MurmurHash2.new.length).to eq(4);
-    expect(MurmurHash2A.new.length).to eq(4);
+    all.each do |c|
+      expect(c.new.length == c::DEFAULT_SEED.length).to be true
+    end
   end
 
   it "to_i" do
-    expect(MurmurHash1.new.update("murmurhash").to_i).to eq(0xc709abd5);
-    expect(MurmurHash2.new.update("murmurhash").to_i).to eq(0x33f67c7e);
-    expect(MurmurHash2A.new.update("murmurhash").to_i).to eq(0xdf25554b);
+    all.each do |c|
+      expect(c.new.update("murmurhash").to_i).to be_a_kind_of(Integer)
+    end
   end
 end

data/spec/exception_spec.rb

@@ -1,10 +1,6 @@
 require 'spec_helper'
 
 describe MurmurHash do
-  let :all do
-    [MurmurHash1, MurmurHash2, MurmurHash2A]
-  end
-
   it "update nil" do
     all.each do |c|
       murmur = c.new
@@ -17,4 +13,23 @@ describe MurmurHash do
       expect{ c.rawdigest }.to raise_error(ArgumentError)
     end
   end
+
+  it "seed digest" do
+    all.each do |c|
+      expect{ c.digest "", ""}.to raise_error(ArgumentError)
+      expect{ c.digest "", "\x00" }.to raise_error(ArgumentError)
+      seed = (c::DEFAULT_SEED.bytesize == 4) ? seed32 : seed64
+      expect{ c.digest "", seed }.to_not raise_error
+    end
+  end
+
+  it "seed instance" do
+    all.each do |c|
+      murmur = c.new
+      expect{ murmur.seed = "" }.to raise_error(ArgumentError)
+      expect{ murmur.seed = "\x00" }.to raise_error(ArgumentError)
+      seed = (c::DEFAULT_SEED.bytesize == 4) ? seed32 : seed64
+      expect{ murmur.seed = seed }.to_not raise_error
+    end
+  end
 end

data/spec/mem_spec.rb

@@ -2,16 +2,13 @@ require 'spec_helper'
 
 describe MurmurHash do
   it "gc safe" do
-    {
-      MurmurHash1 => "c709abd5",
-      MurmurHash2 => "33f67c7e",
-      MurmurHash2A => "df25554b",
-    }.each do |c, should|
+    all.each do |c|
       murmur = c.new
+      init = murmur.to_s
       GC.start
       murmur.update("murmur")
       GC.start
-      expect(murmur.update("hash").to_s).to eq(should);
+      expect(murmur.update("hash").to_s != init).to be true
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,2 +1,23 @@
 require 'digest/murmurhash'
 include Digest
+
+def all
+  [
+    MurmurHash1,
+    MurmurHash2,
+    MurmurHash2A,
+    MurmurHash64A,
+    MurmurHash64B,
+    MurmurHashNeutral2,
+    MurmurHashAligned2
+  ]
+end
+
+def seed32
+  (0..4).to_a.pack("C4")
+end
+
+def seed64
+  (0..8).to_a.pack("C8")
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: digest-murmurhash
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-25 00:00:00.000000000 Z
+date: 2014-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest-stringbuffer
@@ -72,15 +72,15 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 0.8.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.2
-description: Digest::MurmurHash1 is a class of use algorithm MurmurHash1(32-bit) desiged
+        version: 0.8.3
+description: Digest::MurmurHash is class collections of use algorithm MurmurHash desiged
   by Austin Appleby.
 email: co000ri@gmail.com
 executables: []
@@ -96,7 +96,7 @@ files:
 - Rakefile
 - digest-murmurhash.gemspec
 - ext/digest/murmurhash/extconf.rb
-- ext/digest/murmurhash/init.c
+- ext/digest/murmurhash/murmurhash.c
 - ext/digest/murmurhash/murmurhash.h
 - ext/digest/murmurhash/murmurhash1.c
 - ext/digest/murmurhash/murmurhash1.h
@@ -104,6 +104,14 @@ files:
 - ext/digest/murmurhash/murmurhash2.h
 - ext/digest/murmurhash/murmurhash2a.c
 - ext/digest/murmurhash/murmurhash2a.h
+- ext/digest/murmurhash/murmurhash64a.c
+- ext/digest/murmurhash/murmurhash64a.h
+- ext/digest/murmurhash/murmurhash64b.c
+- ext/digest/murmurhash/murmurhash64b.h
+- ext/digest/murmurhash/murmurhash_aligned2.c
+- ext/digest/murmurhash/murmurhash_aligned2.h
+- ext/digest/murmurhash/murmurhash_neutral2.c
+- ext/digest/murmurhash/murmurhash_neutral2.h
 - lib/digest/murmurhash.rb
 - lib/digest/murmurhash/version.rb
 - spec/bench.rb
@@ -134,7 +142,7 @@ rubyforge_project:
 rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
-summary: Digest::MurmurHash1 is a class of use algorithm MurmurHash1(32-bit) desiged
+summary: Digest::MurmurHash is class collections of use algorithm MurmurHash desiged
   by Austin Appleby.
 test_files:
 - spec/bench.rb