py-alpha-lib 0.3.1__tar.gz → 0.3.3__tar.gz

{py_alpha_lib-0.3.1 → py_alpha_lib-0.3.3}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "alpha"
-version = "0.3.1"
+version = "0.3.3"
 dependencies = [
  "alpha-algo",
  "anyhow",
@@ -19,7 +19,7 @@ dependencies = [
 
 [[package]]
 name = "alpha-algo"
-version = "0.3.1"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "mlua",
@@ -52,7 +52,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -238,7 +238,7 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "js-alpha-lib"
-version = "0.3.1"
+version = "0.3.3"
 dependencies = [
  "alpha-algo",
  "console_error_panic_hook",
@@ -288,7 +288,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lua-alpha-lib"
-version = "0.3.1"
+version = "0.3.3"
 dependencies = [
  "alpha-algo",
  "anyhow",
@@ -345,7 +345,7 @@ dependencies = [
 
 [[package]]
 name = "mlang"
-version = "0.3.1"
+version = "0.3.3"
 dependencies = [
  "alpha-algo",
  "anyhow",
@@ -438,9 +438,9 @@ dependencies = [
 
 [[package]]
 name = "numpy"
-version = "0.28.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "778da78c64ddc928ebf5ad9df5edf0789410ff3bdbf3619aed51cd789a6af1e2"
+checksum = "aa0b9111761885449e894981fa8051dcf69e0bd114aecbd4bcdd830b6be4ed92"
 dependencies = [
  "libc",
  "ndarray",
@@ -517,7 +517,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -568,9 +568,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.28.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf85e27e86080aafd5a22eae58a162e133a589551542b3e5cee4beb27e54f8e1"
+checksum = "229ca13b8a15bb0d1487b81ab975bfcd97513416499a8312011b6036e42e0de4"
 dependencies = [
  "libc",
  "once_cell",
@@ -582,18 +582,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.28.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bf94ee265674bf76c09fa430b0e99c26e319c945d96ca0d5a8215f31bf81cf7"
+checksum = "70130e2b6dd1ee589a8788026a429561ca5c40fa7a2fa7914c2282eddae24700"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.28.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "491aa5fc66d8059dd44a75f4580a2962c1862a1c2945359db36f6c2818b748dc"
+checksum = "5e7ff73c555c286d212d4ce7e5fbda845a973c4f61bd5f160f5f2c3c2a04d1c4"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -601,9 +601,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-log"
-version = "0.13.3"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26c2ec80932c5c3b2d4fbc578c9b56b2d4502098587edb8bef5b6bfcad43682e"
+checksum = "b91aabf1c0d674a2e3b0b55daab6cef1308ce6f0ad3697ae56f4f68db54c98a1"
 dependencies = [
  "arc-swap",
  "log",
@@ -612,27 +612,26 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.28.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5d671734e9d7a43449f8480f8b38115df67bef8d21f76837fa75ee7aaa5e52e"
+checksum = "c46d2e5862c7bb8207e3b639f713dda3c499933444784154c11d013c5a691b60"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.28.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22faaa1ce6c430a1f71658760497291065e6450d7b5dc2bcf254d49f66ee700a"
+checksum = "38b89f066f2ae72a2aef52d1537ca2fcd104440ebfadee06e97aa90738a25b9b"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
- "syn",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -733,7 +732,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -789,6 +788,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "syn"
+version = "3.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
 [[package]]
 name = "target-lexicon"
 version = "0.13.4"
@@ -812,7 +822,7 @@ checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -891,7 +901,7 @@ dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.114",
  "wasm-bindgen-shared",
 ]
 
@@ -934,7 +944,7 @@ checksum = "e925354648d2a4d1bf205412e36d520a800280622eef4719678d268e5d40e978"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.114",
 ]
 
 [[package]]

{py_alpha_lib-0.3.1 → py_alpha_lib-0.3.3}/Cargo.toml

@@ -3,14 +3,14 @@ members = ["alpha-algo", "py-binding"]
 resolver = "3"
 
 [workspace.package]
-version = "0.3.1"
+version = "0.3.3"
 authors = ["ElseJJ"]
 edition = "2024"
 
 [workspace.dependencies]
 log = "0.4"
 num-traits = "0.2"
-numpy = "0.28"
+numpy = "0.30"
 pyo3-log = "0.13"
 rayon = "1.11"
 thiserror = "2"
@@ -18,7 +18,7 @@ anyhow = "1"
 mlua = { version = "0.11", features = ["lua55", "vendored", "anyhow"] }
 
 [workspace.dependencies.pyo3]
-version = "0.28"
+version = "0.30"
 
 
 [profile.wasm]

{py_alpha_lib-0.3.1 → py_alpha_lib-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-alpha-lib
-Version: 0.3.1
+Version: 0.3.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -9,7 +9,7 @@ License-File: LICENSE
 Summary: Alpha Library: A high-performance rolling window calculation library implemented in Rust with Python bindings. Used for financial data analysis and factor research.
 Keywords: financial data analysis,factor research,technical indicator calculation
 Author: ElseJJ
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: repository, https://github.com/msd-rs/py-alpha-lib
 

{py_alpha_lib-0.3.1 → py_alpha_lib-0.3.3}/alpha-algo/src/algo/rank.rs

@@ -478,25 +478,40 @@ mod tests {
   #[test]
   fn test_ta_rank_with_nan() {
     // groups=3, matrix [3,NaN; 1,5; 4,6]
-    let input = vec![3.0, f64::NAN, 1.0, 5.0, 4.0, 6.0];
+    let n = 32;
+    let g = 32;
+    let mut input = vec![];
+    (0..n).for_each(|i| {
+      if i % 2 == 0 {
+        (0..g).for_each(|_j| input.push(f64::NAN));
+      } else if i % 3 == 0 {
+        (0..g).for_each(|_j| input.push(f64::INFINITY));
+      } else if i % 5 == 0 {
+        (0..g).for_each(|_j| input.push(f64::NEG_INFINITY));
+      } else {
+        (0..g).for_each(|_j| input.push(i as f64));
+      }
+    });
     let mut r = vec![0.0; input.len()];
-    let ctx = Context::new(0, 3, 0);
+    let ctx = Context::new(0, g, 0);
 
     ta_cc_rank(&ctx, &mut r, &input).unwrap();
     // j=0: values [3,1,4], all valid, sorted [1,3,4], ranks [2,1,3]
     // j=1: values [NaN,5,6], 2 valid, sorted [5,6,NaN]
     //   5 -> rank 1/2=0.5, 6 -> rank 2/2=1.0, NaN -> NaN
-    assert_vec_eq_nan(
-      &r,
-      &vec![
-        2.0 / 3.0,
-        f64::NAN,
-        1.0 / 3.0,
-        1.0 / 2.0,
-        3.0 / 3.0,
-        2.0 / 2.0,
-      ],
-    );
+    // assert_vec_eq_nan(
+    //   &r,
+    //   &vec![
+    //     2.0 / 3.0,
+    //     f64::NAN,
+    //     1.0 / 3.0,
+    //     1.0 / 2.0,
+    //     3.0 / 3.0,
+    //     2.0 / 2.0,
+    //   ],
+    // );
+    println!("{:?}", input);
+    println!("{:?}", r);
   }
 
   #[test]
@@ -531,6 +546,24 @@ mod tests {
       -1.0,
       f64::MAX,
       f64::MIN,
+      f64::NAN,
+      1.0,
+      f64::NAN,
+      f64::NEG_INFINITY,
+      f64::INFINITY,
+      0.0,
+      -1.0,
+      f64::MAX,
+      f64::MIN,
+      f64::NAN,
+      1.0,
+      f64::NAN,
+      f64::NEG_INFINITY,
+      f64::INFINITY,
+      0.0,
+      -1.0,
+      f64::MAX,
+      f64::MIN,
     ]
     .into_iter()
     .map(OrderedFloat::from)

py_alpha_lib-0.3.3/alpha-algo/src/join.rs

@@ -0,0 +1,408 @@
+// Copyright 2026 MSD-RS Project LiJia
+// SPDX-License-Identifier: BSD-2-Clause
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub enum FillMethod {
+  #[default]
+  Zero,
+  Nan,
+  Backward,
+  Forward,
+}
+
+impl From<i32> for FillMethod {
+  fn from(value: i32) -> Self {
+    match value {
+      1 => Self::Nan,
+      2 => Self::Backward,
+      3 => Self::Forward,
+      _ => Self::Zero,
+    }
+  }
+}
+
+impl From<FillMethod> for i32 {
+  fn from(value: FillMethod) -> i32 {
+    match value {
+      FillMethod::Zero => 0,
+      FillMethod::Nan => 1,
+      FillMethod::Backward => 2,
+      FillMethod::Forward => 3,
+    }
+  }
+}
+
+impl From<&str> for FillMethod {
+  fn from(value: &str) -> Self {
+    match value {
+      "nan" => Self::Nan,
+      "backward" => Self::Backward,
+      "forward" => Self::Forward,
+      _ => Self::Zero,
+    }
+  }
+}
+
+impl From<String> for FillMethod {
+  fn from(value: String) -> Self {
+    Self::from(value.as_str())
+  }
+}
+
+impl From<&String> for FillMethod {
+  fn from(value: &String) -> Self {
+    Self::from(value.as_str())
+  }
+}
+
+impl From<FillMethod> for &'static str {
+  fn from(value: FillMethod) -> Self {
+    match value {
+      FillMethod::Zero => "zero",
+      FillMethod::Nan => "nan",
+      FillMethod::Backward => "backward",
+      FillMethod::Forward => "forward",
+    }
+  }
+}
+
+/// Join `left` and `right` according to `method`, and return in `result` the indices of `right` that match `left`. Both `left` and `right` are already sorted in ascending order.
+pub fn joined_index<T>(left: &[T], right: &[T], method: FillMethod, result: &mut Vec<usize>)
+where
+  T: PartialOrd + PartialEq,
+{
+  if result.len() != left.len() {
+    result.resize(left.len(), usize::MAX);
+  }
+
+  if left.is_empty() {
+    return;
+  }
+
+  if right.is_empty() {
+    result.fill(usize::MAX);
+    return;
+  }
+
+  match method {
+    FillMethod::Backward => joined_index_backward(left, right, result),
+    FillMethod::Forward => joined_index_forward(left, right, result),
+    FillMethod::Zero | FillMethod::Nan => joined_index_exact(left, right, result),
+  }
+}
+
+#[inline]
+fn joined_index_backward<T: PartialOrd>(left: &[T], right: &[T], result: &mut [usize]) {
+  let right_len = right.len();
+  let mut curr: Option<usize> = None;
+
+  for (x, out) in left.iter().zip(result.iter_mut()) {
+    if x.partial_cmp(x).is_none() {
+      *out = usize::MAX;
+      continue;
+    }
+
+    let mut cand = match curr {
+      Some(c) if right[c] <= *x => c,
+      _ => {
+        if right[0] > *x {
+          *out = usize::MAX;
+          continue;
+        }
+        0
+      }
+    };
+
+    if cand + 1 < right_len && right[cand + 1] <= *x {
+      cand += 1;
+      if cand + 1 < right_len && right[cand + 1] <= *x {
+        cand += 1;
+        let mut step = 2usize;
+        while cand + step < right_len && right[cand + step] <= *x {
+          cand += step;
+          step = step.saturating_mul(2);
+        }
+        let upper = (cand + step).min(right_len);
+        let offset = right[cand + 1..upper].partition_point(|r| r <= x);
+        cand += offset;
+      }
+    }
+
+    *out = cand;
+    curr = Some(cand);
+  }
+}
+
+#[inline]
+fn joined_index_exact<T: PartialOrd + PartialEq>(left: &[T], right: &[T], result: &mut [usize]) {
+  let right_len = right.len();
+  let mut curr: Option<usize> = None;
+
+  for (x, out) in left.iter().zip(result.iter_mut()) {
+    if x.partial_cmp(x).is_none() {
+      *out = usize::MAX;
+      continue;
+    }
+
+    let mut cand = match curr {
+      Some(c) if right[c] <= *x => c,
+      _ => {
+        if right[0] > *x {
+          *out = usize::MAX;
+          continue;
+        }
+        0
+      }
+    };
+
+    if cand + 1 < right_len && right[cand + 1] <= *x {
+      cand += 1;
+      if cand + 1 < right_len && right[cand + 1] <= *x {
+        cand += 1;
+        let mut step = 2usize;
+        while cand + step < right_len && right[cand + step] <= *x {
+          cand += step;
+          step = step.saturating_mul(2);
+        }
+        let upper = (cand + step).min(right_len);
+        let offset = right[cand + 1..upper].partition_point(|r| r <= x);
+        cand += offset;
+      }
+    }
+
+    curr = Some(cand);
+    if right[cand] == *x {
+      *out = cand;
+    } else {
+      *out = usize::MAX;
+    }
+  }
+}
+
+#[inline]
+fn joined_index_forward<T: PartialOrd>(left: &[T], right: &[T], result: &mut [usize]) {
+  let right_len = right.len();
+  let mut curr = 0usize;
+
+  for (x, out) in left.iter().zip(result.iter_mut()) {
+    if x.partial_cmp(x).is_none() {
+      *out = usize::MAX;
+      continue;
+    }
+
+    if curr >= right_len {
+      *out = usize::MAX;
+      continue;
+    }
+
+    if right[curr] >= *x {
+      *out = curr;
+      continue;
+    }
+
+    if curr + 1 >= right_len {
+      curr = right_len;
+      *out = usize::MAX;
+      continue;
+    }
+    if right[curr + 1] >= *x {
+      curr += 1;
+      *out = curr;
+      continue;
+    }
+
+    if curr + 2 >= right_len {
+      curr = right_len;
+      *out = usize::MAX;
+      continue;
+    }
+    if right[curr + 2] >= *x {
+      curr += 2;
+      *out = curr;
+      continue;
+    }
+
+    let mut step = 4usize;
+    curr += 2;
+    while curr + step < right_len && right[curr + step] < *x {
+      curr += step;
+      step = step.saturating_mul(2);
+    }
+
+    let upper = (curr + step).min(right_len);
+    let offset = right[curr + 1..upper].partition_point(|r| r < x);
+    let found = curr + 1 + offset;
+
+    if found < right_len && right[found] >= *x {
+      curr = found;
+      *out = found;
+    } else {
+      curr = right_len;
+      *out = usize::MAX;
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test_joined_index_empty() {
+    let mut res = Vec::new();
+    joined_index::<f64>(&[], &[1.0, 2.0], FillMethod::Backward, &mut res);
+    assert_eq!(res, Vec::<usize>::new());
+
+    joined_index::<f64>(&[1.0, 2.0], &[], FillMethod::Backward, &mut res);
+    assert_eq!(res, vec![usize::MAX, usize::MAX]);
+  }
+
+  #[test]
+  fn test_joined_index_exact() {
+    let left = vec![1.0, 2.0, 2.5, 3.0, 4.0];
+    let right = vec![1.0, 2.0, 3.0];
+    let mut res = Vec::new();
+    joined_index(&left, &right, FillMethod::Zero, &mut res);
+    assert_eq!(res, vec![0, 1, usize::MAX, 2, usize::MAX]);
+
+    joined_index(&left, &right, FillMethod::Nan, &mut res);
+    assert_eq!(res, vec![0, 1, usize::MAX, 2, usize::MAX]);
+  }
+
+  #[test]
+  fn test_joined_index_backward() {
+    let left = vec![0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5];
+    let right = vec![1.0, 2.0, 3.0];
+    let mut res = Vec::new();
+    joined_index(&left, &right, FillMethod::Backward, &mut res);
+    assert_eq!(res, vec![usize::MAX, 0, 0, 1, 1, 2, 2]);
+  }
+
+  #[test]
+  fn test_joined_index_forward() {
+    let left = vec![0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5];
+    let right = vec![1.0, 2.0, 3.0];
+    let mut res = Vec::new();
+    joined_index(&left, &right, FillMethod::Forward, &mut res);
+    assert_eq!(res, vec![0, 0, 1, 1, 2, 2, usize::MAX]);
+  }
+
+  #[test]
+  fn test_joined_index_duplicates() {
+    let left = vec![2.0];
+    let right = vec![1.0, 2.0, 2.0, 2.0, 3.0];
+    let mut res = Vec::new();
+
+    // Backward chooses the last element <= 2.0 -> index 3
+    joined_index(&left, &right, FillMethod::Backward, &mut res);
+    assert_eq!(res, vec![3]);
+
+    // Forward chooses the first element >= 2.0 -> index 1
+    joined_index(&left, &right, FillMethod::Forward, &mut res);
+    assert_eq!(res, vec![1]);
+
+    // Exact matches the last element == 2.0 -> index 3
+    joined_index(&left, &right, FillMethod::Zero, &mut res);
+    assert_eq!(res, vec![3]);
+  }
+
+  #[test]
+  fn test_joined_index_nan() {
+    let left = vec![1.0, f64::NAN, 2.0];
+    let right = vec![1.0, 2.0];
+    let mut res = Vec::new();
+
+    joined_index(&left, &right, FillMethod::Backward, &mut res);
+    assert_eq!(res, vec![0, usize::MAX, 1]);
+
+    joined_index(&left, &right, FillMethod::Forward, &mut res);
+    assert_eq!(res, vec![0, usize::MAX, 1]);
+  }
+
+  #[test]
+  fn test_joined_index_stress_equivalence() {
+    // Stress test comparing against naive binary search
+    let left: Vec<i64> = (0..5000).map(|x| x * 3).collect();
+    let right: Vec<i64> = (0..10000).map(|x| x * 2).collect();
+
+    let mut res_backward = Vec::new();
+    joined_index(&left, &right, FillMethod::Backward, &mut res_backward);
+
+    for (i, &x) in left.iter().enumerate() {
+      let idx = right.partition_point(|&r| r <= x);
+      let expected = if idx > 0 { idx - 1 } else { usize::MAX };
+      assert_eq!(res_backward[i], expected, "mismatch at left[{}]={}", i, x);
+    }
+
+    let mut res_forward = Vec::new();
+    joined_index(&left, &right, FillMethod::Forward, &mut res_forward);
+
+    for (i, &x) in left.iter().enumerate() {
+      let idx = right.partition_point(|&r| r < x);
+      let expected = if idx < right.len() { idx } else { usize::MAX };
+      assert_eq!(res_forward[i], expected, "mismatch at left[{}]={}", i, x);
+    }
+
+    let mut res_exact = Vec::new();
+    joined_index(&left, &right, FillMethod::Zero, &mut res_exact);
+
+    for (i, &x) in left.iter().enumerate() {
+      let idx = right.partition_point(|&r| r <= x);
+      let expected = if idx > 0 && right[idx - 1] == x {
+        idx - 1
+      } else {
+        usize::MAX
+      };
+      assert_eq!(res_exact[i], expected, "mismatch at left[{}]={}", i, x);
+    }
+  }
+
+  #[test]
+  fn test_joined_index_large_random_comparison() {
+    use std::time::Instant;
+
+    // Pseudo-random generator without external deps (LCG)
+    let mut rng = 123456789u64;
+    let mut rand = || {
+      rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1);
+      (rng >> 33) as i64
+    };
+
+    let n = 50_000;
+    let m = 100_000;
+
+    let mut left = Vec::with_capacity(n);
+    let mut cur = 0i64;
+    for _ in 0..n {
+      cur += (rand().abs() % 10) + 1;
+      left.push(cur);
+    }
+
+    let mut right = Vec::with_capacity(m);
+    cur = 0;
+    for _ in 0..m {
+      cur += (rand().abs() % 5) + 1;
+      right.push(cur);
+    }
+
+    let t0 = Instant::now();
+    let mut res_backward = Vec::new();
+    joined_index(&left, &right, FillMethod::Backward, &mut res_backward);
+    let elapsed = t0.elapsed();
+    println!("joined_index backward 50k x 100k elapsed: {:?}", elapsed);
+
+    for (i, &x) in left.iter().enumerate() {
+      let idx = right.partition_point(|&r| r <= x);
+      let expected = if idx > 0 { idx - 1 } else { usize::MAX };
+      assert_eq!(res_backward[i], expected);
+    }
+
+    let mut res_forward = Vec::new();
+    joined_index(&left, &right, FillMethod::Forward, &mut res_forward);
+    for (i, &x) in left.iter().enumerate() {
+      let idx = right.partition_point(|&r| r < x);
+      let expected = if idx < right.len() { idx } else { usize::MAX };
+      assert_eq!(res_forward[i], expected);
+    }
+  }
+}

{py_alpha_lib-0.3.1 → py_alpha_lib-0.3.3}/alpha-algo/src/lib.rs

@@ -1,6 +1,8 @@
 mod algo;
+mod join;
 
 pub use algo::*;
+pub use join::*;
 
 // #[cfg(feature = "py-binding")]
 // pub mod py_bindings;

{py_alpha_lib-0.3.1 → py_alpha_lib-0.3.3}/py-binding/Cargo.toml

@@ -12,7 +12,7 @@ crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]
-pyo3 = { workspace = true, features = ["abi3"] }
+pyo3 = { workspace = true, features = ["abi3-py312", "abi3t-py315"] }
 pyo3-log.workspace = true
 thiserror.workspace = true
 numpy.workspace = true

py_alpha_lib-0.3.3/py-binding/tests/rank.py

@@ -0,0 +1,54 @@
+import pandas as pd
+import numpy as np
+import alpha
+
+
+df = pd.DataFrame(
+  data={
+    "Animal": ["cat", "penguin", "dog", "spider", "snake"],
+    "Number_legs": [4, 2, 4, 8, 0],
+  }
+)
+
+def test_log_delta_rank_chain_panics():
+  """模拟修复前 alpha_002 的 LOG→DELTA(2)→RANK 链路即复现线上 panic"""
+  rng = np.random.default_rng(17)
+  n = 32
+  # t=4 目标截面（已验证稳定触发 Rust total-order 校验 panic 的 recipe）
+  target = rng.normal(size=n)
+  pos = rng.permutation(n)
+  nn = max(1, int(n * rng.uniform(0.1, 0.3)))
+  target[pos[:nn]] = np.nan
+  target[pos[nn % n]] = np.inf
+  target[pos[(nn + 1) % n]] = -np.inf
+  # 反推成交量，使 delta(log(vol),2) 在 t=4 的截面 == target
+  vol = np.full((n, 6), 1000.0)
+  nan_m = np.isnan(target)
+  posinf_m = np.isposinf(target)
+  neginf_m = np.isneginf(target)
+  vol[nan_m, 2] = np.nan               # 停牌 → delta=NaN
+  vol[posinf_m, 2] = 0.0               # LOG(0)=-inf → delta=+inf
+  vol[neginf_m, 4] = 0.0               # delta=-inf
+  fin_m = ~(nan_m | posinf_m | neginf_m)
+  vol[fin_m, 4] = 1000.0 * np.exp(target[fin_m])  # delta=target
+  # 算子链路：LOG → DELTA(2) → 截面 RANK（与 ctx.LOG/ctx.DELTA 同语义）
+  with np.errstate(divide='ignore', invalid='ignore'):
+    log_vol = np.log(vol)
+  delta = log_vol[:, 2:] - log_vol[:, :-2]
+  # t=4 截面（NaN+±inf 混排）；列切片为非连续视图，须连续化（绑定层提取要求 contiguous，
+  # 否则抛 ValueError "failed to get slice"）
+  cross = np.ascontiguousarray(delta[:, 2])
+  alpha.set_ctx(groups=n)
+  print(len(cross), n)
+  r = np.empty_like(cross)
+  print(alpha.CC_RANK(cross))
+
+
+alpha.set_ctx(groups=5)
+print(alpha.RANK(df["Number_legs"].to_numpy().astype(np.float64), 1))
+print(df["Number_legs"].rank(pct=True).to_numpy().astype(np.float64))
+
+alpha.set_ctx(groups=3)
+print(alpha.CC_RANK(np.array([3.0, np.nan, 1.0, np.inf, 4.0, -np.inf]*50)))
+
+test_log_delta_rank_chain_panics()

{py_alpha_lib-0.3.1 → py_alpha_lib-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "py-alpha-lib"
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",

py_alpha_lib-0.3.1/py-binding/tests/rank.py

@@ -1,19 +0,0 @@
-import pandas as pd
-import numpy as np
-import alpha
-
-
-df = pd.DataFrame(
-  data={
-    "Animal": ["cat", "penguin", "dog", "spider", "snake"],
-    "Number_legs": [4, 2, 4, 8, 0],
-  }
-)
-
-
-alpha.set_ctx(groups=5)
-print(alpha.RANK(df["Number_legs"].to_numpy().astype(np.float64), 1))
-print(df["Number_legs"].rank(pct=True).to_numpy().astype(np.float64))
-
-alpha.set_ctx(groups=3)
-print(alpha.CC_RANK(np.array([3.0, np.nan, 1.0, np.inf, 4.0, -np.inf])))