fuzzgpu 0.1.0__tar.gz → 0.1.1__tar.gz

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/Cargo.lock

@@ -248,7 +248,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-core"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "bytemuck",
  "log",
@@ -260,7 +260,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-python"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "fuzzgpu-core",
  "pollster",

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fuzzgpu
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -35,7 +35,7 @@ Project-URL: Repository, https://github.com/kuntal-devrat/fuzzgpu
 
 *Cross-platform GPU compute via WebGPU (`wgpu`) & Multi-Core CPU parallelism with Rayon. Zero CUDA dependencies.*
 
-[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.1-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 [![Rust](https://img.shields.io/badge/rust-1.75+-orange.svg?style=flat-square)](https://www.rust-lang.org)
 [![Cross Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20WASM-lightgrey.svg?style=flat-square)](https://github.com/kuntal-devrat/fuzzgpu)
@@ -100,7 +100,7 @@ pip install fuzzgpu
 ### Rust (Cargo.toml)
 ```toml
 [dependencies]
-fuzzgpu-core = "0.1.0"
+fuzzgpu-core = "0.1.1"
 ```
 
 ---

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/README.md

@@ -8,7 +8,7 @@
 
 *Cross-platform GPU compute via WebGPU (`wgpu`) & Multi-Core CPU parallelism with Rayon. Zero CUDA dependencies.*
 
-[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.1-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 [![Rust](https://img.shields.io/badge/rust-1.75+-orange.svg?style=flat-square)](https://www.rust-lang.org)
 [![Cross Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20WASM-lightgrey.svg?style=flat-square)](https://github.com/kuntal-devrat/fuzzgpu)
@@ -73,7 +73,7 @@ pip install fuzzgpu
 ### Rust (Cargo.toml)
 ```toml
 [dependencies]
-fuzzgpu-core = "0.1.0"
+fuzzgpu-core = "0.1.1"
 ```
 
 ---

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-core"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "GPU-accelerated fuzzy string matching engine"
 license = "MIT"

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-core/src/damerau.rs

@@ -1,23 +1,29 @@
 use rayon::prelude::*;
+use std::collections::HashMap;
 
 /// True unrestricted Damerau-Levenshtein distance (Lowrance & Wagner 1975).
 /// Computes edit distance allowing insertions, deletions, substitutions, and transpositions of any characters
 /// (including non-adjacent transpositions where characters were inserted/deleted in between).
+/// Supports both ASCII (fast array path) and full Unicode characters.
 pub fn damerau_levenshtein_distance(a: &str, b: &str) -> u32 {
-    let a = a.as_bytes();
-    let b = b.as_bytes();
-    let (m, n) = (a.len(), b.len());
+    if a.is_ascii() && b.is_ascii() {
+        damerau_bytes(a.as_bytes(), b.as_bytes())
+    } else {
+        let a_chars: Vec<char> = a.chars().collect();
+        let b_chars: Vec<char> = b.chars().collect();
+        damerau_chars(&a_chars, &b_chars)
+    }
+}
 
+fn damerau_bytes(a: &[u8], b: &[u8]) -> u32 {
+    let (m, n) = (a.len(), b.len());
     if m == 0 { return n as u32; }
     if n == 0 { return m as u32; }
     if a == b { return 0; }
 
     let max_dist = (m + n) as u32;
-
-    // 2D distance matrix of size (m + 2) x (n + 2)
-    let rows = m + 2;
     let cols = n + 2;
-    let mut h = vec![0u32; rows * cols];
+    let mut h = vec![0u32; (m + 2) * cols];
 
     let idx = |i: isize, j: isize| -> usize {
         ((i + 1) as usize) * cols + ((j + 1) as usize)
@@ -33,11 +39,10 @@ pub fn damerau_levenshtein_distance(a: &str, b: &str) -> u32 {
         h[idx(0, j as isize)] = j as u32;
     }
 
-    // da[c] stores the last row where character c appeared in a
     let mut da = [0usize; 256];
 
     for i in 1..=m {
-        let mut db = 0usize; // last column where character appeared in b
+        let mut db = 0usize;
         let ai = a[i - 1];
 
         for j in 1..=n {
@@ -71,6 +76,67 @@ pub fn damerau_levenshtein_distance(a: &str, b: &str) -> u32 {
     h[idx(m as isize, n as isize)]
 }
 
+fn damerau_chars(a: &[char], b: &[char]) -> u32 {
+    let (m, n) = (a.len(), b.len());
+    if m == 0 { return n as u32; }
+    if n == 0 { return m as u32; }
+    if a == b { return 0; }
+
+    let max_dist = (m + n) as u32;
+    let cols = n + 2;
+    let mut h = vec![0u32; (m + 2) * cols];
+
+    let idx = |i: isize, j: isize| -> usize {
+        ((i + 1) as usize) * cols + ((j + 1) as usize)
+    };
+
+    h[idx(-1, -1)] = max_dist;
+    for i in 0..=m {
+        h[idx(i as isize, -1)] = max_dist;
+        h[idx(i as isize, 0)] = i as u32;
+    }
+    for j in 0..=n {
+        h[idx(-1, j as isize)] = max_dist;
+        h[idx(0, j as isize)] = j as u32;
+    }
+
+    let mut da: HashMap<char, usize> = HashMap::with_capacity(a.len());
+
+    for i in 1..=m {
+        let mut db = 0usize;
+        let ai = a[i - 1];
+
+        for j in 1..=n {
+            let bj = b[j - 1];
+            let k = da.get(&bj).copied().unwrap_or(0);
+            let l = db;
+
+            let cost = if ai == bj {
+                db = j;
+                0u32
+            } else {
+                1u32
+            };
+
+            let sub = h[idx((i - 1) as isize, (j - 1) as isize)] + cost;
+            let ins = h[idx(i as isize, (j - 1) as isize)] + 1;
+            let del = h[idx((i - 1) as isize, j as isize)] + 1;
+
+            let trans = if k > 0 && l > 0 {
+                h[idx((k - 1) as isize, (l - 1) as isize)] + ((i - k - 1) as u32) + 1 + ((j - l - 1) as u32)
+            } else {
+                max_dist
+            };
+
+            h[idx(i as isize, j as isize)] = sub.min(ins).min(del).min(trans);
+        }
+
+        da.insert(ai, i);
+    }
+
+    h[idx(m as isize, n as isize)]
+}
+
 /// Batch Damerau-Levenshtein: one query vs many candidates.
 pub fn damerau_levenshtein_batch(query: &str, candidates: &[&str]) -> Vec<u32> {
     candidates.par_iter().map(|c| damerau_levenshtein_distance(query, c)).collect()
@@ -88,7 +154,8 @@ pub fn damerau_levenshtein_cdist(list_a: &[&str], list_b: &[&str]) -> Vec<Vec<u3
 
 /// Damerau-Levenshtein normalized ratio (0.0 to 100.0) based on Sørensen-Dice formula.
 pub fn damerau_ratio(s1: &str, s2: &str) -> f64 {
-    let (len_a, len_b) = (s1.len(), s2.len());
+    let len_a = if s1.is_ascii() { s1.len() } else { s1.chars().count() };
+    let len_b = if s2.is_ascii() { s2.len() } else { s2.chars().count() };
     let total = len_a + len_b;
     if total == 0 { return 100.0; }
     let dist = damerau_levenshtein_distance(s1, s2) as f64;
@@ -101,13 +168,19 @@ mod tests {
 
     #[test]
     fn test_damerau_transposition() {
-        // "ab" to "ba" is 1 transposition in Damerau-Levenshtein, but 2 edits in Levenshtein
         assert_eq!(damerau_levenshtein_distance("ab", "ba"), 1);
-        // "ca" to "abc" is 2 in true Damerau-Levenshtein (transposition of 'c' and 'a', plus insertion of 'b')
         assert_eq!(damerau_levenshtein_distance("ca", "abc"), 2);
         assert_eq!(damerau_levenshtein_distance("kitten", "sitting"), 3);
     }
 
+    #[test]
+    fn test_damerau_unicode() {
+        assert_eq!(damerau_levenshtein_distance("café", "cafe"), 1);
+        assert_eq!(damerau_levenshtein_distance("naïve", "naive"), 1);
+        assert_eq!(damerau_levenshtein_distance("🚀", ""), 1);
+        assert_eq!(damerau_levenshtein_distance("中文", "中问"), 1);
+    }
+
     #[test]
     fn test_damerau_identical_and_empty() {
         assert_eq!(damerau_levenshtein_distance("", ""), 0);

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-core/src/fuzz.rs

@@ -2,10 +2,19 @@ use rayon::prelude::*;
 use std::collections::BTreeSet;
 
 /// Standard Indel / Levenshtein (substitution cost = 2) edit distance used for fuzzy ratios.
+/// Supports both ASCII fast-path and full Unicode characters.
 #[inline]
 pub fn indel_distance(a: &str, b: &str) -> u32 {
-    let a = a.as_bytes();
-    let b = b.as_bytes();
+    if a.is_ascii() && b.is_ascii() {
+        indel_distance_slice(a.as_bytes(), b.as_bytes())
+    } else {
+        let a_chars: Vec<char> = a.chars().collect();
+        let b_chars: Vec<char> = b.chars().collect();
+        indel_distance_slice(&a_chars, &b_chars)
+    }
+}
+
+fn indel_distance_slice<T: PartialEq>(a: &[T], b: &[T]) -> u32 {
     let (m, n) = (a.len(), b.len());
     if m == 0 { return n as u32; }
     if n == 0 { return m as u32; }
@@ -19,10 +28,10 @@ pub fn indel_distance(a: &str, b: &str) -> u32 {
     for i in 1..=m {
         let mut prev_diag = row[0];
         row[0] = i as u32;
-        let ai = a[i - 1];
+        let ai = &a[i - 1];
         for j in 1..=n {
             let old = row[j];
-            let cost = if ai == b[j - 1] { 0 } else { 2 };
+            let cost = if ai == &b[j - 1] { 0 } else { 2 };
             row[j] = (prev_diag + cost).min(row[j] + 1).min(row[j - 1] + 1);
             prev_diag = old;
         }
@@ -34,9 +43,10 @@ pub fn indel_distance(a: &str, b: &str) -> u32 {
 ///
 /// Formula: `(|a| + |b| - indel_distance) / (|a| + |b|) × 100`
 ///
-/// Matches RapidFuzz and FuzzyWuzzy identically across all symmetric and asymmetric test cases.
+/// Matches RapidFuzz and FuzzyWuzzy identically across all ASCII and multi-byte Unicode test cases.
 pub fn ratio(s1: &str, s2: &str) -> f64 {
-    let (len_a, len_b) = (s1.len(), s2.len());
+    let len_a = if s1.is_ascii() { s1.len() } else { s1.chars().count() };
+    let len_b = if s2.is_ascii() { s2.len() } else { s2.chars().count() };
     let total = len_a + len_b;
     if total == 0 { return 100.0; }
     let dist = indel_distance(s1, s2) as f64;
@@ -51,33 +61,41 @@ pub fn ratio(s1: &str, s2: &str) -> f64 {
 pub fn partial_ratio(s1: &str, s2: &str) -> f64 {
     if s1.is_empty() || s2.is_empty() { return 0.0; }
 
-    // Ensure `shorter` is the shorter string.
-    let (shorter, longer) = if s1.len() <= s2.len() { (s1, s2) } else { (s2, s1) };
+    let s1_count = if s1.is_ascii() { s1.len() } else { s1.chars().count() };
+    let s2_count = if s2.is_ascii() { s2.len() } else { s2.chars().count() };
 
-    let short_len = shorter.len();
-    let long_len = longer.len();
+    let (shorter, longer, short_chars, long_chars) = if s1_count <= s2_count {
+        (s1, s2, s1_count, s2_count)
+    } else {
+        (s2, s1, s2_count, s1_count)
+    };
 
-    if short_len == long_len {
+    if short_chars == long_chars {
         return ratio(shorter, longer);
     }
 
-
-    let mut best = 0.0f64;
-
-    // Slide a window of `short_len` across `longer`.
-    for start in 0..=(long_len - short_len) {
-        // Only compare at valid UTF-8 boundaries.
-        if start > 0 && !longer.is_char_boundary(start) { continue; }
-        let end = start + short_len;
-        if end <= long_len && longer.is_char_boundary(end) {
-            let window = &longer[start..end];
+    if shorter.is_ascii() && longer.is_ascii() {
+        let short_bytes = shorter.as_bytes();
+        let long_bytes = longer.as_bytes();
+        let mut best = 0.0f64;
+        for start in 0..=(long_bytes.len() - short_bytes.len()) {
+            let window = &longer[start..start + short_bytes.len()];
             let score = ratio(shorter, window);
             if score > best { best = score; }
-            if best == 100.0 { return 100.0; } // Early exit: can't do better.
+            if best == 100.0 { return 100.0; }
+        }
+        best
+    } else {
+        let longer_chars: Vec<char> = longer.chars().collect();
+        let mut best = 0.0f64;
+        for start in 0..=(longer_chars.len() - short_chars) {
+            let window: String = longer_chars[start..start + short_chars].iter().collect();
+            let score = ratio(shorter, &window);
+            if score > best { best = score; }
+            if best == 100.0 { return 100.0; }
         }
+        best
     }
-
-    best
 }
 
 /// Token sort ratio: sort tokens alphabetically, then compare.
@@ -108,12 +126,9 @@ pub fn token_set_ratio(s1: &str, s2: &str) -> f64 {
 
     // If both strings have identical token sets
     if diff1.is_empty() && diff2.is_empty() {
-        return if inter_str.is_empty() { 100.0 } else { 100.0 };
+        return 100.0;
     }
 
-    // t0 = intersection
-    // t1 = intersection + diff1
-    // t2 = intersection + diff2
     let t0 = &inter_str;
 
     let t1 = if inter_str.is_empty() {
@@ -155,15 +170,10 @@ pub fn ratio_batch(query: &str, candidates: &[&str]) -> Vec<f64> {
 /// Extract top matches with partial-sort optimization.
 ///
 /// Returns `Vec<(match_string, score, original_index)>` sorted by score descending.
-///
-/// Uses `select_nth_unstable_by` for O(n) top-K selection when `limit << choices.len()`,
-/// and parallelizes scoring with Rayon for large choice sets.
 pub fn extract(query: &str, choices: &[&str], score_cutoff: f64, limit: usize) -> Vec<(String, f64, usize)> {
     if choices.is_empty() || limit == 0 { return vec![]; }
 
-    // Score all choices, filtering by cutoff.
     let mut results: Vec<(String, f64, usize)> = if choices.len() > 1000 {
-        // Parallelize for large choice sets.
         choices.par_iter().enumerate()
             .filter_map(|(i, c)| {
                 let score = ratio(query, c);
@@ -181,14 +191,11 @@ pub fn extract(query: &str, choices: &[&str], score_cutoff: f64, limit: usize) -
 
     if results.is_empty() { return results; }
 
-    // Optimized top-K: if we need far fewer results than we have,
-    // use partial sort instead of full sort.
     if limit < results.len() {
         results.select_nth_unstable_by(limit, |a, b| {
             b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal)
         });
         results.truncate(limit);
-        // Sort the top-K for deterministic output order.
         results.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
     } else {
         results.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
@@ -212,7 +219,7 @@ pub fn extract_one(query: &str, choices: &[&str], score_cutoff: f64) -> Option<(
                 best = Some((c.to_string(), score, i));
             }
         }
-        if score == 100.0 { break; } // Can't do better.
+        if score == 100.0 { break; }
     }
 
     best
@@ -224,23 +231,26 @@ mod tests {
 
     #[test]
     fn test_ratio_sorensen_dice() {
-        // "hello" (5) vs "hallo" (5): edit distance = 2 (sub cost = 2)
-        // Expected: (5 + 5 - 2) / (5 + 5) * 100 = 80.0
         let r = ratio("hello", "hallo");
         assert!((r - 80.0).abs() < 0.01, "Expected 80.0, got {}", r);
     }
 
+    #[test]
+    fn test_ratio_unicode() {
+        let r = ratio("café", "cafe");
+        // "café" (4 chars), "cafe" (4 chars), indel distance = 2
+        // (4 + 4 - 2) / (4 + 4) * 100 = 75.0%
+        assert!((r - 75.0).abs() < 0.01, "Expected 75.0, got {}", r);
+    }
+
     #[test]
     fn test_ratio_asymmetric() {
-        // "a" (1) vs "abc" (3): edit distance = 2
-        // Expected: (1 + 3 - 2) / (1 + 3) * 100 = 50.0
         let r = ratio("a", "abc");
         assert!((r - 50.0).abs() < 0.01, "Expected 50.0, got {}", r);
     }
 
     #[test]
     fn test_partial_ratio() {
-        // "hello" is a substring of "oh hello there"
         let r = partial_ratio("hello", "oh hello there");
         assert!(r >= 100.0 - 0.01, "Expected ~100.0, got {}", r);
     }
@@ -254,11 +264,4 @@ mod tests {
         assert_eq!(m, "apple");
         assert!((s - 100.0).abs() < 0.01);
     }
-
-    #[test]
-    fn test_extract_one_none_below_cutoff() {
-        let choices = vec!["zzzzz"];
-        let result = extract_one("apple", &choices, 90.0);
-        assert!(result.is_none());
-    }
 }

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-core/src/jaro.rs

@@ -3,11 +3,38 @@ use rayon::prelude::*;
 /// Jaro similarity between two strings.
 ///
 /// Returns 1.0 for identical strings (including both empty), 0.0 if no matches.
+/// Supports both ASCII fast-path and full Unicode characters.
 pub fn jaro(a: &str, b: &str) -> f64 {
-    let a = a.as_bytes();
-    let b = b.as_bytes();
+    if a.is_ascii() && b.is_ascii() {
+        jaro_bytes(a.as_bytes(), b.as_bytes())
+    } else {
+        let a_chars: Vec<char> = a.chars().collect();
+        let b_chars: Vec<char> = b.chars().collect();
+        jaro_chars(&a_chars, &b_chars)
+    }
+}
+
+fn jaro_bytes(a: &[u8], b: &[u8]) -> f64 {
     let (m, n) = (a.len(), b.len());
+    if m == 0 && n == 0 { return 1.0; }
+    if m == 0 || n == 0 { return 0.0; }
+    if a == b { return 1.0; }
+
+    let match_distance = (m.max(n) / 2).saturating_sub(1);
+
+    if m <= 128 && n <= 128 {
+        let mut a_matches = [false; 128];
+        let mut b_matches = [false; 128];
+        jaro_inner_slice(a, b, &mut a_matches[..m], &mut b_matches[..n], match_distance)
+    } else {
+        let mut a_matches = vec![false; m];
+        let mut b_matches = vec![false; n];
+        jaro_inner_slice(a, b, &mut a_matches, &mut b_matches, match_distance)
+    }
+}
 
+fn jaro_chars(a: &[char], b: &[char]) -> f64 {
+    let (m, n) = (a.len(), b.len());
     if m == 0 && n == 0 { return 1.0; }
     if m == 0 || n == 0 { return 0.0; }
     if a == b { return 1.0; }
@@ -17,25 +44,25 @@ pub fn jaro(a: &str, b: &str) -> f64 {
     if m <= 128 && n <= 128 {
         let mut a_matches = [false; 128];
         let mut b_matches = [false; 128];
-        jaro_inner(a, b, &mut a_matches[..m], &mut b_matches[..n], match_distance)
+        jaro_inner_slice(a, b, &mut a_matches[..m], &mut b_matches[..n], match_distance)
     } else {
         let mut a_matches = vec![false; m];
         let mut b_matches = vec![false; n];
-        jaro_inner(a, b, &mut a_matches, &mut b_matches, match_distance)
+        jaro_inner_slice(a, b, &mut a_matches, &mut b_matches, match_distance)
     }
 }
 
 #[inline]
-fn jaro_inner(a: &[u8], b: &[u8], a_matches: &mut [bool], b_matches: &mut [bool], match_distance: usize) -> f64 {
+fn jaro_inner_slice<T: PartialEq>(a: &[T], b: &[T], a_matches: &mut [bool], b_matches: &mut [bool], match_distance: usize) -> f64 {
     let (m, n) = (a.len(), b.len());
     let mut matches = 0u32;
 
     for i in 0..m {
         let lo = i.saturating_sub(match_distance);
         let hi = (i + match_distance + 1).min(n);
-        let ai = a[i];
+        let ai = &a[i];
         for j in lo..hi {
-            if b_matches[j] || ai != b[j] { continue; }
+            if b_matches[j] || ai != &b[j] { continue; }
             a_matches[i] = true;
             b_matches[j] = true;
             matches += 1;
@@ -61,15 +88,27 @@ fn jaro_inner(a: &[u8], b: &[u8], a_matches: &mut [bool], b_matches: &mut [bool]
 
 /// Jaro-Winkler similarity with prefix bonus.
 /// `p` is the prefix weight (0.0–0.25, default 0.1).
+/// Winkler prefix boost is applied when base Jaro similarity is >= 0.7 (Winkler 1990 standard).
 pub fn jaro_winkler(a: &str, b: &str, p: f64) -> f64 {
     if a == b { return 1.0; }
 
     let jaro_score = jaro(a, b);
-    let prefix_len = a.as_bytes().iter()
-        .zip(b.as_bytes().iter())
-        .take_while(|(x, y)| x == y)
-        .count()
-        .min(4);
+    if jaro_score < 0.7 {
+        return jaro_score;
+    }
+
+    let prefix_len = if a.is_ascii() && b.is_ascii() {
+        a.as_bytes().iter()
+            .zip(b.as_bytes().iter())
+            .take_while(|(x, y)| x == y)
+            .count()
+            .min(4)
+    } else {
+        a.chars().zip(b.chars())
+            .take_while(|(x, y)| x == y)
+            .count()
+            .min(4)
+    };
 
     jaro_score + (prefix_len as f64 * p * (1.0 - jaro_score))
 }
@@ -261,11 +300,13 @@ pub mod gpu_ext {
             let mut max_len = 0u32;
             for &i in indices {
                 let (a, b) = pairs[i];
-                chars_a.extend(a.bytes().map(|c| c as u32));
+                chars_a.extend(a.chars().map(|c| c as u32));
                 offsets_a.push(chars_a.len() as u32);
-                chars_b.extend(b.bytes().map(|c| c as u32));
+                chars_b.extend(b.chars().map(|c| c as u32));
                 offsets_b.push(chars_b.len() as u32);
-                max_len = max_len.max(a.len().max(b.len()) as u32);
+                let a_count = a.chars().count();
+                let b_count = b.chars().count();
+                max_len = max_len.max(a_count.max(b_count) as u32);
             }
 
             if chars_a.is_empty() { chars_a.push(0); }
@@ -341,7 +382,7 @@ pub mod gpu_ext {
             let mut chars_a: Vec<u32> = Vec::new();
             offsets_a.push(0);
             for a in list_a {
-                chars_a.extend(a.bytes().map(|c| c as u32));
+                chars_a.extend(a.chars().map(|c| c as u32));
                 offsets_a.push(chars_a.len() as u32);
             }
 
@@ -350,7 +391,7 @@ pub mod gpu_ext {
             let mut chars_b: Vec<u32> = Vec::new();
             offsets_b.push(0);
             for b in list_b {
-                chars_b.extend(b.bytes().map(|c| c as u32));
+                chars_b.extend(b.chars().map(|c| c as u32));
                 offsets_b.push(chars_b.len() as u32);
             }
 

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-core/src/levenshtein.rs

@@ -1,9 +1,18 @@
 use rayon::prelude::*;
 
 /// Standard single-row DP Levenshtein distance with diagonal optimization.
+/// Supports both ASCII (byte-fast path) and Unicode characters (scalar value codepoint path).
 pub fn levenshtein_distance_raw(a: &str, b: &str) -> u32 {
-    let a = a.as_bytes();
-    let b = b.as_bytes();
+    if a.is_ascii() && b.is_ascii() {
+        levenshtein_distance_slice(a.as_bytes(), b.as_bytes())
+    } else {
+        let a_chars: Vec<char> = a.chars().collect();
+        let b_chars: Vec<char> = b.chars().collect();
+        levenshtein_distance_slice(&a_chars, &b_chars)
+    }
+}
+
+fn levenshtein_distance_slice<T: PartialEq>(a: &[T], b: &[T]) -> u32 {
     let (m, n) = (a.len(), b.len());
     if m == 0 { return n as u32; }
     if n == 0 { return m as u32; }
@@ -18,10 +27,10 @@ pub fn levenshtein_distance_raw(a: &str, b: &str) -> u32 {
     for i in 1..=m {
         let mut prev_diag = row[0];
         row[0] = i as u32;
-        let ai = a[i - 1];
+        let ai = &a[i - 1];
         for j in 1..=n {
             let old = row[j];
-            let cost = if ai == b[j - 1] { 0 } else { 1 };
+            let cost = if ai == &b[j - 1] { 0 } else { 1 };
             row[j] = (prev_diag + cost).min(row[j] + 1).min(row[j - 1] + 1);
             prev_diag = old;
         }
@@ -158,7 +167,9 @@ pub mod gpu_ext {
 
             for (i, (a, b)) in pairs.iter().enumerate() {
                 if a.is_empty() || b.is_empty() {
-                    results[i] = (a.len().max(b.len())) as u32;
+                    let a_count = if a.is_ascii() { a.len() } else { a.chars().count() };
+                    let b_count = if b.is_ascii() { b.len() } else { b.chars().count() };
+                    results[i] = (a_count.max(b_count)) as u32;
                 } else if *a == *b {
                     results[i] = 0;
                 } else if a.len() > GPU_MAX_STRING_LEN || b.len() > GPU_MAX_STRING_LEN {
@@ -214,11 +225,13 @@ pub mod gpu_ext {
             let mut max_len = 0u32;
             for &i in indices {
                 let (a, b) = pairs[i];
-                chars_a.extend(a.bytes().map(|c| c as u32));
+                chars_a.extend(a.chars().map(|c| c as u32));
                 offsets_a.push(chars_a.len() as u32);
-                chars_b.extend(b.bytes().map(|c| c as u32));
+                chars_b.extend(b.chars().map(|c| c as u32));
                 offsets_b.push(chars_b.len() as u32);
-                max_len = max_len.max(a.len().max(b.len()) as u32);
+                let a_count = a.chars().count();
+                let b_count = b.chars().count();
+                max_len = max_len.max(a_count.max(b_count) as u32);
             }
 
             if chars_a.is_empty() { chars_a.push(0); }
@@ -329,7 +342,7 @@ pub mod gpu_ext {
             let mut chars_a: Vec<u32> = Vec::new();
             offsets_a.push(0);
             for a in list_a {
-                chars_a.extend(a.bytes().map(|c| c as u32));
+                chars_a.extend(a.chars().map(|c| c as u32));
                 offsets_a.push(chars_a.len() as u32);
             }
 
@@ -338,7 +351,7 @@ pub mod gpu_ext {
             let mut chars_b: Vec<u32> = Vec::new();
             offsets_b.push(0);
             for b in list_b {
-                chars_b.extend(b.bytes().map(|c| c as u32));
+                chars_b.extend(b.chars().map(|c| c as u32));
                 offsets_b.push(chars_b.len() as u32);
             }
 

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-core/src/needleman.rs

@@ -3,17 +3,32 @@ use rayon::prelude::*;
 /// Needleman-Wunsch global alignment score with linear gap penalty.
 ///
 /// Uses single-row DP + scalar diagonal for minimal memory.
+/// Supports both ASCII fast-path and full Unicode characters.
 pub fn needleman_wunsch(a: &str, b: &str, match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
-    let a = a.as_bytes();
-    let b = b.as_bytes();
+    if a.is_ascii() && b.is_ascii() {
+        needleman_wunsch_bytes(a.as_bytes(), b.as_bytes(), match_score, mismatch_score, gap_penalty)
+    } else {
+        let a_chars: Vec<char> = a.chars().collect();
+        let b_chars: Vec<char> = b.chars().collect();
+        needleman_wunsch_chars(&a_chars, &b_chars, match_score, mismatch_score, gap_penalty)
+    }
+}
+
+fn needleman_wunsch_bytes(a: &[u8], b: &[u8], match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
+    needleman_wunsch_slice(a, b, match_score, mismatch_score, gap_penalty)
+}
+
+fn needleman_wunsch_chars(a: &[char], b: &[char], match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
+    needleman_wunsch_slice(a, b, match_score, mismatch_score, gap_penalty)
+}
+
+fn needleman_wunsch_slice<T: PartialEq>(a: &[T], b: &[T], match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
     let (m, n) = (a.len(), b.len());
 
     if m == 0 { return (n as i32) * gap_penalty; }
     if n == 0 { return (m as i32) * gap_penalty; }
-    // Fast path: identical strings.
     if a == b { return (m as i32) * match_score; }
 
-    // Single-row + diagonal optimization: halves memory.
     let mut row = vec![0i32; n + 1];
     for (j, item) in row.iter_mut().enumerate() {
         *item = (j as i32) * gap_penalty;
@@ -22,10 +37,10 @@ pub fn needleman_wunsch(a: &str, b: &str, match_score: i32, mismatch_score: i32,
     for i in 1..=m {
         let mut prev_diag = row[0];
         row[0] = (i as i32) * gap_penalty;
-        let ai = a[i - 1];
+        let ai = &a[i - 1];
         for j in 1..=n {
             let old = row[j];
-            let score = if ai == b[j - 1] { match_score } else { mismatch_score };
+            let score = if ai == &b[j - 1] { match_score } else { mismatch_score };
             row[j] = (prev_diag + score)
                 .max(row[j] + gap_penalty)
                 .max(row[j - 1] + gap_penalty);
@@ -50,10 +65,6 @@ const NEG_INF: i32 = -1_000_000_000;
 /// Needleman-Wunsch global alignment score with affine gap penalties (Gotoh 1982 algorithm).
 ///
 /// Affine model: gap of length k costs `gap_open + k * gap_extend`.
-/// Uses 3 DP matrices / rows:
-/// - M(i, j): score where a[i-1] aligns with b[j-1]
-/// - Ix(i, j): score where a[i-1] aligns with a gap (deletion in b)
-/// - Iy(i, j): score where b[j-1] aligns with a gap (insertion in b)
 pub fn needleman_wunsch_affine(
     a: &str,
     b: &str,
@@ -62,8 +73,23 @@ pub fn needleman_wunsch_affine(
     gap_open: i32,
     gap_extend: i32,
 ) -> i32 {
-    let a = a.as_bytes();
-    let b = b.as_bytes();
+    if a.is_ascii() && b.is_ascii() {
+        needleman_wunsch_affine_slice(a.as_bytes(), b.as_bytes(), match_score, mismatch_score, gap_open, gap_extend)
+    } else {
+        let a_chars: Vec<char> = a.chars().collect();
+        let b_chars: Vec<char> = b.chars().collect();
+        needleman_wunsch_affine_slice(&a_chars, &b_chars, match_score, mismatch_score, gap_open, gap_extend)
+    }
+}
+
+fn needleman_wunsch_affine_slice<T: PartialEq>(
+    a: &[T],
+    b: &[T],
+    match_score: i32,
+    mismatch_score: i32,
+    gap_open: i32,
+    gap_extend: i32,
+) -> i32 {
     let (m, n) = (a.len(), b.len());
 
     if m == 0 && n == 0 { return 0; }
@@ -71,7 +97,6 @@ pub fn needleman_wunsch_affine(
     if n == 0 { return gap_open + (m as i32) * gap_extend; }
     if a == b { return (m as i32) * match_score; }
 
-    // Memory-efficient O(N) space implementation using 3 rows
     let mut m_row = vec![NEG_INF; n + 1];
     let mut ix_row = vec![NEG_INF; n + 1];
     let mut iy_row = vec![NEG_INF; n + 1];
@@ -93,23 +118,18 @@ pub fn needleman_wunsch_affine(
         m_row[0] = gap_cost_i;
         iy_row[0] = NEG_INF;
 
-        let ai = a[i - 1];
+        let ai = &a[i - 1];
 
         for j in 1..=n {
-            let bj = b[j - 1];
+            let bj = &b[j - 1];
             let sub_score = if ai == bj { match_score } else { mismatch_score };
 
-            // Diagonal best score from (i-1, j-1)
             let prev_diag_best = prev_m_diag.max(prev_ix_diag).max(prev_iy_diag);
             let new_m = prev_diag_best + sub_score;
 
-            // Ix: extension or new gap in B from row i-1
             let new_ix = (ix_row[j] + gap_extend).max(m_row[j] + gap_open + gap_extend).max(iy_row[j] + gap_open + gap_extend);
-
-            // Iy: extension or new gap in A from col j-1
             let new_iy = (iy_row[j - 1] + gap_extend).max(m_row[j - 1] + gap_open + gap_extend).max(ix_row[j - 1] + gap_open + gap_extend);
 
-            // Save old states for next diagonal
             prev_m_diag = m_row[j];
             prev_ix_diag = ix_row[j];
             prev_iy_diag = iy_row[j];
@@ -147,8 +167,6 @@ mod tests {
         let s2 = "AGCT";
         assert_eq!(needleman_wunsch_affine(s1, s2, 2, -1, -3, -1), 8);
 
-        // Gap open -3, extend -1: 2-char gap costs -3 + 2*(-1) = -5
-        // vs linear with gap -2: 2-char gap costs 2*(-2) = -4
         let score = needleman_wunsch_affine("ACGT", "AT", 2, -1, -3, -1);
         assert!(score < 8);
     }

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-core/src/shaders/jaro.wgsl

@@ -104,18 +104,20 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let t_f = f32(transpositions);
     let jaro = (m_f / a_f + m_f / b_f + (m_f - t_f / 2.0) / m_f) / 3.0;
 
-    // Winkler prefix bonus
-    let p = bitcast<f32>(params.winkler_p_bits);
-    var prefix_len = 0u;
-    let max_prefix = min(min(a_len, b_len), 4u);
-    for (var i = 0u; i < max_prefix; i++) {
-        if (chars_a[a_start + i] == chars_b[b_start + i]) {
-            prefix_len += 1u;
-        } else {
-            break;
+    // Winkler prefix bonus (standard Winkler 1990: only when jaro >= 0.7)
+    var jw = jaro;
+    if (jaro >= 0.7) {
+        let p = bitcast<f32>(params.winkler_p_bits);
+        var prefix_len = 0u;
+        let max_prefix = min(min(a_len, b_len), 4u);
+        for (var i = 0u; i < max_prefix; i++) {
+            if (chars_a[a_start + i] == chars_b[b_start + i]) {
+                prefix_len += 1u;
+            } else {
+                break;
+            }
         }
+        jw = jaro + f32(prefix_len) * p * (1.0 - jaro);
     }
-
-    let jw = jaro + f32(prefix_len) * p * (1.0 - jaro);
     results[pair_idx] = bitcast<u32>(jw);
 }

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-core/src/shaders/jaro_matrix.wgsl

@@ -104,17 +104,20 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let t_f = f32(transpositions);
     let jaro = (m_f / a_f + m_f / b_f + (m_f - t_f / 2.0) / m_f) / 3.0;
 
-    let p = bitcast<f32>(params.winkler_p_bits);
-    var prefix_len = 0u;
-    let max_prefix = min(min(a_len, b_len), 4u);
-    for (var i = 0u; i < max_prefix; i++) {
-        if (chars_a[a_start + i] == chars_b[b_start + i]) {
-            prefix_len += 1u;
-        } else {
-            break;
+    // Winkler prefix bonus (standard Winkler 1990: only when jaro >= 0.7)
+    var jw = jaro;
+    if (jaro >= 0.7) {
+        let p = bitcast<f32>(params.winkler_p_bits);
+        var prefix_len = 0u;
+        let max_prefix = min(min(a_len, b_len), 4u);
+        for (var i = 0u; i < max_prefix; i++) {
+            if (chars_a[a_start + i] == chars_b[b_start + i]) {
+                prefix_len += 1u;
+            } else {
+                break;
+            }
         }
+        jw = jaro + f32(prefix_len) * p * (1.0 - jaro);
     }
-
-    let jw = jaro + f32(prefix_len) * p * (1.0 - jaro);
     matrix[out_idx] = bitcast<u32>(jw);
 }

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-python"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "Python bindings for FuzzGPU: GPU-accelerated fuzzy string matching engine"
 license = "MIT"
@@ -17,6 +17,6 @@ default = ["gpu"]
 gpu = ["fuzzgpu-core/gpu"]
 
 [dependencies]
-fuzzgpu-core = { path = "../fuzzgpu-core" }
+fuzzgpu-core = { path = "../fuzzgpu-core", version = "0.1.1", default-features = false }
 pyo3 = { workspace = true, features = ["abi3-py39"] }
 pollster = { workspace = true }

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/crates/fuzzgpu-python/src/lib.rs

@@ -119,11 +119,13 @@ fn jaro_similarity(a: &str, b: &str) -> PyResult<f64> {
 }
 
 #[pyfunction]
+#[pyo3(signature = (a, b, p = 0.1))]
 fn jaro_winkler_similarity(a: &str, b: &str, p: f64) -> PyResult<f64> {
     Ok(fuzzgpu_core::jaro_winkler(a, b, p))
 }
 
 #[pyfunction]
+#[pyo3(signature = (query, candidates, p = 0.1))]
 fn jaro_winkler_batch_fn(py: Python, query: String, candidates: Vec<String>, p: f64) -> PyResult<Vec<f64>> {
     let pairs: Vec<(&str, &str)> = candidates.iter().map(|c| (query.as_str(), c.as_str())).collect();
     #[cfg(feature = "gpu")]
@@ -144,6 +146,7 @@ fn jaro_winkler_batch_fn(py: Python, query: String, candidates: Vec<String>, p:
 }
 
 #[pyfunction]
+#[pyo3(signature = (list_a, list_b, p = 0.1))]
 fn jaro_winkler_cdist(py: Python, list_a: Vec<String>, list_b: Vec<String>, p: f64) -> PyResult<Vec<Vec<f64>>> {
     let refs_a: Vec<&str> = list_a.iter().map(|s| s.as_str()).collect();
     let refs_b: Vec<&str> = list_b.iter().map(|s| s.as_str()).collect();
@@ -268,6 +271,6 @@ fn fuzzgpu(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(jaro_optimized, m)?)?;
     // GPU info & version
     m.add_function(wrap_pyfunction!(gpu_info, m)?)?;
-    m.add("__version__", "0.1.0")?;
+    m.add("__version__", "0.1.1")?;
     Ok(())
 }

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "fuzzgpu"
-version = "0.1.0"
+version = "0.1.1"
 description = "Hardware-accelerated fuzzy string matching & sequence alignment — cross-platform, no CUDA required"
 readme = "README.md"
 license = { text = "MIT" }

{fuzzgpu-0.1.0 → fuzzgpu-0.1.1}/python/fuzzgpu/__init__.py

@@ -19,9 +19,9 @@ Usage:
     score = fuzzgpu.needleman_wunsch_score("AGTACGCA", "TATGC", 2, -1, -2)
     score_affine = fuzzgpu.needleman_wunsch_affine("AGTACGCA", "TATGC", 2, -1, -3, -1)
 
-    # Jaro-Winkler similarity (GPU-accelerated for batches)
-    sim = fuzzgpu.jaro_winkler_similarity("MARTHA", "MARHTA", 0.1)  # 0.96
-    jw_batch = fuzzgpu.jaro_winkler_batch("MARTHA", ["MARHTA", "MATRH"], 0.1)
+    # Jaro & Jaro-Winkler similarity (GPU-accelerated for batches)
+    sim = fuzzgpu.jaro_winkler("MARTHA", "MARHTA")  # 0.96 (default p=0.1)
+    jw_batch = fuzzgpu.jaro_winkler_batch("MARTHA", ["MARHTA", "MATRH"])
 
     # Fuzzy matching (rapidfuzz-compatible)
     from fuzzgpu.fuzz import ratio, partial_ratio, token_sort_ratio, token_set_ratio, extract, extractOne
@@ -65,11 +65,14 @@ from fuzzgpu.fuzzgpu import (
     __version__,
 )
 
-# Re-export with clean names
+# Re-export with clean names & intuitive aliases
 levenshtein = levenshtein_distance
 damerau_levenshtein = damerau_levenshtein_distance
+damerau = damerau_levenshtein_distance
 needleman_wunsch = needleman_wunsch_score
 needleman_wunsch_batch = needleman_wunsch_batch_fn
+jaro = jaro_similarity
+jaro_winkler = jaro_winkler_similarity
 jaro_winkler_batch = jaro_winkler_batch_fn
 ratio = fuzz_ratio
 partial_ratio = fuzz_partial_ratio
@@ -90,7 +93,7 @@ __all__ = [
     "levenshtein_myers", "needleman_wunsch_striped", "jaro_optimized",
     "gpu_info", "__version__",
     # Aliases
-    "levenshtein", "damerau_levenshtein", "needleman_wunsch", "needleman_wunsch_batch",
-    "jaro_winkler_batch", "ratio", "partial_ratio", "token_sort_ratio", "token_set_ratio",
-    "wratio", "ratio_batch", "extract", "extractOne",
+    "levenshtein", "damerau_levenshtein", "damerau", "needleman_wunsch", "needleman_wunsch_batch",
+    "jaro", "jaro_winkler", "jaro_winkler_batch", "ratio", "partial_ratio",
+    "token_sort_ratio", "token_set_ratio", "wratio", "ratio_batch", "extract", "extractOne",
 ]