py-alpha-lib 0.2.2__tar.gz → 0.2.4__tar.gz

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # ChangeLog
 
+
+## [0.2.4] - 2026-04-27
+
+### Added
+
+- ALPHA: calculate alpha for a strategy
+- BETA: calculate beta for a strategy
+- SHARPE: calculate sharpe ratio for a strategy
+- MAX_DRAWDOWN: calculate max drawdown of a series
+
+
+## [0.2.3] - 2026-04-13
+
+### Added
+
+- ExecContext: TS_QUANTILE, SLOPE, INTERCEPT, DMA, SUMBARS, BARSLAST, BARSSINCE, BINS, FRET, RCROSS, RLONGCROSS
+
 ## [0.2.2] - 2026-04-11
 
 ### Added

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/Cargo.lock

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

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "alpha"
-version = "0.2.2"
+version = "0.2.4"
 edition = "2024"
 authors = ["ElseJJ"]
 readme = "README.md"
@@ -9,6 +9,7 @@ readme = "README.md"
 [lib]
 name = "alpha"
 crate-type = ["cdylib", "rlib"]
+doctest = false
 
 [dependencies]
 pyo3 = { version = "0.28", features = ["abi3"] }

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-alpha-lib
-Version: 0.2.2
+Version: 0.2.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -172,9 +172,11 @@ Naming Rules:
 
 | Name | Description |
 |---|---|
+| ALPHA | Rolling Jensen's Alpha of asset returns against benchmark returns. |
 | BACKFILL | Forward-fill NaN values with the last valid observation |
 | BARSLAST | Calculate number of bars since last condition true |
 | BARSSINCE | Calculate number of bars since first condition true |
+| BETA | Rolling Beta coefficient of asset returns against benchmark returns. |
 | BINS | Discretize the input into n bins, the ctx.groups() is the number of groups |
 | CC_RANK | Calculate rank percentage cross group dimension, the ctx.groups() is the number of groups Same value are averaged |
 | CC_ZSCORE | Calculate cross-sectional Z-Score across groups at each time step |
@@ -199,6 +201,7 @@ Naming Rules:
 | LONGCROSS | For 2 arrays A and B, return true if previous N periods A < B, Current A >= B |
 | LWMA | Linear Weighted Moving Average |
 | MA | Simple Moving Average, also known as arithmetic moving average |
+| MAX_DRAWDOWN | Rolling Maximum Drawdown. |
 | MIN_MAX_DIFF | Calculate rolling min-max difference (range) over a moving window |
 | MOMENT | Calculate rolling k-th central moment over a moving window |
 | NEUTRALIZE | Neutralize the effect of a categorical variable on a numeric variable |
@@ -212,6 +215,7 @@ Naming Rules:
 | RLONGCROSS | For 2 arrays A and B, return true if previous N periods A > B, Current A <= B |
 | SCAN_ADD | Conditional cumulative add: r[t] = r[t-1] + (cond[t] ? input[t] : 0) |
 | SCAN_MUL | Conditional cumulative multiply: r[t] = r[t-1] * (cond[t] ? input[t] : 1) |
+| SHARPE | Rolling Sharpe Ratio of returns. |
 | SKEWNESS | Calculate rolling sample Skewness over a moving window |
 | SLOPE | Linear Regression Slope |
 | SMA | Exponential Moving Average (variant of well-known EMA) weight = m / n |

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/README.md

@@ -157,9 +157,11 @@ Naming Rules:
 
 | Name | Description |
 |---|---|
+| ALPHA | Rolling Jensen's Alpha of asset returns against benchmark returns. |
 | BACKFILL | Forward-fill NaN values with the last valid observation |
 | BARSLAST | Calculate number of bars since last condition true |
 | BARSSINCE | Calculate number of bars since first condition true |
+| BETA | Rolling Beta coefficient of asset returns against benchmark returns. |
 | BINS | Discretize the input into n bins, the ctx.groups() is the number of groups |
 | CC_RANK | Calculate rank percentage cross group dimension, the ctx.groups() is the number of groups Same value are averaged |
 | CC_ZSCORE | Calculate cross-sectional Z-Score across groups at each time step |
@@ -184,6 +186,7 @@ Naming Rules:
 | LONGCROSS | For 2 arrays A and B, return true if previous N periods A < B, Current A >= B |
 | LWMA | Linear Weighted Moving Average |
 | MA | Simple Moving Average, also known as arithmetic moving average |
+| MAX_DRAWDOWN | Rolling Maximum Drawdown. |
 | MIN_MAX_DIFF | Calculate rolling min-max difference (range) over a moving window |
 | MOMENT | Calculate rolling k-th central moment over a moving window |
 | NEUTRALIZE | Neutralize the effect of a categorical variable on a numeric variable |
@@ -197,6 +200,7 @@ Naming Rules:
 | RLONGCROSS | For 2 arrays A and B, return true if previous N periods A > B, Current A <= B |
 | SCAN_ADD | Conditional cumulative add: r[t] = r[t-1] + (cond[t] ? input[t] : 0) |
 | SCAN_MUL | Conditional cumulative multiply: r[t] = r[t-1] * (cond[t] ? input[t] : 1) |
+| SHARPE | Rolling Sharpe Ratio of returns. |
 | SKEWNESS | Calculate rolling sample Skewness over a moving window |
 | SLOPE | Linear Regression Slope |
 | SMA | Exponential Moving Average (variant of well-known EMA) weight = m / n |

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/python/alpha/algo/algo_gen.py

@@ -18,6 +18,30 @@ def _to_bool(a):
     return a
   return a.astype(bool)
 
+def ALPHA(
+  input: np.ndarray | list[np.ndarray], benchmark: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Rolling Jensen's Alpha of asset returns against benchmark returns.
+  
+  Alpha = mean(input) - Beta * mean(benchmark)
+  Measures excess return of an asset relative to its expected return given beta.
+  
+  Ref: https://en.wikipedia.org/wiki/Jensen%27s_alpha
+  """
+  if isinstance(input, list) and isinstance(benchmark, list):
+    input = [_to_f64(x) for x in input]
+    benchmark = [_to_f64(x) for x in benchmark]
+    r = [np.empty_like(x) for x in input]
+    _algo.alpha(r, input, benchmark, periods)
+    return r
+  else:
+    input = _to_f64(input)
+    benchmark = _to_f64(benchmark)
+    r = np.empty_like(input)
+    _algo.alpha(r, input, benchmark, periods)
+    return r
+
 def BACKFILL(
   input: np.ndarray | list[np.ndarray]
 ) -> np.ndarray | list[np.ndarray]:
@@ -76,6 +100,30 @@ def BARSSINCE(
     _algo.barssince(r, input)
     return r
 
+def BETA(
+  input: np.ndarray | list[np.ndarray], benchmark: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Rolling Beta coefficient of asset returns against benchmark returns.
+  
+  Beta = Covariance(input, benchmark) / Variance(benchmark)
+  Measures systematic risk of an asset relative to the market.
+  
+  Ref: https://en.wikipedia.org/wiki/Beta_(finance)
+  """
+  if isinstance(input, list) and isinstance(benchmark, list):
+    input = [_to_f64(x) for x in input]
+    benchmark = [_to_f64(x) for x in benchmark]
+    r = [np.empty_like(x) for x in input]
+    _algo.beta(r, input, benchmark, periods)
+    return r
+  else:
+    input = _to_f64(input)
+    benchmark = _to_f64(benchmark)
+    r = np.empty_like(input)
+    _algo.beta(r, input, benchmark, periods)
+    return r
+
 def BINS(
   input: np.ndarray | list[np.ndarray], bins: int
 ) -> np.ndarray | list[np.ndarray]:
@@ -542,6 +590,29 @@ def MA(
     _algo.ma(r, input, periods)
     return r
 
+def MAX_DRAWDOWN(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Rolling Maximum Drawdown.
+  
+  MaxDrawdown = minimum peak-to-trough decline within the rolling window.
+  Result is expressed as a negative return (e.g. -0.2 means 20% drawdown from peak).
+  Input should be a price or equity curve series.
+  
+  Ref: https://en.wikipedia.org/wiki/Drawdown_(economics)
+  """
+  if isinstance(input, list):
+    input = [_to_f64(x) for x in input]
+    r = [np.empty_like(x) for x in input]
+    _algo.max_drawdown(r, input, periods)
+    return r
+  else:
+    input = _to_f64(input)
+    r = np.empty_like(input)
+    _algo.max_drawdown(r, input, periods)
+    return r
+
 def MIN_MAX_DIFF(
   input: np.ndarray | list[np.ndarray], periods: int
 ) -> np.ndarray | list[np.ndarray]:
@@ -811,6 +882,28 @@ def SCAN_MUL(
     _algo.scan_mul(r, input, condition)
     return r
 
+def SHARPE(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Rolling Sharpe Ratio of returns.
+  
+  Sharpe = mean(returns) / stddev(returns)
+  Measures risk-adjusted return over a rolling window.
+  
+  Ref: https://en.wikipedia.org/wiki/Sharpe_ratio
+  """
+  if isinstance(input, list):
+    input = [_to_f64(x) for x in input]
+    r = [np.empty_like(x) for x in input]
+    _algo.sharpe(r, input, periods)
+    return r
+  else:
+    input = _to_f64(input)
+    r = np.empty_like(input)
+    _algo.sharpe(r, input, periods)
+    return r
+
 def SKEWNESS(
   input: np.ndarray | list[np.ndarray], periods: int
 ) -> np.ndarray | list[np.ndarray]:

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/python/alpha/algo.md

@@ -2,9 +2,11 @@ List of available functions with python type hints:
 
 the `np.ndarray` is `ndarray` type in `numpy` package
 
+- ALPHA(input: np.ndarray[float], benchmark: np.ndarray[float], periods: int): Rolling Jensen's Alpha of asset returns against benchmark returns.  Alpha = mean(input) - Beta * mean(benchmark) Measures excess return of an asset relative to its expected return given beta.
 - BACKFILL(input: np.ndarray[float]): Forward-fill NaN values with the last valid observation  Iterates forward through each group; if x[i] is NaN, copies the last valid value. Leading NaNs (before any valid value) remain NaN.
 - BARSLAST(input: np.ndarray[bool]): Calculate number of bars since last condition true
 - BARSSINCE(input: np.ndarray[bool]): Calculate number of bars since first condition true
+- BETA(input: np.ndarray[float], benchmark: np.ndarray[float], periods: int): Rolling Beta coefficient of asset returns against benchmark returns.  Beta = Covariance(input, benchmark) / Variance(benchmark) Measures systematic risk of an asset relative to the market.
 - BINS(input: np.ndarray[float], bins: int): Discretize the input into n bins, the ctx.groups() is the number of groups  Bins are 0-based index. Same value are assigned to the same bin.
 - CC_RANK(input: np.ndarray[float]): Calculate rank percentage cross group dimension, the ctx.groups() is the number of groups Same value are averaged
 - CC_ZSCORE(input: np.ndarray[float]): Calculate cross-sectional Z-Score across groups at each time step  Z-Score = (x - mean) / stddev, computed across all groups for each time position. NaN values are excluded from mean/stddev computation. NaN input produces NaN output.
@@ -29,6 +31,7 @@ the `np.ndarray` is `ndarray` type in `numpy` package
 - LONGCROSS(a: np.ndarray[float], b: np.ndarray[float], n: int): For 2 arrays A and B, return true if previous N periods A < B, Current A >= B
 - LWMA(input: np.ndarray[float], periods: int): Linear Weighted Moving Average  LWMA = SUM(Price * Weight) / SUM(Weight)
 - MA(input: np.ndarray[float], periods: int): Simple Moving Average, also known as arithmetic moving average
+- MAX_DRAWDOWN(input: np.ndarray[float], periods: int): Rolling Maximum Drawdown.  MaxDrawdown = minimum peak-to-trough decline within the rolling window. Result is expressed as a negative return (e.g. -0.2 means 20% drawdown from peak). Input should be a price or equity curve series.
 - MIN_MAX_DIFF(input: np.ndarray[float], periods: int): Calculate rolling min-max difference (range) over a moving window  TS_MIN_MAX_DIFF = TS_MAX(x, d) - TS_MIN(x, d) Single-pass using two monotonic deques for efficiency.
 - MOMENT(input: np.ndarray[float], periods: int, k: int): Calculate rolling k-th central moment over a moving window  MOMENT(x, d, k) = mean((x - mean)^k) over window of d periods. This is the raw (non-adjusted) sample moment. k=2 gives variance (population), k=3 gives raw third moment, etc.
 - NEUTRALIZE(category: np.ndarray[float], input: np.ndarray[float]): Neutralize the effect of a categorical variable on a numeric variable
@@ -42,6 +45,7 @@ the `np.ndarray` is `ndarray` type in `numpy` package
 - RLONGCROSS(a: np.ndarray[float], b: np.ndarray[float], n: int): For 2 arrays A and B, return true if previous N periods A > B, Current A <= B
 - SCAN_ADD(input: np.ndarray[float], condition: np.ndarray[bool]): Conditional cumulative add: r[t] = r[t-1] + (cond[t] ? input[t] : 0)  Used for SELF-referencing alpha expressions with additive accumulation. Serial within each stock, parallel across stocks via rayon.
 - SCAN_MUL(input: np.ndarray[float], condition: np.ndarray[bool]): Conditional cumulative multiply: r[t] = r[t-1] * (cond[t] ? input[t] : 1)  Used for SELF-referencing alpha expressions like GTJA #143. Serial within each stock, parallel across stocks via rayon.
+- SHARPE(input: np.ndarray[float], periods: int): Rolling Sharpe Ratio of returns.  Sharpe = mean(returns) / stddev(returns) Measures risk-adjusted return over a rolling window.
 - SKEWNESS(input: np.ndarray[float], periods: int): Calculate rolling sample Skewness over a moving window  Uses adjusted Fisher-Pearson formula (matches pandas): skew = n / ((n-1)(n-2)) * sum(((x-mean)/std)^3) Requires at least 3 valid values.
 - SLOPE(input: np.ndarray[float], periods: int): Linear Regression Slope  Calculates the slope of the linear regression line for a moving window.
 - SMA(input: np.ndarray[float], n: int, m: int): Exponential Moving Average (variant of well-known EMA) weight = m / n

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/python/alpha/context.py

@@ -249,6 +249,9 @@ class ExecContext:
     else:
       return alpha.SMA(a, int(args[0]), int(args[1]))
 
+  def DMA(self, a: np.ndarray, weight: float) -> np.ndarray:
+    return alpha.DMA(a, float(weight))
+
   # ── TS: Std Dev / Variance ─────────────────────────────────────────
   #   BRAIN: ts_std_dev    GTJA: STD               wq101: STDDEV
 
@@ -315,6 +318,11 @@ class ExecContext:
 
   TSRANK = TS_RANK  # gtja191
 
+  # ── TS: Quantile ────────────────────────────────────────────────────
+
+  def TS_QUANTILE(self, a: np.ndarray, w: int, q: float) -> np.ndarray:
+    return alpha.QUANTILE(a, int(w), q)
+
   # ── TS: Delay / Delta ──────────────────────────────────────────────
   #   BRAIN: ts_delay, ts_delta
   #   wq101: DELAY, DELTA
@@ -364,6 +372,14 @@ class ExecContext:
 
   REGRESI = TS_REGRESI  # gtja191
 
+  # ── TS: Slope / Intercept ───────────────────────────────────────
+
+  def SLOPE(self, a: np.ndarray, w: int) -> np.ndarray:
+    return alpha.SLOPE(a, int(w))
+
+  def INTERCEPT(self, a: np.ndarray, w: int) -> np.ndarray:
+    return alpha.INTERCEPT(a, int(w))
+
   # ── TS: Counting / Conditional ─────────────────────────────────────
   #   GTJA: COUNT, SUMIF
 
@@ -379,6 +395,17 @@ class ExecContext:
 
   SUMIF = TS_SUMIF  # gtja191
 
+  def SUMBARS(self, a: np.ndarray, amount: float) -> np.ndarray:
+    return alpha.SUMBARS(a, amount)
+
+  # ── TS: Bar Counting ──────────────────────────────────────────
+
+  def BARSLAST(self, cond: np.ndarray) -> np.ndarray:
+    return alpha.BARSLAST(np.asarray(cond, dtype=bool))
+
+  def BARSSINCE(self, cond: np.ndarray) -> np.ndarray:
+    return alpha.BARSSINCE(np.asarray(cond, dtype=bool))
+
   # ── TS: Conditional Scan (SELF recursion) ───────────────────────────
   #   GTJA: SELF-referencing patterns
 
@@ -440,6 +467,16 @@ class ExecContext:
   def TS_MOMENT(self, a: np.ndarray, w: int, k: int = 2) -> np.ndarray:
     return alpha.MOMENT(a, int(w), int(k))
 
+  # ── TS: Binning ────────────────────────────────────────────────
+
+  def BINS(self, a: np.ndarray, n: int) -> np.ndarray:
+    return alpha.BINS(a, int(n))
+
+  # ── TS: Future Return ──────────────────────────────────────────
+
+  def FRET(self, open: np.ndarray, close: np.ndarray, is_calc: np.ndarray, delay: int, periods: int) -> np.ndarray:
+    return alpha.FRET(open, close, is_calc, int(delay), int(periods))
+
   # ── TS: Cross Detection ────────────────────────────────────────────
   #   AmiBroker/GTJA: CROSS, LONGCROSS
 
@@ -449,6 +486,12 @@ class ExecContext:
   def LONGCROSS(self, a: np.ndarray, b: np.ndarray, n: int) -> np.ndarray:
     return alpha.LONGCROSS(a, b, int(n))
 
+  def RCROSS(self, a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    return alpha.RCROSS(a, b)
+
+  def RLONGCROSS(self, a: np.ndarray, b: np.ndarray, n: int) -> np.ndarray:
+    return alpha.RLONGCROSS(a, b, int(n))
+
   # ====================================================================
   #  Cross-Sectional Operators (no prefix)
   #

{py_alpha_lib-0.2.2 → py_alpha_lib-0.2.4}/python/alpha/lang/to_python.py

@@ -119,7 +119,7 @@ class AlphaTransformer(Transformer):
     for arg in args:
       try:
         val = float(arg)
-        if '.' in arg and val == val:
+        if '.' in arg and val == arg:
           arg = str(round(val))
       except (ValueError, TypeError):
         pass

py_alpha_lib-0.2.4/src/algo/alpha.rs

@@ -0,0 +1,225 @@
+// Copyright 2026 MSD-RS Project LiJia
+// SPDX-License-Identifier: BSD-2-Clause
+
+use num_traits::Float;
+use rayon::prelude::*;
+
+use crate::algo::{Context, Error, is_normal};
+
+/// Rolling Jensen's Alpha of asset returns against benchmark returns.
+///
+/// Alpha = mean(input) - Beta * mean(benchmark)
+/// Measures excess return of an asset relative to its expected return given beta.
+///
+/// Ref: https://en.wikipedia.org/wiki/Jensen%27s_alpha
+///
+pub fn ta_alpha<NumT: Float + Send + Sync>(
+  ctx: &Context,
+  r: &mut [NumT],
+  input: &[NumT],
+  benchmark: &[NumT],
+  periods: usize,
+) -> Result<(), Error> {
+  if r.len() != input.len() || r.len() != benchmark.len() {
+    return Err(Error::LengthMismatch(r.len(), input.len()));
+  }
+
+  if periods < 2 {
+    return Err(Error::InvalidPeriod(format!(
+      "alpha requires periods >= 2, got {}",
+      periods
+    )));
+  }
+
+  r.par_chunks_mut(ctx.chunk_size(r.len()))
+    .zip(input.par_chunks(ctx.chunk_size(input.len())))
+    .zip(benchmark.par_chunks(ctx.chunk_size(benchmark.len())))
+    .for_each(|((r, x), y)| {
+      let start = ctx.start(r.len());
+      let end = ctx.end(r.len());
+      r.fill(NumT::nan());
+
+      if ctx.is_skip_nan() {
+        for i in start..end {
+          let mut sum_x = NumT::zero();
+          let mut sum_y = NumT::zero();
+          let mut sum_xy = NumT::zero();
+          let mut sum_y2 = NumT::zero();
+          let mut n = 0usize;
+          let mut gap = false;
+
+          let mut j = i;
+          loop {
+            if is_normal(&x[j]) && is_normal(&y[j]) {
+              sum_x = sum_x + x[j];
+              sum_y = sum_y + y[j];
+              sum_xy = sum_xy + x[j] * y[j];
+              sum_y2 = sum_y2 + y[j] * y[j];
+              n += 1;
+              if n == periods {
+                break;
+              }
+            } else {
+              gap = true;
+            }
+            if j == 0 {
+              break;
+            }
+            j -= 1;
+          }
+
+          if !is_normal(&x[i]) || !is_normal(&y[i]) {
+            continue;
+          }
+
+          if ctx.is_strictly_cycle() {
+            if n != periods || gap || (i - j + 1) != periods {
+              continue;
+            }
+          }
+
+          if n < 2 {
+            continue;
+          }
+
+          let nf = NumT::from(n).unwrap();
+          let denom = nf * sum_y2 - sum_y * sum_y;
+          if denom == NumT::zero() {
+            continue;
+          }
+          let beta = (nf * sum_xy - sum_x * sum_y) / denom;
+          r[i] = (sum_x - beta * sum_y) / nf;
+        }
+      } else {
+        let mut sum_x = NumT::zero();
+        let mut sum_y = NumT::zero();
+        let mut sum_xy = NumT::zero();
+        let mut sum_y2 = NumT::zero();
+        let mut nan_in_window = 0usize;
+
+        let pre_start = if start >= periods { start - periods } else { 0 };
+        for k in pre_start..start {
+          if is_normal(&x[k]) && is_normal(&y[k]) {
+            sum_x = sum_x + x[k];
+            sum_y = sum_y + y[k];
+            sum_xy = sum_xy + x[k] * y[k];
+            sum_y2 = sum_y2 + y[k] * y[k];
+          } else {
+            nan_in_window += 1;
+          }
+        }
+
+        for i in start..end {
+          if is_normal(&x[i]) && is_normal(&y[i]) {
+            sum_x = sum_x + x[i];
+            sum_y = sum_y + y[i];
+            sum_xy = sum_xy + x[i] * y[i];
+            sum_y2 = sum_y2 + y[i] * y[i];
+          } else {
+            nan_in_window += 1;
+          }
+
+          if i >= periods {
+            let old_x = x[i - periods];
+            let old_y = y[i - periods];
+            if is_normal(&old_x) && is_normal(&old_y) {
+              sum_x = sum_x - old_x;
+              sum_y = sum_y - old_y;
+              sum_xy = sum_xy - old_x * old_y;
+              sum_y2 = sum_y2 - old_y * old_y;
+            } else {
+              nan_in_window -= 1;
+            }
+          }
+
+          if !is_normal(&x[i]) || !is_normal(&y[i]) {
+            continue;
+          }
+
+          if ctx.is_strictly_cycle() && i < periods - 1 {
+            continue;
+          }
+
+          if nan_in_window > 0 {
+            continue;
+          }
+
+          let n = if i < periods { i + 1 } else { periods };
+          if n < 2 {
+            continue;
+          }
+          let nf = NumT::from(n).unwrap();
+          let denom = nf * sum_y2 - sum_y * sum_y;
+          if denom == NumT::zero() {
+            continue;
+          }
+          let beta = (nf * sum_xy - sum_x * sum_y) / denom;
+          r[i] = (sum_x - beta * sum_y) / nf;
+        }
+      }
+    });
+
+  Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::algo::{
+    assert_vec_eq_nan,
+    context::{FLAG_SKIP_NAN, FLAG_STRICTLY_CYCLE},
+  };
+
+  use super::*;
+
+  #[test]
+  fn test_ta_alpha_basic() {
+    // y = 2x, Alpha should be 0 (returns proportional, no excess return)
+    let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+    let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
+    let periods = 3;
+    let mut r = vec![0.0; x.len()];
+    let ctx = Context::new(0, 0, 0);
+    ta_alpha(&ctx, &mut r, &x, &y, periods).unwrap();
+    assert_vec_eq_nan(&r, &vec![f64::NAN, 0.0, 0.0, 0.0, 0.0]);
+  }
+
+  #[test]
+  fn test_ta_alpha_positive() {
+    // x has extra 1.0 above y*0.5
+    let x = vec![2.0, 3.0, 4.0, 5.0, 6.0];   // y*0.5 + 1
+    let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];   // y=2*(x-1)
+    let periods = 3;
+    let mut r = vec![0.0; x.len()];
+    let ctx = Context::new(0, 0, 0);
+    ta_alpha(&ctx, &mut r, &x, &y, periods).unwrap();
+    // Alpha should be 1.0
+    assert_vec_eq_nan(&r, &vec![f64::NAN, 1.0, 1.0, 1.0, 1.0]);
+  }
+
+  #[test]
+  fn test_ta_alpha_strictly_cycle() {
+    let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+    let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
+    let periods = 3;
+    let mut r = vec![0.0; x.len()];
+    let ctx = Context::new(0, 0, FLAG_STRICTLY_CYCLE);
+    ta_alpha(&ctx, &mut r, &x, &y, periods).unwrap();
+    assert_vec_eq_nan(&r, &vec![f64::NAN, f64::NAN, 0.0, 0.0, 0.0]);
+  }
+
+  #[test]
+  fn test_ta_alpha_skip_nan() {
+    let x = vec![1.0, f64::NAN, 3.0, 4.0, 5.0];
+    let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
+    let periods = 3;
+    let mut r = vec![0.0; x.len()];
+
+    let ctx = Context::new(0, 0, FLAG_SKIP_NAN);
+    ta_alpha(&ctx, &mut r, &x, &y, periods).unwrap();
+    // i=0: n=1 → NaN
+    // i=1: NaN → skip
+    // i=2: pairs (0,0) and (2,2) valid, n=2 → Alpha=0
+    // i=3: 3 valid pairs → Alpha=0
+    assert_vec_eq_nan(&r, &vec![f64::NAN, f64::NAN, 0.0, 0.0, 0.0]);
+  }
+}