Merge pull request #75 from apache/bloomfilter

(feat) BloomFilter Sketch

Author: freakyzoidberg

README.md

@@ -59,7 +59,7 @@ If you are interested in making contributions to this site please see our [Commu
 |  | ReserviorItemsSketch<T> | ❌ |
 | 	  | VarOptItemsSketch<T>    | ❌ |
 | Membership | | |
-| | BloomFilterSketch | ❌ |
+| | BloomFilter | 🚧 |
 
 
 ## Specialty Sketches

filters/bit_array.go

@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package filters
+
+import "math/bits"
+
+// getBit returns the value of the bit at the specified index.
+func getBit(array []uint64, index uint64) bool {
+	longIdx := index >> 6  // divide by 64
+	bitIdx := index & 0x3F // mod 64
+	return (array[longIdx] & (1 << bitIdx)) != 0
+}
+
+// setBit sets the bit at the specified index to 1.
+func setBit(array []uint64, index uint64) {
+	longIdx := index >> 6
+	bitIdx := index & 0x3F
+	array[longIdx] |= (1 << bitIdx)
+}
+
+// clearBit sets the bit at the specified index to 0.
+func clearBit(array []uint64, index uint64) {
+	longIdx := index >> 6
+	bitIdx := index & 0x3F
+	array[longIdx] &^= (1 << bitIdx)
+}
+
+// assignBit sets the bit at the specified index to the given value.
+func assignBit(array []uint64, index uint64, value bool) {
+	if value {
+		setBit(array, index)
+	} else {
+		clearBit(array, index)
+	}
+}
+
+// getAndSetBit gets the current bit value and sets it to 1 in a single operation.
+// Returns true if the bit was already set, false if it was newly set.
+func getAndSetBit(array []uint64, index uint64) bool {
+	longIdx := index >> 6
+	bitIdx := index & 0x3F
+	mask := uint64(1) << bitIdx
+	wasSet := (array[longIdx] & mask) != 0
+	array[longIdx] |= mask
+	return wasSet
+}
+
+// countBitsSet counts the number of bits set to 1 in the array.
+func countBitsSet(array []uint64) uint64 {
+	count := uint64(0)
+	for _, val := range array {
+		count += uint64(bits.OnesCount64(val))
+	}
+	return count
+}
+
+// unionWith performs a bitwise OR operation between target and source arrays.
+// The result is stored in target. Returns the number of bits set in the result.
+func unionWith(target, source []uint64) uint64 {
+	count := uint64(0)
+	for i := range target {
+		target[i] |= source[i]
+		count += uint64(bits.OnesCount64(target[i]))
+	}
+	return count
+}
+
+// intersect performs a bitwise AND operation between target and source arrays.
+// The result is stored in target. Returns the number of bits set in the result.
+func intersect(target, source []uint64) uint64 {
+	count := uint64(0)
+	for i := range target {
+		target[i] &= source[i]
+		count += uint64(bits.OnesCount64(target[i]))
+	}
+	return count
+}
+
+// invert performs a bitwise NOT operation on the array.
+// Returns the number of bits set in the result.
+func invert(array []uint64) uint64 {
+	count := uint64(0)
+	for i := range array {
+		array[i] = ^array[i]
+		count += uint64(bits.OnesCount64(array[i]))
+	}
+	return count
+}

filters/bit_array_test.go

@@ -0,0 +1,186 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package filters
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBitArrayBasicOperations(t *testing.T) {
+	// Create array with 128 bits (2 longs)
+	array := make([]uint64, 2)
+
+	// Test initial state - all bits should be 0
+	assert.Equal(t, uint64(0), countBitsSet(array))
+	assert.False(t, getBit(array, 0))
+	assert.False(t, getBit(array, 63))
+	assert.False(t, getBit(array, 64))
+	assert.False(t, getBit(array, 127))
+
+	// Test setBit
+	setBit(array, 5)
+	assert.True(t, getBit(array, 5))
+	assert.Equal(t, uint64(1), countBitsSet(array))
+
+	setBit(array, 65)
+	assert.True(t, getBit(array, 65))
+	assert.Equal(t, uint64(2), countBitsSet(array))
+
+	// Test clearBit
+	clearBit(array, 5)
+	assert.False(t, getBit(array, 5))
+	assert.Equal(t, uint64(1), countBitsSet(array))
+
+	// Test assignBit
+	assignBit(array, 10, true)
+	assert.True(t, getBit(array, 10))
+	assert.Equal(t, uint64(2), countBitsSet(array))
+
+	assignBit(array, 10, false)
+	assert.False(t, getBit(array, 10))
+	assert.Equal(t, uint64(1), countBitsSet(array))
+
+	// Test getAndSetBit
+	wasSet := getAndSetBit(array, 20)
+	assert.False(t, wasSet) // Was not set
+	assert.True(t, getBit(array, 20))
+	assert.Equal(t, uint64(2), countBitsSet(array))
+
+	wasSet = getAndSetBit(array, 20)
+	assert.True(t, wasSet) // Was already set
+	assert.True(t, getBit(array, 20))
+	assert.Equal(t, uint64(2), countBitsSet(array))
+}
+
+func TestBitArrayInversion(t *testing.T) {
+	// Create array with 128 bits
+	array := make([]uint64, 2)
+
+	// Set some bits
+	setBit(array, 0)
+	setBit(array, 10)
+	setBit(array, 63)
+	setBit(array, 100)
+	assert.Equal(t, uint64(4), countBitsSet(array))
+
+	// Invert
+	count := invert(array)
+	assert.Equal(t, uint64(128-4), count)
+	assert.Equal(t, uint64(128-4), countBitsSet(array))
+
+	// Previously set bits should now be clear
+	assert.False(t, getBit(array, 0))
+	assert.False(t, getBit(array, 10))
+	assert.False(t, getBit(array, 63))
+	assert.False(t, getBit(array, 100))
+
+	// Previously clear bits should now be set
+	assert.True(t, getBit(array, 1))
+	assert.True(t, getBit(array, 50))
+	assert.True(t, getBit(array, 64))
+	assert.True(t, getBit(array, 127))
+}
+
+func TestBitArrayUnion(t *testing.T) {
+	// Create two arrays with 192 bits (3 longs)
+	array1 := make([]uint64, 3)
+	array2 := make([]uint64, 3)
+	array3 := make([]uint64, 3)
+
+	// Array1: bits 0-9
+	for i := uint64(0); i < 10; i++ {
+		setBit(array1, i)
+	}
+
+	// Array2: bits 5-14
+	for i := uint64(5); i < 15; i++ {
+		setBit(array2, i)
+	}
+
+	// Array3: even bits 0-18
+	for i := uint64(0); i < 19; i += 2 {
+		setBit(array3, i)
+	}
+
+	// Union of array2 and array3
+	count := unionWith(array2, array3)
+	// Array2 had bits 5-14 (10 bits)
+	// Array3 had even bits 0-18 (10 bits: 0,2,4,6,8,10,12,14,16,18)
+	// Union should have: 5,6,7,8,9,10,11,12,13,14 + 0,2,4,16,18 = 15 bits
+	assert.Equal(t, uint64(15), count)
+	assert.Equal(t, uint64(15), countBitsSet(array2))
+}
+
+func TestBitArrayIntersection(t *testing.T) {
+	// Create two arrays
+	array1 := make([]uint64, 3)
+	array2 := make([]uint64, 3)
+
+	// Array1: bits 0-9
+	for i := uint64(0); i < 10; i++ {
+		setBit(array1, i)
+	}
+
+	// Array2: bits 5-14
+	for i := uint64(5); i < 15; i++ {
+		setBit(array2, i)
+	}
+
+	// Intersection
+	count := intersect(array1, array2)
+	// Overlap is bits 5-9 = 5 bits
+	assert.Equal(t, uint64(5), count)
+	assert.Equal(t, uint64(5), countBitsSet(array1))
+
+	// Verify the overlap bits
+	for i := uint64(5); i < 10; i++ {
+		assert.True(t, getBit(array1, i))
+	}
+	// Verify non-overlap bits are cleared
+	for i := uint64(0); i < 5; i++ {
+		assert.False(t, getBit(array1, i))
+	}
+}
+
+func TestBitArrayBoundaries(t *testing.T) {
+	// Test bit operations at long boundaries
+	array := make([]uint64, 3) // 192 bits
+
+	// Test at boundary of first and second long (bit 63-64)
+	setBit(array, 63)
+	setBit(array, 64)
+	assert.True(t, getBit(array, 63))
+	assert.True(t, getBit(array, 64))
+
+	clearBit(array, 63)
+	assert.False(t, getBit(array, 63))
+	assert.True(t, getBit(array, 64))
+
+	// Test at boundary of second and third long (bit 127-128)
+	setBit(array, 127)
+	setBit(array, 128)
+	assert.True(t, getBit(array, 127))
+	assert.True(t, getBit(array, 128))
+
+	// Test last bit
+	setBit(array, 191)
+	assert.True(t, getBit(array, 191))
+	assert.Equal(t, uint64(4), countBitsSet(array))
+}