add Bitap algorithm; misc. improvements

Author: joachimschmidt557

src/bitap.zig

@@ -0,0 +1,73 @@
+/// Bitap algorithm (exact matching variant)
+///
+/// See https://en.wikipedia.org/wiki/Bitap_algorithm for more details
+const std = @import("std");
+const assert = std.debug.assert;
+const testing = std.testing;
+
+const test_suites = @import("test_cases.zig").test_suites;
+const possibleValues = @import("common.zig").possibleValues;
+
+pub fn bitap(
+    comptime T: type,
+    comptime max_pattern_length: comptime_int,
+    text: T,
+    pattern: T,
+) ?usize {
+    assert(std.meta.trait.isIndexable(T));
+    const ElemType = std.meta.Elem(T);
+    assert(@typeInfo(ElemType) == .Int);
+    assert(pattern.len <= max_pattern_length);
+
+    const Int = @Type(std.builtin.TypeInfo{
+        .Int = .{
+            .is_signed = false,
+            .bits = max_pattern_length + 1,
+        },
+    });
+    const Log2Int = @Type(std.builtin.TypeInfo{
+        .Int = .{
+            .is_signed = false,
+            .bits = std.math.log2(max_pattern_length + 1),
+        },
+    });
+    const possible_values = possibleValues(ElemType);
+
+    if (pattern.len == 0) return 0;
+    const len = @intCast(Log2Int, pattern.len);
+
+    const one: Int = 1;
+
+    var R: Int = ~one;
+    var pattern_mask = [_]Int{std.math.maxInt(Int)} ** possible_values;
+
+    for (pattern) |x, i| {
+        pattern_mask[x] &= ~(one << @intCast(Log2Int, i));
+    }
+
+    for (text) |x, i| {
+        R |= pattern_mask[x];
+        R <<= 1;
+
+        if ((R & (one << len)) == 0) {
+            return if (i < len) 0 else i - len + 1;
+        }
+    }
+
+    return null;
+}
+
+test "bitap" {
+    inline for (&[_]comptime_int{ 31, 63, 127, 59, 67 }) |max_pattern_length| {
+        for (test_suites) |suite| {
+            for (suite.cases) |case| {
+                testing.expectEqual(case.expected, bitap(
+                    []const u8,
+                    max_pattern_length,
+                    case.text,
+                    suite.pattern,
+                ));
+            }
+        }
+    }
+}

src/boyer_moore.zig

@@ -4,6 +4,7 @@ const assert = std.debug.assert;
 const testing = std.testing;
 
 const test_suites = @import("test_cases.zig").test_suites;
+const possibleValues = @import("common.zig").possibleValues;
 
 pub fn StringFinder(comptime T: type) type {
     assert(std.meta.trait.isIndexable(T));
@@ -27,11 +28,6 @@ pub fn StringFinder(comptime T: type) type {
             .good_suffix = &[_]usize{},
         };
 
-        /// Returns the number of possible values for an integer type
-        fn possibleValues(comptime Type: type) usize {
-            return std.math.maxInt(Type) - std.math.minInt(Type) + 1;
-        }
-
         /// Returns the maximum length of suffixes of both strings
         fn longestCommonSuffix(a: T, b: T) usize {
             var i: usize = 0;

src/common.zig

@@ -0,0 +1,6 @@
+const std = @import("std");
+
+/// Returns the number of possible values for an integer type
+pub fn possibleValues(comptime Type: type) comptime_int {
+    return std.math.maxInt(Type) - std.math.minInt(Type) + 1;
+}

src/main.zig

@@ -1,5 +1,7 @@
+pub const bitap = @import("bitap.zig");
 pub const boyer_moore = @import("boyer_moore.zig");
 
 test "" {
+    _ = @import("bitap.zig");
     _ = @import("boyer_moore.zig");
 }