Basic bitmap implementation

Author: cyradin

.github/workflows/test.yaml

@@ -0,0 +1,18 @@
+name: Go package
+
+on: [push]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: 1.19
+
+      - name: Test
+        run: go test ./...

README.md

@@ -0,0 +1,36 @@
+# Bitmap
+
+Yet another bitmap implementation written in go.
+
+## Installation
+
+```
+$ go get -v github.com/f1monkey/bitmap
+```
+
+## Usage
+
+```go
+func main() {
+    var b bitmap.Bitmap
+
+    b.IsEmpty() // true
+
+    b.Set(0)
+    b.Has(0) // true
+    b.Remove(0)
+    b.Has(0) // false
+
+    b.Xor(1000)
+    b.Has(1000) // true
+    b.Xor(1000)
+    b.Has(1000) // false
+
+    b2 := b.Clone() // copy of "b"
+
+    b2.Range(func(n uint32) bool {
+        fmt.PrintLn(n)
+        return true
+    })
+}
+```

bitmap.go

@@ -0,0 +1,104 @@
+package bitmap
+
+import "math/bits"
+
+type Bitmap []uint64
+
+// Set set n-th bit to 1
+func (b *Bitmap) Set(n uint32) {
+	block, bit := n>>6, n%64
+	b.grow(block)
+	(*b)[block] |= (1 << bit)
+}
+
+// Remove set n-th bit to 0
+func (b *Bitmap) Remove(n uint32) {
+	block, bit := n>>6, n%64
+	if uint32(len(*b)) <= block {
+		return
+	}
+	(*b)[block] &= (0 << bit)
+}
+
+// Xor invert n-th bit
+func (b *Bitmap) Xor(n uint32) {
+	block, val := n>>6, n%64
+	b.grow(block)
+	(*b)[block] ^= (1 << val)
+}
+
+// IsEmpty check if the bitmap has any bit set to 1
+func (b *Bitmap) 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 *Bitmap) Has(n uint32) bool {
+	block, val := n>>6, n%64
+	if uint32(len(*b)) <= block {
+		return false
+	}
+
+	return (*b)[block]&(1<<val) > 0
+}
+
+// CountDiff count different bits in two bitmaps
+func (b *Bitmap) CountDiff(b2 Bitmap) 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.OnesCount64((*b)[i])
+			continue
+		}
+		if len(*b) <= i {
+			diff += bits.OnesCount64((b2)[i])
+			continue
+		}
+
+		diff += bits.OnesCount64((*b)[i] ^ b2[i])
+	}
+
+	return diff
+}
+
+// Clone create a copy of the bitmap
+func (b *Bitmap) Clone() Bitmap {
+	clone := make(Bitmap, 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 *Bitmap) Range(f func(n uint32) bool) {
+	for i, block := range *b {
+		for block != 0 {
+			tz := bits.TrailingZeros64(block)
+			bitIndex := uint32(i*64 + tz)
+
+			if !f(bitIndex) {
+				return
+			}
+
+			block &= block - 1
+		}
+	}
+}
+
+func (b *Bitmap) grow(length uint32) {
+	if length+1 > uint32(len(*b)) {
+		*b = append(*b, make(Bitmap, length+1-uint32(len(*b)))...)
+	}
+}

bitmap_test.go

@@ -0,0 +1,172 @@
+package bitmap
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Benchmark_Bitmap_Set(b *testing.B) {
+	var bm Bitmap
+	for i := 0; i < b.N; i++ {
+		bm.Set(1)
+	}
+}
+
+func Test_Bitmap_Set(t *testing.T) {
+	t.Run("must set the specified bit", func(t *testing.T) {
+		t.Run("0", func(t *testing.T) {
+			var b Bitmap
+			b.Set(0)
+			assert.Equal(t, Bitmap{1}, b)
+		})
+		t.Run("2", func(t *testing.T) {
+			var b Bitmap
+			b.Set(2)
+			assert.Equal(t, Bitmap{4}, b)
+		})
+		t.Run("0,2", func(t *testing.T) {
+			var b Bitmap
+			b.Set(0)
+			b.Set(2)
+			assert.Equal(t, Bitmap{5}, b)
+		})
+
+		t.Run("63", func(t *testing.T) {
+			var b Bitmap
+			b.Set(63)
+			assert.Equal(t, Bitmap{9223372036854775808}, b)
+		})
+
+		t.Run("64", func(t *testing.T) {
+			var b Bitmap
+			b.Set(64)
+			assert.Equal(t, Bitmap{0, 1}, b)
+		})
+	})
+	t.Run("must do nothing if the specified bit is already == 1", func(t *testing.T) {
+		var b Bitmap
+		b.Set(0)
+		b.Set(0)
+		assert.Equal(t, Bitmap{1}, b)
+	})
+}
+
+func Test_Bitmap_Remove(t *testing.T) {
+	var b Bitmap
+
+	b.Remove(0)
+	assert.Nil(t, b)
+
+	b.Set(0)
+	b.Set(100)
+	b.Remove(100)
+	assert.Equal(t, Bitmap{1, 0}, b)
+}
+
+func Benchmark_Bitmap_Xor(b *testing.B) {
+	var bm Bitmap
+	for i := 0; i < b.N; i++ {
+		bm.Xor(1)
+	}
+}
+
+func Test_Bitmap_Xor(t *testing.T) {
+	t.Run("must invert the specified bit", func(t *testing.T) {
+		var b Bitmap
+		b.Xor(0)
+		assert.Equal(t, Bitmap{1}, b)
+		b.Xor(0)
+		assert.Equal(t, Bitmap{0}, b)
+	})
+}
+
+func Test_Bitmap_IsEmpty(t *testing.T) {
+	t.Run("must return true if it's empty", func(t *testing.T) {
+		var b Bitmap
+		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 Bitmap
+		b.Set(1)
+		assert.False(t, b.IsEmpty())
+	})
+}
+
+func Test_Bitmap_Has(t *testing.T) {
+	var b Bitmap
+	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_Bitmap_CountDiff(b *testing.B) {
+	var b1, b2 Bitmap
+	b1.Set(1)
+	b1.Set(2)
+	b2.Set(31)
+	for i := 0; i < b.N; i++ {
+		b1.CountDiff(b2)
+	}
+}
+
+func Test_Bitmap_CountDiff(t *testing.T) {
+	t.Run("must return 0 if bitmaps are equal", func(t *testing.T) {
+		var b1, b2 Bitmap
+		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 Bitmap
+		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_Bitmap_Clone(t *testing.T) {
+	var b1 Bitmap
+	b1.Set(0)
+	b2 := b1.Clone()
+
+	assert.Equal(t, b1, b2)
+
+	b2.Set(2)
+	assert.Equal(t, Bitmap{5}, b2)
+	assert.Equal(t, Bitmap{1}, b1)
+}
+
+func Test_Bitmap_Range(t *testing.T) {
+	var b1 Bitmap
+	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
+	})
+
+	require.Equal(t, []uint32{0, 1, 2, 1000}, items)
+}

go.mod

@@ -0,0 +1,11 @@
+module github.com/f1monkey/bitmap
+
+go 1.19
+
+require github.com/stretchr/testify v1.8.4
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,10 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=