Merge branch 'dev'

Author: chrismichaelps

src/index.ts

@@ -1,10 +1,9 @@
 import type { NestedKeyOf } from './types'
 import { Effect } from 'effect'
-import { normalizeText } from './utils'
+import { addBitVectors, bitwiseAND, bitwiseNOT, bitwiseOR, bitwiseShiftLeft, bitwiseXOR, countSetBits, maskVP, normalizeText, setLeastSignificantBit } from './utils'
 
 export class QuantumMatcher<T> {
   private collection: T[]
-
   private pathCache = new Map<string, string[]>()
 
   constructor(
@@ -19,7 +18,7 @@ export class QuantumMatcher<T> {
   public findMatches(query: string): { item: T, score: number, matches: [number, number][] }[] {
     return Effect.try({
       try: () => {
-        const queryParts = query.split(' ').map(normalizeText) // Split and normalize query parts
+        const queryParts = query.split(' ').map(normalizeText)
         const results: { item: T, score: number, matches: [number, number][] }[] = []
 
         for (const item of this.collection) {
@@ -37,26 +36,30 @@ export class QuantumMatcher<T> {
               const m = queryPart.length
               const n = normalizedText.length
 
-              let VP = (1n << BigInt(m)) - 1n
-              let HN = 0n
-              let HP = 0n
+              let VP = this.createInitialVP(m)
+              let HN: number[] = []
+              let HP: number[] = []
               let score = 0
               let matches: [number, number][] = []
 
               for (let j = 0; j < n; j++) {
                 const char = normalizedText[j]
-                const EQ = queryMask.get(char) || 0n
+                const EQ = queryMask.get(char) || []
+
+                const X = bitwiseOR(EQ, HP)
+                const X_and_VP = bitwiseAND(X, VP)
+                const sum = addBitVectors(VP, X_and_VP)
+                const sum_xor_VP = bitwiseXOR(sum, VP)
+                const D0 = bitwiseOR(sum_xor_VP, X)
 
-                const X = EQ | HP
-                const D0 = ((VP + (X & VP)) ^ VP) | X
-                HN = VP & D0
-                HP = VP | ~(D0 | HN)
+                const HN_new = bitwiseAND(VP, D0)
+                const D0_or_HN = bitwiseOR(D0, HN_new)
+                const HP_new = bitwiseOR(VP, bitwiseNOT(D0_or_HN))
 
-                HP = (HP << 1n) | 1n
-                HN <<= 1n
+                HP = setLeastSignificantBit(bitwiseShiftLeft(HP_new))
+                HN = bitwiseShiftLeft(HN_new)
 
-                VP = HP | ~(D0 | HN)
-                VP &= (1n << BigInt(m)) - 1n
+                VP = maskVP(bitwiseOR(HP, bitwiseNOT(bitwiseOR(D0, HN))), m)
 
                 const currentScore = this.calculateMatchQuality(VP, m, j, normalizedText, queryPart)
                 if (currentScore > score) {
@@ -75,7 +78,6 @@ export class QuantumMatcher<T> {
             allMatches = allMatches.concat(bestMatchesForPart)
           }
 
-          // Only add results with a significant total score
           if (totalScore / queryParts.length > 0.5) {
             results.push({ item, score: totalScore / queryParts.length, matches: allMatches })
           }
@@ -93,129 +95,126 @@ export class QuantumMatcher<T> {
     if (obj == null)
       return undefined
 
-    // Cache path arrays
     let pathArray = this.pathCache.get(path)
     if (!pathArray) {
       pathArray = path.split('.')
       this.pathCache.set(path, pathArray)
     }
 
-    const length = pathArray.length
     let current = obj
-    for (let i = 0; i < length; i++) {
+    for (const part of pathArray) {
       if (current == null)
         return undefined
-      current = current[pathArray[i]]
+      current = current[part]
     }
     return current
   }
 
-  private createCharMask(text: string): Map<string, bigint> {
-    return Effect.try({
-      try: () => {
-        const maskMap = new Map<string, bigint>()
-        for (let i = 0; i < text.length; i++) {
-          const char = text[i]
-          maskMap.set(char, (maskMap.get(char) || 0n) | (1n << BigInt(i)))
-        }
-        return maskMap
-      },
-      catch: error => new Error(`[createCharMask]: Failed to create char mask: ${error}`),
-    }).pipe(Effect.runSync)
+  private createCharMask(text: string): Map<string, number[]> {
+    const maskMap = new Map<string, number[]>()
+    const chunkCount = Math.ceil(text.length / 32)
+
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i]
+      const chunkIndex = Math.floor(i / 32)
+      const bitPosition = i % 32
+
+      // eslint-disable-next-line unicorn/no-new-array
+      let chunks = maskMap.get(char) || new Array(chunkCount).fill(0)
+      if (chunks.length < chunkCount) {
+        chunks = [...chunks, ...Array.from({ length: chunkCount - chunks.length }).fill(0)]
+      }
+
+      chunks[chunkIndex] |= 1 << bitPosition
+      maskMap.set(char, chunks)
+    }
+
+    for (const [char, chunks] of maskMap) {
+      if (chunks.length < chunkCount) {
+        maskMap.set(char, [...chunks, ...Array.from<number>({ length: chunkCount - chunks.length }).fill(0)])
+      }
+    }
+
+    return maskMap
+  }
+
+  private createInitialVP(m: number): number[] {
+    const chunkCount = Math.ceil(m / 32)
+    // eslint-disable-next-line unicorn/no-new-array
+    const vp = new Array(chunkCount).fill(0)
+    for (let i = 0; i < m; i++) {
+      const chunkIndex = Math.floor(i / 32)
+      const bitPosition = i % 32
+      vp[chunkIndex] |= 1 << bitPosition
+    }
+    return vp
   }
 
   private calculateMatchQuality(
-    VP: bigint,
+    VP: number[],
     m: number,
     currentIndex: number,
     normalizedText: string,
     query: string,
   ): number {
-    return Effect.try({
-      try: () => {
-        // Count the number of set bits (matches) in VP
-        let matchCount = 0
-        let mask = VP
-
-        while (mask !== 0n) {
-          if ((mask & 1n) === 1n) {
-            matchCount++
-          }
-          mask >>= 1n
-        }
-
-        // Calculate the match ratio (matches / query length)
-        const matchRatio = matchCount / m
-
-        // Penalize matches that are not contiguous or not aligned properly
-        const isContiguous = this.isContiguousMatch(VP, m)
-        const alignmentPenalty = isContiguous ? 1 : 0.2 // Reduce score for non-contiguous matches
-
-        // Calculate position bonus (matches at the start of the text score higher)
-        const positionBonus = matchRatio > 0.5 ? (normalizedText.length - currentIndex) / normalizedText.length : 0
-
-        // Calculate partial match bonus (reward partial matches)
-        const partialMatchBonus = normalizedText.includes(query) ? 1 : 0
-
-        // Combine factors to calculate score
-        const score = (
-          (matchRatio * 0.6) // 60% weight
-          + (alignmentPenalty * 0.3) // 30% weight
-          + (positionBonus * 0.05) // 5% weight
-          + (partialMatchBonus * 0.05) // 5% weight
-        )
-
-        return Math.min(score, 1) // Ensure score does not exceed 1
-      },
-      catch: error => new Error(`[calculateMatchQuality]: Failed to calculate match quality: ${error}`),
-    }).pipe(Effect.runSync)
+    const matchCount = countSetBits(VP)
+    const matchRatio = matchCount / m
+    const isContiguous = this.isContiguousMatch(VP, m)
+    const alignmentPenalty = isContiguous ? 1 : 0.2
+    const positionBonus = matchRatio > 0.5 ? (normalizedText.length - currentIndex) / normalizedText.length : 0
+    const partialMatchBonus = normalizedText.includes(query) ? 1 : 0
+
+    const score = (
+      (matchRatio * 0.6)
+      + (alignmentPenalty * 0.3)
+      + (positionBonus * 0.05)
+      + (partialMatchBonus * 0.05)
+    )
+
+    return Math.min(score, 1)
   }
 
-  private isContiguousMatch(VP: bigint, m: number): boolean {
-    return Effect.try({
-      try: () => {
-        let first = -1
-        let last = -1
-        for (let i = 0; i < m; i++) {
-          if ((VP & (1n << BigInt(i))) !== 0n) {
-            if (first === -1)
-              first = i
-            last = i
-          }
-        }
-        return (last - first + 1) === m
-      },
-      catch: error => new Error(`[isContiguousMatch]: Failed to check if match is contiguous: ${error}`),
-    }).pipe(Effect.runSync)
+  private isContiguousMatch(VP: number[], m: number): boolean {
+    let first = -1
+    let last = -1
+    for (let i = 0; i < m; i++) {
+      const chunkIndex = Math.floor(i / 32)
+      const bitPosition = i % 32
+      if (chunkIndex >= VP.length)
+        break
+      if ((VP[chunkIndex] & (1 << bitPosition)) !== 0) {
+        if (first === -1)
+          first = i
+        last = i
+      }
+    }
+    return (last - first + 1) === m && first !== -1
   }
 
-  private findMatchRanges(VP: bigint, m: number, endIndex: number): [number, number][] {
-    return Effect.try({
-      try: () => {
-        const ranges: [number, number][] = []
-        let start = -1
-        let end = -1
-
-        for (let i = 0; i < m; i++) {
-          if ((VP & (1n << BigInt(i))) !== 0n) {
-            if (start === -1)
-              start = endIndex - i
-            end = endIndex - i
-          }
-          else if (start !== -1) {
-            ranges.push([start, end])
-            start = -1
-            end = -1
-          }
-        }
+  private findMatchRanges(VP: number[], m: number, endIndex: number): [number, number][] {
+    const ranges: [number, number][] = []
+    let start = -1
+    let end = -1
+
+    for (let i = 0; i < m; i++) {
+      const chunkIndex = Math.floor(i / 32)
+      const bitPosition = i % 32
+      if (chunkIndex < VP.length && (VP[chunkIndex] & (1 << bitPosition)) !== 0) {
+        if (start === -1)
+          start = endIndex - i
+        end = endIndex - i
+      }
+      else if (start !== -1) {
+        ranges.push([start, end])
+        start = -1
+        end = -1
+      }
+    }
 
-        if (start !== -1) {
-          ranges.push([start, end])
-        }
+    if (start !== -1) {
+      ranges.push([start, end])
+    }
 
-        return ranges
-      },
-      catch: error => new Error(`[findMatchRanges]: Failed to find match ranges: ${error}`),
-    }).pipe(Effect.runSync)
+    return ranges
   }
 }

src/utils/index.ts

@@ -12,3 +12,98 @@ export function normalizeText(text: string): string {
     catch: error => new Error(`[normalizeText]: Failed to normalize text: ${error}`),
   }).pipe(Effect.runSync)
 }
+
+export function bitwiseOR(a: number[], b: number[]): number[] {
+  const result: number[] = []
+  const maxLength = Math.max(a.length, b.length)
+  for (let i = 0; i < maxLength; i++) {
+    const aVal = i < a.length ? a[i] : 0
+    const bVal = i < b.length ? b[i] : 0
+    result.push(aVal | bVal)
+  }
+  return result
+}
+
+export function bitwiseAND(a: number[], b: number[]): number[] {
+  const result: number[] = []
+  const maxLength = Math.max(a.length, b.length)
+  for (let i = 0; i < maxLength; i++) {
+    const aVal = i < a.length ? a[i] : 0
+    const bVal = i < b.length ? b[i] : 0
+    result.push(aVal & bVal)
+  }
+  return result
+}
+
+export function bitwiseXOR(a: number[], b: number[]): number[] {
+  const result: number[] = []
+  const maxLength = Math.max(a.length, b.length)
+  for (let i = 0; i < maxLength; i++) {
+    const aVal = i < a.length ? a[i] : 0
+    const bVal = i < b.length ? b[i] : 0
+    result.push(aVal ^ bVal)
+  }
+  return result
+}
+
+export const bitwiseNOT = (a: number[]): number[] => a.map(chunk => (~chunk) >>> 0)
+
+export function bitwiseShiftLeft(a: number[]): number[] {
+  const result: number[] = []
+  let carry = 0
+  for (const chunk of a) {
+    const newChunk = (chunk << 1) | carry
+    carry = (chunk >>> 31) & 1
+    result.push(newChunk >>> 0)
+  }
+  if (carry)
+    result.push(carry)
+  return result
+}
+
+export function addBitVectors(a: number[], b: number[]): number[] {
+  const result: number[] = []
+  let carry = 0
+  const maxLength = Math.max(a.length, b.length)
+  for (let i = 0; i < maxLength; i++) {
+    const aVal = i < a.length ? a[i] : 0
+    const bVal = i < b.length ? b[i] : 0
+    const sum = aVal + bVal + carry
+    carry = sum > 0xFFFFFFFF ? 1 : 0
+    result.push(sum & 0xFFFFFFFF)
+  }
+  if (carry)
+    result.push(carry)
+  return result
+}
+
+export function setLeastSignificantBit(a: number[]): number[] {
+  if (a.length === 0)
+    return [1]
+  const newA = [...a]
+  newA[0] |= 1
+  return newA
+}
+
+export function maskVP(vp: number[], m: number): number[] {
+  const chunkCount = Math.ceil(m / 32)
+  const masked = vp.slice(0, chunkCount)
+  const lastChunkBits = m % 32 || 32
+  if (masked.length > 0) {
+    const lastIndex = masked.length - 1
+    masked[lastIndex] &= (1 << lastChunkBits) - 1
+  }
+  return masked
+}
+
+export function countSetBits(vp: number[]): number {
+  let count = 0
+  for (const chunk of vp) {
+    let c = chunk
+    while (c) {
+      count += c & 1
+      c >>>= 1
+    }
+  }
+  return count
+}