move bitmap to bitarray package

Author: Theodus

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

@@ -1,6 +1,32 @@
+/*
+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 bitmap contains bitmaps of length 32 and 64 for tracking bool
 // values without the need for arrays or hashing.
-package bitmap
+package bitarray
 
 // Bitmap32 tracks 32 bool values within a uint32
 type Bitmap32 uint32
@@ -20,7 +46,7 @@ func (b Bitmap32) HasBit(pos uint) bool {
 	return (b & (1 << pos)) != 0
 }
 
-// PopCount returns the ammount of bits set to 1 in the Bitmap32
+// PopCount returns the amount 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
@@ -49,7 +75,7 @@ func (b Bitmap64) HasBit(pos uint) bool {
 	return (b & (1 << pos)) != 0
 }
 
-// PopCount returns the ammount of bits set to 1 in the Bitmap64
+// PopCount returns the amount 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_test.go

@@ -0,0 +1,105 @@
+/*
+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
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBitmap32_PopCount(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 TestBitmap64_PopCount(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 TestBitmap32_SetBit(t *testing.T) {
+	m := Bitmap32(0)
+	assert.Equal(t, Bitmap32(0x4), m.SetBit(2))
+}
+
+func TestBitmap32_ClearBit(t *testing.T) {
+	m := Bitmap32(0x4)
+	assert.Equal(t, Bitmap32(0), m.ClearBit(2))
+}
+
+func TestBitmap32_HasBit(t *testing.T) {
+	m := Bitmap32(0x55555555)
+	assert.Equal(t, true, m.HasBit(2))
+}
+
+func TestBitmap64_SetBit(t *testing.T) {
+	m := Bitmap64(0)
+	assert.Equal(t, Bitmap64(0x4), m.SetBit(2))
+}
+
+func TestBitmap64_ClearBit(t *testing.T) {
+	m := Bitmap64(0x4)
+	assert.Equal(t, Bitmap64(0), m.ClearBit(2))
+}
+
+func TestBitmap64_HasBit(t *testing.T) {
+	m := Bitmap64(0x55555555)
+	assert.Equal(t, true, m.HasBit(2))
+}
+
+func BenchmarkBitmap32_PopCount(b *testing.B) {
+	m := Bitmap32(0x33333333)
+	b.ResetTimer()
+	for i := b.N; i > 0; i-- {
+		m.PopCount()
+	}
+}
+
+func BenchmarkBitmap64_PopCount(b *testing.B) {
+	m := Bitmap64(0x3333333333333333)
+	b.ResetTimer()
+	for i := b.N; i > 0; i-- {
+		m.PopCount()
+	}
+}