fix algo and do stuff

Author: adhami3310

Cargo.lock

@@ -1,11 +1,14 @@
 [package]
-name = "lcs"
+name = "fast-lcs"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/reflex-dev/lcs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
-name = "lcs"
+name = "fast_lcs"
 crate-type = ["cdylib"]
 
 [dependencies]

Cargo.toml

@@ -0,0 +1,7 @@
+# fast-lcs
+
+```python
+from fast_lcs import compute_lcs_similarity
+
+compute_lcs_similarity(source="bab", target="abacaba", length_of_prefixes_of_target=[3, 4])
+```

README.md

@@ -0,0 +1,3 @@
+def compute_lcs_similarity(
+    source: str, target: str, length_of_prefixes_of_target: list[int]
+) -> list[float]: ...

fast_lcs.pyi

@@ -3,13 +3,17 @@ requires = ["maturin>=1.11,<2.0"]
 build-backend = "maturin"
 
 [project]
-name = "lcs"
-requires-python = ">=3.8"
+name = "fast-lcs"
+description = "A fast implementation of the longest common subsequence."
+requires-python = ">=3.13"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dynamic = ["version"]
+license = { text = "MIT" }
+readme = "README.md"
+
 [tool.maturin]
 features = ["pyo3/extension-module"]

lcs.pyi

@@ -1,15 +1,16 @@
 use pyo3::prelude::*;
 
 struct LCS {
-    calculated: Vec<usize>,
+    length_of_source: usize,
+    calculated_table: Vec<usize>,
 }
 
 impl LCS {
-    fn from_strings(s1: &str, s2: &str) -> Self {
-        let mut previous = vec![0; s2.len() + 1];
-        let mut current = vec![0; s2.len() + 1];
-        for c1 in s1.chars() {
-            for (j, c2) in s2.chars().enumerate() {
+    fn from_strings(source: &str, target: &str) -> Self {
+        let mut previous = vec![0; target.len() + 1];
+        let mut current = vec![0; target.len() + 1];
+        for c1 in source.chars() {
+            for (j, c2) in target.chars().enumerate() {
                 if c1 == c2 {
                     current[j + 1] = previous[j] + 1;
                 } else {
@@ -19,30 +20,37 @@ impl LCS {
             std::mem::swap(&mut previous, &mut current);
         }
         Self {
-            calculated: previous,
+            length_of_source: source.len(),
+            calculated_table: previous,
         }
     }
 
-    fn normalized_similarity_of_prefix(&self, prefix_length: usize) -> f64 {
-        if prefix_length == 0 {
+    fn normalized_similarity_of_prefix(&self, length_of_prefix_of_target: usize) -> f64 {
+        if length_of_prefix_of_target == 0 {
             return 1.0;
         }
-        let lcs_length = self.calculated[prefix_length];
-        (2.0 * lcs_length as f64) / (prefix_length + self.calculated.len() - 1) as f64
+        let lcs_length = self.calculated_table[length_of_prefix_of_target];
+        (2.0 * lcs_length as f64) / (length_of_prefix_of_target + self.length_of_source) as f64
     }
 }
 
 #[pyfunction]
-fn compute_lcs_similarity(s1: &str, s2: &str, queries: Vec<usize>) -> Vec<f64> {
-    let lcs = LCS::from_strings(s1, s2);
-    queries
+fn compute_lcs_similarity(
+    source: &str,
+    target: &str,
+    length_of_prefixes_of_target: Vec<usize>,
+) -> Vec<f64> {
+    let lcs = LCS::from_strings(source, target);
+    length_of_prefixes_of_target
         .into_iter()
-        .map(|prefix_length| lcs.normalized_similarity_of_prefix(prefix_length))
+        .map(|length_of_prefix_of_target| {
+            lcs.normalized_similarity_of_prefix(length_of_prefix_of_target)
+        })
         .collect()
 }
 
 #[pymodule(gil_used = false)]
-fn lcs(m: &Bound<'_, PyModule>) -> PyResult<()> {
+fn fast_lcs(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(compute_lcs_similarity, m)?)?;
     Ok(())
 }