py-alpha-lib 0.1.1__tar.gz → 0.1.2__tar.gz

py_alpha_lib-0.1.2/CHANGELOG.md

@@ -0,0 +1,24 @@
+# ChangeLog
+
+
+## [0.1.2] - 2026-02-04
+
+### Added
+
+- TS_CORR @zhaojun6969
+
+## [0.1.1] - 2026-02-02
+
+### Added
+
+- BINS @zhaojun6969
+- FRET @zhaojun6969 
+- INTERCEPT @zhaojun6969
+- NEUTRALIZE @zhaojun6969
+- REGBETA
+- REGRESI
+- SUMIF
+
+See [algo.md](python/alpha/algo.md) for details.
+
+Thanks @zhaojun6969, our first contributor!

{py_alpha_lib-0.1.1 → py_alpha_lib-0.1.2}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "alpha"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "log",

{py_alpha_lib-0.1.1 → py_alpha_lib-0.1.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "alpha"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 authors = ["ElseJJ"]
 readme = "README.md"

{py_alpha_lib-0.1.1 → py_alpha_lib-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-alpha-lib
-Version: 0.1.1
+Version: 0.1.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{py_alpha_lib-0.1.1 → py_alpha_lib-0.1.2}/python/alpha/algo/algo_gen.py

@@ -586,6 +586,23 @@ def SUMIF(
     _algo.sumif(r, input, condition, periods)
     return r
 
+def TS_CORR(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Time Series Correlation
+  
+  Calculates the correlation coefficient between the input series and the time index.
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.ts_corr(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.ts_corr(r, input, periods)
+    return r
+
 def TS_RANK(
   input: np.ndarray | list[np.ndarray], periods: int
 ) -> np.ndarray | list[np.ndarray]:

{py_alpha_lib-0.1.1 → py_alpha_lib-0.1.2}/python/alpha/algo.md

@@ -34,5 +34,6 @@ the `np.ndarray` is `ndarray` type in `numpy` package
 - SUM(input: np.ndarray[float], periods: int): Calculate sum of values in preceding `periods` window  If periods is 0, it calculates the cumulative sum from the first valid value.
 - SUMBARS(input: np.ndarray[float], amount: float): Calculate number of periods (bars) backwards until the sum of values is greater than or equal to `amount`
 - SUMIF(input: np.ndarray[float], condition: np.ndarray[bool], periods: int): Calculate sum of values in preceding `periods` window where `condition` is true
+- TS_CORR(input: np.ndarray[float], periods: int): Time Series Correlation  Calculates the correlation coefficient between the input series and the time index.
 - TS_RANK(input: np.ndarray[float], periods: int): Calculate rank in a sliding window with size `periods`
 - VAR(input: np.ndarray[float], periods: int): Calculate Variance over a moving window  Variance = (SumSq - (Sum^2)/N) / (N - 1)

{py_alpha_lib-0.1.1 → py_alpha_lib-0.1.2}/src/algo/slope.rs

@@ -6,7 +6,7 @@ use rayon::prelude::*;
 
 use crate::algo::{Context, Error, is_normal, skip_nan_window::SkipNanWindow};
 
-fn ta_linear_reg_core<NumT, F>(
+fn linear_reg_core<NumT, F>(
   ctx: &Context,
   r: &mut [NumT],
   input: &[NumT],
@@ -15,7 +15,7 @@ fn ta_linear_reg_core<NumT, F>(
 ) -> Result<(), Error>
 where
   NumT: Float + Send + Sync,
-  F: Fn(NumT, NumT, NumT, NumT, NumT) -> NumT + Sync + Send + Copy,
+  F: Fn(NumT, NumT, NumT, NumT, NumT, NumT) -> NumT + Sync + Send + Copy,
 {
   if r.len() != input.len() {
     return Err(Error::LengthMismatch(r.len(), input.len()));
@@ -35,6 +35,7 @@ where
       if ctx.is_skip_nan() {
         let iter = SkipNanWindow::new(x, periods, start);
         let mut sum_y = NumT::zero();
+        let mut sum_y2 = NumT::zero();
         let mut sum_xy_1based = NumT::zero();
         let mut count = 0;
 
@@ -44,6 +45,7 @@ where
             if old.is_normal() {
                sum_xy_1based = sum_xy_1based - sum_y;
                sum_y = sum_y - old;
+               sum_y2 = sum_y2 - old * old;
                count -= 1;
             }
           }
@@ -53,6 +55,7 @@ where
             count += 1;
             let n_t = NumT::from(count).unwrap();
             sum_y = sum_y + val;
+            sum_y2 = sum_y2 + val * val;
             sum_xy_1based = sum_xy_1based + n_t * val;
           }
 
@@ -74,11 +77,12 @@ where
              
              let sum_xy = sum_xy_1based - sum_y;
              
-             r[i.end] = op(n, sum_x, sum_x2, sum_y, sum_xy);
+             r[i.end] = op(n, sum_x, sum_x2, sum_y, sum_y2, sum_xy);
           }
         }
       } else {
         let mut sum_y = NumT::zero();
+        let mut sum_y2 = NumT::zero();
         let mut sum_xy_1based = NumT::zero();
         let mut count = 0;
         let mut nan_in_window = 0;
@@ -90,6 +94,7 @@ where
                  count += 1;
                  let n_t = NumT::from(count).unwrap();
                  sum_y = sum_y + val;
+                 sum_y2 = sum_y2 + val * val;
                  sum_xy_1based = sum_xy_1based + n_t * val;
              } else {
                  count += 1;
@@ -109,6 +114,7 @@ where
            
            if c.is_normal() {
                sum_y = sum_y + *c;
+               sum_y2 = sum_y2 + *c * *c;
                sum_xy_1based = sum_xy_1based + n_t * *c;
            } else {
                nan_in_window += 1;
@@ -121,6 +127,7 @@ where
               sum_xy_1based = sum_xy_1based - sum_y;
               if old.is_normal() {
                  sum_y = sum_y - old;
+                 sum_y2 = sum_y2 - old * old;
               } else {
                  nan_in_window -= 1;
               }
@@ -139,7 +146,7 @@ where
                    
                    let sum_xy = sum_xy_1based - sum_y;
                    
-                   *r = op(n_val, sum_x, sum_x2, sum_y, sum_xy);
+                   *r = op(n_val, sum_x, sum_x2, sum_y, sum_y2, sum_xy);
                }
            } else {
                *r = NumT::nan();
@@ -160,7 +167,7 @@ pub fn ta_slope<NumT: Float + Send + Sync>(
   input: &[NumT],
   periods: usize,
 ) -> Result<(), Error> {
-  ta_linear_reg_core(ctx, r, input, periods, |n, sum_x, sum_x2, sum_y, sum_xy| {
+  linear_reg_core(ctx, r, input, periods, |n, sum_x, sum_x2, sum_y, _sum_y2, sum_xy| {
     // slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x^2)
     let numerator = n * sum_xy - sum_x * sum_y;
     let denominator = n * sum_x2 - sum_x * sum_x;
@@ -183,7 +190,7 @@ pub fn ta_intercept<NumT: Float + Send + Sync>(
   input: &[NumT],
   periods: usize,
 ) -> Result<(), Error> {
-  ta_linear_reg_core(ctx, r, input, periods, |n, sum_x, sum_x2, sum_y, sum_xy| {
+  linear_reg_core(ctx, r, input, periods, |n, sum_x, sum_x2, sum_y, _sum_y2, sum_xy| {
      // Intercept: b = (sum_y * sum_x2 - sum_x * sum_xy) / (n * sum_x2 - sum_x^2)
      let numerator = sum_y * sum_x2 - sum_x * sum_xy;
      let denominator = n * sum_x2 - sum_x * sum_x;
@@ -196,6 +203,31 @@ pub fn ta_intercept<NumT: Float + Send + Sync>(
   })
 }
 
+/// Time Series Correlation
+///
+/// Calculates the correlation coefficient between the input series and the time index.
+///
+pub fn ta_ts_corr<NumT: Float + Send + Sync>(
+  ctx: &Context,
+  r: &mut [NumT],
+  input: &[NumT],
+  periods: usize,
+) -> Result<(), Error> {
+  linear_reg_core(ctx, r, input, periods, |n, sum_x, sum_x2, sum_y, sum_y2, sum_xy| {
+      // r = (n * sum_xy - sum_x * sum_y) / sqrt( (n * sum_x2 - sum_x^2) * (n * sum_y2 - sum_y^2) )
+      let numerator = n * sum_xy - sum_x * sum_y;
+      let var_x = n * sum_x2 - sum_x * sum_x;
+      let var_y = n * sum_y2 - sum_y * sum_y;
+      
+      let denominator_sq = var_x * var_y;
+      if denominator_sq > NumT::zero() {
+         numerator / denominator_sq.sqrt()
+      } else {
+         NumT::nan()
+      }
+  })
+}
+
 #[cfg(test)]
 mod tests {
   use crate::algo::{
@@ -281,4 +313,16 @@ mod tests {
     
     assert_vec_eq_nan(&r, &vec![f64::NAN, f64::NAN, 1.0, 3.0, 5.0]);
   }
+
+  #[test]
+  fn test_ta_ts_corr() {
+    let input = vec![1.0, 2.0, 3.0, 3.0, 2.0, 1.0];
+    let periods = 3;
+    let mut r = vec![0.0; input.len()];
+    let ctx = Context::new(0, 0, 0);
+    ta_ts_corr(&ctx, &mut r, &input, periods).unwrap();
+    
+    let expected = vec![f64::NAN, f64::NAN, 1.0, 0.8660254037844386, -0.8660254037844386, -1.0];
+    assert_vec_eq_nan(&r, &expected);
+  }
 }

{py_alpha_lib-0.1.1 → py_alpha_lib-0.1.2}/tests/usage.py

@@ -97,3 +97,10 @@ print("NEUTRALIZE:", result_neutralize)
 df = df.assign(neutralize=result_neutralize)
 print(df.pivot_table(index="time", columns="stock", values="neutralize"))
 
+# Calculate Time Series Correlation
+al.set_ctx(flags=0, groups=1)
+data_corr = np.array([1, 2, 3, 4, 5, 5, 4, 3, 2, 1], dtype=np.float64)
+# First 5: Correlation should be 1.0 (perfectly increasing)
+# Next part: decreasing.
+result_corr = al.TS_CORR(data_corr, 5)
+print("TS_CORR(5):", result_corr)

py_alpha_lib-0.1.1/CHANGELOG.md

@@ -1,15 +0,0 @@
-# ChangeLog
-
-## [0.1.1] - 2026-02-02
-
-### Added
-
-- BINS
-- FRET
-- INTERCEPT
-- NEUTRALIZE
-- REGBETA
-- REGRESI
-- SUMIF
-
-See [algo.md](python/alpha/algo.md) for details.