Merge pull request #3 from f1monkey/feature/bitmap-32

Add 32-bit bitmap version

Author: cyradin

README.md

@@ -39,5 +39,9 @@ func main() {
     b3.Set(100)
     b3.String() // "2|68719476736"
     b4, err := bitmap.FromString("2|68719476736")
+
+    // Bitmap32 is backed by []uint32 slice
+    // Everything else is all the same
+    var b32 bitmap.Bitmap32
 }
 ```

bitmap_32.go

@@ -0,0 +1,138 @@
+package bitmap
+
+import (
+	"math/bits"
+	"strconv"
+	"strings"
+)
+
+type Bitmap32 []uint32
+
+// Set set n-th bit to 1
+func (b *Bitmap32) Set(n uint32) {
+	block, bit := n>>5, n%32
+	b.grow(block)
+	(*b)[block] |= (1 << bit)
+}
+
+// Remove set n-th bit to 0
+func (b *Bitmap32) Remove(n uint32) {
+	block, bit := n>>5, n%32
+	if uint32(len(*b)) <= block {
+		return
+	}
+	(*b)[block] &= (0 << bit)
+}
+
+// Xor invert n-th bit
+func (b *Bitmap32) Xor(n uint32) {
+	block, val := n>>5, n%32
+	b.grow(block)
+	(*b)[block] ^= (1 << val)
+}
+
+// IsEmpty check if the bitmap has any bit set to 1
+func (b *Bitmap32) IsEmpty() bool {
+	for i := range *b {
+		if (*b)[i] > 0 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Has check if n-th bit is set to 1
+func (b *Bitmap32) Has(n uint32) bool {
+	block, val := n>>5, n%32
+	if uint32(len(*b)) <= block {
+		return false
+	}
+
+	return (*b)[block]&(1<<val) > 0
+}
+
+// CountDiff count different bits in two bitmaps
+func (b *Bitmap32) CountDiff(b2 Bitmap32) int {
+	diff := 0
+	max := len(*b)
+	if len(b2) > max {
+		max = len(b2)
+	}
+
+	for i := 0; i < max; i++ {
+		if len(b2) <= i {
+			diff += bits.OnesCount32((*b)[i])
+			continue
+		}
+		if len(*b) <= i {
+			diff += bits.OnesCount32((b2)[i])
+			continue
+		}
+
+		diff += bits.OnesCount32((*b)[i] ^ b2[i])
+	}
+
+	return diff
+}
+
+// Clone create a copy of the bitmap
+func (b *Bitmap32) Clone() Bitmap32 {
+	clone := make(Bitmap32, len(*b))
+	copy(clone, *b)
+
+	return clone
+}
+
+// Range call the passed callback with all bits set to 1.
+// If the callback returns false, the method exits
+func (b *Bitmap32) Range(f func(n uint32) bool) {
+	for i, block := range *b {
+		for block != 0 {
+			tz := bits.TrailingZeros32(block)
+			bitIndex := uint32(i*64 + tz)
+
+			if !f(bitIndex) {
+				return
+			}
+
+			block &= block - 1
+		}
+	}
+}
+
+func (b *Bitmap32) String() string {
+	var sb strings.Builder
+
+	for i := range *b {
+		sb.WriteString(strconv.FormatUint(uint64((*b)[i]), 10))
+		if i != len(*b)-1 {
+			sb.WriteString("|")
+		}
+	}
+
+	return sb.String()
+}
+
+func FromString32(str string) (Bitmap32, error) {
+	if str == "" {
+		return Bitmap32{}, nil
+	}
+
+	nums := strings.Split(str, "|")
+	result := make(Bitmap32, 0, len(nums))
+	for _, num := range nums {
+		v, err := strconv.ParseUint(num, 10, 32)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, uint32(v))
+	}
+	return result, nil
+}
+
+func (b *Bitmap32) grow(length uint32) {
+	if length+1 > uint32(len(*b)) {
+		*b = append(*b, make(Bitmap32, length+1-uint32(len(*b)))...)
+	}
+}

bitmap_32_test.go

@@ -0,0 +1,206 @@
+package bitmap
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Benchmark_Bitmap32_Set(b *testing.B) {
+	var bm Bitmap32
+	for i := 0; i < b.N; i++ {
+		bm.Set(1)
+	}
+}
+
+func Test_Bitmap32_Set(t *testing.T) {
+	t.Run("must set the specified bit", func(t *testing.T) {
+		t.Run("0", func(t *testing.T) {
+			var b Bitmap32
+			b.Set(0)
+			assert.Equal(t, Bitmap32{1}, b)
+		})
+		t.Run("2", func(t *testing.T) {
+			var b Bitmap32
+			b.Set(2)
+			assert.Equal(t, Bitmap32{4}, b)
+		})
+		t.Run("0,2", func(t *testing.T) {
+			var b Bitmap32
+			b.Set(0)
+			b.Set(2)
+			assert.Equal(t, Bitmap32{5}, b)
+		})
+
+		t.Run("31", func(t *testing.T) {
+			var b Bitmap32
+			b.Set(31)
+			assert.Equal(t, Bitmap32{2147483648}, b)
+		})
+
+		t.Run("32", func(t *testing.T) {
+			var b Bitmap32
+			b.Set(32)
+			assert.Equal(t, Bitmap32{0, 1}, b)
+		})
+	})
+	t.Run("must do nothing if the specified bit is already == 1", func(t *testing.T) {
+		var b Bitmap32
+		b.Set(0)
+		b.Set(0)
+		assert.Equal(t, Bitmap32{1}, b)
+	})
+}
+
+func Test_Bitmap32_Remove(t *testing.T) {
+	var b Bitmap32
+
+	b.Remove(0)
+	assert.Nil(t, b)
+
+	b.Set(0)
+	b.Set(100)
+	b.Remove(100)
+	assert.Equal(t, Bitmap32{1, 0, 0, 0}, b)
+}
+
+func Benchmark_Bitmap32_Xor(b *testing.B) {
+	var bm Bitmap32
+	for i := 0; i < b.N; i++ {
+		bm.Xor(1)
+	}
+}
+
+func Test_Bitmap32_Xor(t *testing.T) {
+	t.Run("must invert the specified bit", func(t *testing.T) {
+		var b Bitmap32
+		b.Xor(0)
+		assert.Equal(t, Bitmap32{1}, b)
+		b.Xor(0)
+		assert.Equal(t, Bitmap32{0}, b)
+	})
+}
+
+func Test_Bitmap32_IsEmpty(t *testing.T) {
+	t.Run("must return true if it's empty", func(t *testing.T) {
+		var b Bitmap32
+		assert.True(t, b.IsEmpty())
+		b.Xor(1)
+		b.Xor(1)
+		assert.True(t, b.IsEmpty())
+	})
+	t.Run("must return false if it is not empty", func(t *testing.T) {
+		var b Bitmap32
+		b.Set(1)
+		assert.False(t, b.IsEmpty())
+	})
+}
+
+func Test_Bitmap32_Has(t *testing.T) {
+	var b Bitmap32
+	assert.False(t, b.Has(0))
+	b.Xor(0)
+	assert.True(t, b.Has(0))
+	b.Xor(0)
+	assert.False(t, b.Has(0))
+}
+
+func Benchmark_Bitmap32_CountDiff(b *testing.B) {
+	var b1, b2 Bitmap32
+	b1.Set(1)
+	b1.Set(2)
+	b2.Set(31)
+	for i := 0; i < b.N; i++ {
+		b1.CountDiff(b2)
+	}
+}
+
+func Test_Bitmap32_CountDiff(t *testing.T) {
+	t.Run("must return 0 if bitmaps are equal", func(t *testing.T) {
+		var b1, b2 Bitmap32
+		b1.Set(1)
+		b2.Set(1)
+		assert.Equal(t, 0, b1.CountDiff(b2))
+	})
+
+	t.Run("must return correct count of different bits", func(t *testing.T) {
+		var b1, b2 Bitmap32
+		b1.Set(1)
+		b1.Set(2)
+		b1.Set(64)
+
+		b2.Set(31)
+		b2.Set(64)
+		b2.Set(650)
+
+		assert.Equal(t, 4, b1.CountDiff(b2))
+	})
+}
+
+func Test_Bitmap32_Clone(t *testing.T) {
+	var b1 Bitmap32
+	b1.Set(0)
+	b2 := b1.Clone()
+
+	assert.Equal(t, b1, b2)
+
+	b2.Set(2)
+	assert.Equal(t, Bitmap32{5}, b2)
+	assert.Equal(t, Bitmap32{1}, b1)
+}
+
+func Test_Bitmap32_Range(t *testing.T) {
+	var b1 Bitmap32
+	b1.Set(0)
+	b1.Set(1)
+	b1.Set(2)
+	b1.Set(1000)
+	b1.Set(10000)
+
+	var items []uint32
+	b1.Range(func(n uint32) bool {
+		items = append(items, n)
+		if n == 1000 {
+			return false
+		}
+
+		return true
+	})
+
+	assert.Equal(t, []uint32{0, 1, 2, 1992, 19984}, items)
+}
+
+func Benchmark_Bitmap32_String(b *testing.B) {
+	bm := Bitmap32{0, 5, 1000}
+	for i := 0; i < b.N; i++ {
+		_ = bm.String()
+	}
+}
+
+func Test_Bitmap32_String(t *testing.T) {
+	b := Bitmap32{}
+	assert.Equal(t, "", b.String())
+
+	b = Bitmap32{0, 5, 100}
+	assert.Equal(t, "0|5|100", b.String())
+}
+
+func Test_FromString32(t *testing.T) {
+	t.Run("must return error if unable to parse the string", func(t *testing.T) {
+		_, err := FromString32("qwe")
+		assert.Error(t, err)
+	})
+	t.Run("must parse the string correctly", func(t *testing.T) {
+		v, err := FromString32("")
+		assert.Nil(t, err)
+		assert.Equal(t, Bitmap32{}, v)
+
+		v, err = FromString32("0")
+		assert.Nil(t, err)
+		assert.Equal(t, Bitmap32{0}, v)
+
+		v, err = FromString32("0|5")
+		assert.Nil(t, err)
+		assert.Equal(t, Bitmap32{0, 5}, v)
+	})
+}