Revert "bitmap"

Author: Theodus

.gitignore

@@ -1,3 +1,2 @@
 *.out
-*.test
-.idea
+*.test

README.md

@@ -21,9 +21,13 @@ Bitarray used to detect existence without having to resort to hashing with
 hashmaps.  Requires entities have a uint64 unique identifier.  Two
 implementations exist, regular and sparse.  Sparse saves a great deal of space
 but insertions are O(log n).  There are some useful functions on the BitArray
-interface to detect intersection between two bitarrays. This package also
-includes Bitmaps of length 32 and 64 that provide increased speed and O(1) on
-all operations.
+interface to detect intersection between two bitarrays.
+
+#### Bitmap
+
+an extremely quick way of representing bitarrays of length 32 or 64 within
+a uint32 and uint64 respectively. This method provides bit switching and
+popcount operations of O(1).
 
 #### Futures
 

bitarray/bitmap_test.go

@@ -1,30 +1,6 @@
-/*
-Copyright (c) 2016, Theodore Butler
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-package bitarray
+// Package bitmap contains bitmaps of length 32 and 64 for tracking bool
+// values without the need for arrays or hashing.
+package bitmap
 
 // Bitmap32 tracks 32 bool values within a uint32
 type Bitmap32 uint32
@@ -44,7 +20,7 @@ func (b Bitmap32) HasBit(pos uint) bool {
 	return (b & (1 << pos)) != 0
 }
 
-// PopCount returns the amount of bits set to 1 in the Bitmap32
+// PopCount returns the ammount of bits set to 1 in the Bitmap32
 func (b Bitmap32) PopCount() int {
 	// http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
 	b -= (b >> 1) & 0x55555555
@@ -73,7 +49,7 @@ func (b Bitmap64) HasBit(pos uint) bool {
 	return (b & (1 << pos)) != 0
 }
 
-// PopCount returns the amount of bits set to 1 in the Bitmap64
+// PopCount returns the ammount of bits set to 1 in the Bitmap64
 func (b Bitmap64) PopCount() int {
 	// http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
 	b -= (b >> 1) & 0x5555555555555555

bitarray/bitmap.go renamed to bitmap/bitmap.go

@@ -0,0 +1,64 @@
+package bitmap
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPopCount32(t *testing.T) {
+	b := []uint32{
+		uint32(0x55555555), // 0x55555555 = 01010101 01010101 01010101 01010101
+		uint32(0x33333333), // 0x33333333 = 00110011 00110011 00110011 00110011
+		uint32(0x0F0F0F0F), // 0x0F0F0F0F = 00001111 00001111 00001111 00001111
+		uint32(0x00FF00FF), // 0x00FF00FF = 00000000 11111111 00000000 11111111
+		uint32(0x0000FFFF), // 0x0000FFFF = 00000000 00000000 11111111 11111111
+	}
+	for _, x := range b {
+		assert.Equal(t, 16, Bitmap32(x).PopCount())
+	}
+}
+
+func TestPopCount64(t *testing.T) {
+	b := []uint64{
+		uint64(0x5555555555555555),
+		uint64(0x3333333333333333),
+		uint64(0x0F0F0F0F0F0F0F0F),
+		uint64(0x00FF00FF00FF00FF),
+		uint64(0x0000FFFF0000FFFF),
+	}
+	for _, x := range b {
+		assert.Equal(t, 32, Bitmap64(x).PopCount())
+	}
+}
+
+func TestSetBit(t *testing.T) {
+	m := Bitmap32(0)
+	assert.Equal(t, Bitmap32(0x4), m.SetBit(2))
+}
+
+func TestClearBit(t *testing.T) {
+	m := Bitmap32(0x4)
+	assert.Equal(t, Bitmap32(0), m.ClearBit(2))
+}
+
+func TestHasBit(t *testing.T) {
+	m := Bitmap32(0x55555555)
+	assert.Equal(t, true, m.HasBit(2))
+}
+
+func BenchmarkPopCount32(b *testing.B) {
+	m := Bitmap32(0x33333333)
+	b.ResetTimer()
+	for i := b.N; i > 0; i-- {
+		m.PopCount()
+	}
+}
+
+func BenchmarkPopCount64(b *testing.B) {
+	m := Bitmap64(0x3333333333333333)
+	b.ResetTimer()
+	for i := b.N; i > 0; i-- {
+		m.PopCount()
+	}
+}

bitmap/bitmap_test.go

@@ -32,37 +32,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // Jurgen J. Vinju
 package dtrie
 
-import "fmt"
-
 // Dtrie is a persistent hash trie that dynamically expands or shrinks
 // to provide efficient memory allocation.
 type Dtrie struct {
 	root   *node
 	hasher func(v interface{}) uint32
 }
 
-type entry struct {
-	hash  uint32
-	key   interface{}
-	value interface{}
-}
-
-func (e *entry) KeyHash() uint32 {
-	return e.hash
-}
-
-func (e *entry) Key() interface{} {
-	return e.key
-}
-
-func (e *entry) Value() interface{} {
-	return e.value
-}
-
-func (e *entry) String() string {
-	return fmt.Sprintf("%v:%v", e.key, e.value)
-}
-
 // New creates an empty DTrie with the given hashing function.
 // If nil is passed in, the default hashing function will be used.
 func New(hasher func(v interface{}) uint32) *Dtrie {
@@ -91,8 +67,8 @@ func (d *Dtrie) Get(key interface{}) Entry {
 
 // Insert adds an entry to the Dtrie, replacing the existing value if
 // the key already exists and returns the resulting Dtrie.
-func (d *Dtrie) Insert(key, value interface{}) *Dtrie {
-	root := insert(d.root, &entry{d.hasher(key), key, value})
+func (d *Dtrie) Insert(entry Entry) *Dtrie {
+	root := insert(d.root, entry)
 	return &Dtrie{root, d.hasher}
 }
 

trie/dtrie/dtrie.go

@@ -27,18 +27,54 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package dtrie
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+func TestPopCount(t *testing.T) {
+	b := []uint32{
+		uint32(0x55555555), // 0x55555555 = 01010101 01010101 01010101 01010101
+		uint32(0x33333333), // 0x33333333 = 00110011 00110011 00110011 00110011
+		uint32(0x0F0F0F0F), // 0x0F0F0F0F = 00001111 00001111 00001111 00001111
+		uint32(0x00FF00FF), // 0x00FF00FF = 00000000 11111111 00000000 11111111
+		uint32(0x0000FFFF), // 0x0000FFFF = 00000000 00000000 11111111 11111111
+	}
+	for _, x := range b {
+		assert.Equal(t, 16, popCount(x))
+	}
+}
+
 func TestDefaultHasher(t *testing.T) {
 	assert.Equal(t,
 		defaultHasher(map[int]string{11234: "foo"}),
 		defaultHasher(map[int]string{11234: "foo"}))
 	assert.NotEqual(t, defaultHasher("foo"), defaultHasher("bar"))
 }
 
+type testEntry struct {
+	hash  uint32
+	key   int
+	value int
+}
+
+func (e *testEntry) KeyHash() uint32 {
+	return e.hash
+}
+
+func (e *testEntry) Key() interface{} {
+	return e.key
+}
+
+func (e *testEntry) Value() interface{} {
+	return e.value
+}
+
+func (e *testEntry) String() string {
+	return fmt.Sprint(e.value)
+}
+
 func collisionHash(key interface{}) uint32 {
 	return uint32(0xffffffff) // for testing collisions
 }
@@ -51,7 +87,7 @@ func TestInsert(t *testing.T) {
 func insertTest(t *testing.T, hashfunc func(interface{}) uint32, count int) *node {
 	n := emptyNode(0, 32)
 	for i := 0; i < count; i++ {
-		n = insert(n, &entry{hashfunc(i), i, i})
+		n = insert(n, &testEntry{hashfunc(i), i, i})
 	}
 	return n
 }
@@ -94,7 +130,7 @@ func TestUpdate(t *testing.T) {
 func updateTest(t *testing.T, hashfunc func(interface{}) uint32, count int) {
 	n := insertTest(t, hashfunc, count)
 	for i := 0; i < count; i++ {
-		n = insert(n, &entry{hashfunc(i), i, -i})
+		n = insert(n, &testEntry{hashfunc(i), i, -i})
 	}
 }
 
@@ -138,7 +174,7 @@ func BenchmarkInsert(b *testing.B) {
 	n := emptyNode(0, 32)
 	b.ResetTimer()
 	for i := b.N; i > 0; i-- {
-		n = insert(n, &entry{defaultHasher(i), i, i})
+		n = insert(n, &testEntry{defaultHasher(i), i, i})
 	}
 }
 
@@ -165,6 +201,6 @@ func BenchmarkUpdate(b *testing.B) {
 	n := insertTest(nil, defaultHasher, b.N)
 	b.ResetTimer()
 	for i := b.N; i > 0; i-- {
-		n = insert(n, &entry{defaultHasher(i), i, -i})
+		n = insert(n, &testEntry{defaultHasher(i), i, -i})
 	}
 }