py-alpha-lib 0.1.0__cp314-abi3-win_amd64.whl → 0.1.1__cp314-abi3-win_amd64.whl

alpha/__init__.py

@@ -1,3 +1,6 @@
+# Copyright 2026 MSD-RS Project LiJia
+# SPDX-License-Identifier: BSD-2-Clause
+
 from .algo import *
 from .lang import *
 

alpha/algo/__init__.py

@@ -1,3 +1,6 @@
+# Copyright 2026 MSD-RS Project LiJia
+# SPDX-License-Identifier: BSD-2-Clause
+
 from .algo import EMA
 from .algo_gen import *
 from ._algo import set_ctx

alpha/algo/algo.py

@@ -1,3 +1,6 @@
+# Copyright 2026 MSD-RS Project LiJia
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numpy as np
 from . import _algo
 

alpha/algo/algo_gen.py

@@ -1,3 +1,6 @@
+# Copyright 2026 MSD-RS Project LiJia
+# SPDX-License-Identifier: BSD-2-Clause
+
 # THIS FILE IS AUTO-GENERATED, DO NOT EDIT
 
 import numpy as np
@@ -41,6 +44,24 @@ def BARSSINCE(
     _algo.barssince(r, input)
     return r
 
+def BINS(
+  input: np.ndarray | list[np.ndarray], bins: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  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.
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.bins(r, input, bins)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.bins(r, input, bins)
+    return r
+
 def CORR(
   x: np.ndarray | list[np.ndarray], y: np.ndarray | list[np.ndarray], periods: int
 ) -> np.ndarray | list[np.ndarray]:
@@ -140,6 +161,33 @@ def DMA(
     _algo.dma(r, input, weight)
     return r
 
+def FRET(
+  open: np.ndarray | list[np.ndarray], close: np.ndarray | list[np.ndarray], is_calc: np.ndarray | list[np.ndarray], delay: int, periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Future Return
+  
+  Calculates the return from the open price of the delayed day (t+delay) to the close price of the future day (t+delay+periods-1).
+  Return = (Close[t+delay+periods-1] - Open[t+delay]) / Open[t+delay]
+  
+  If n=1, delay=1, it calculates (Close[t+1] - Open[t+1]) / Open[t+1].
+  If `is_calc[t+delay]` is 0, returns NaN.
+  """
+  if isinstance(open, list) and isinstance(close, list) and isinstance(is_calc, list):
+    r = [np.empty_like(x) for x in open]
+    open = [x.astype(float) for x in open]
+    close = [x.astype(float) for x in close]
+    is_calc = [x.astype(float) for x in is_calc]
+    _algo.fret(r, open, close, is_calc, delay, periods)
+    return r
+  else:
+    r = np.empty_like(open)
+    open = open.astype(float)
+    close = close.astype(float)
+    is_calc = is_calc.astype(float)
+    _algo.fret(r, open, close, is_calc, delay, periods)
+    return r
+
 def HHV(
   input: np.ndarray | list[np.ndarray], periods: int
 ) -> np.ndarray | list[np.ndarray]:
@@ -174,6 +222,23 @@ def HHVBARS(
     _algo.hhvbars(r, input, periods)
     return r
 
+def INTERCEPT(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Linear Regression Intercept
+  
+  Calculates the intercept of the linear regression line for a moving window.
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.intercept(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.intercept(r, input, periods)
+    return r
+
 def LLV(
   input: np.ndarray | list[np.ndarray], periods: int
 ) -> np.ndarray | list[np.ndarray]:
@@ -261,6 +326,25 @@ def MA(
     _algo.ma(r, input, periods)
     return r
 
+def NEUTRALIZE(
+  category: np.ndarray | list[np.ndarray], input: np.ndarray | list[np.ndarray]
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Neutralize the effect of a categorical variable on a numeric variable
+  """
+  if isinstance(category, list) and isinstance(input, list):
+    r = [np.empty_like(x) for x in category]
+    category = [x.astype(float) for x in category]
+    input = [x.astype(float) for x in input]
+    _algo.neutralize(r, category, input)
+    return r
+  else:
+    r = np.empty_like(category)
+    category = category.astype(float)
+    input = input.astype(float)
+    _algo.neutralize(r, category, input)
+    return r
+
 def PRODUCT(
   input: np.ndarray | list[np.ndarray], periods: int
 ) -> np.ndarray | list[np.ndarray]:
@@ -333,6 +417,48 @@ def REF(
     _algo.ref(r, input, periods)
     return r
 
+def REGBETA(
+  y: np.ndarray | list[np.ndarray], x: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate Regression Coefficient (Beta) of Y on X over a moving window
+  
+  Beta = Cov(X, Y) / Var(X)
+  """
+  if isinstance(y, list) and isinstance(x, list):
+    r = [np.empty_like(x) for x in y]
+    y = [x.astype(float) for x in y]
+    x = [x.astype(float) for x in x]
+    _algo.regbeta(r, y, x, periods)
+    return r
+  else:
+    r = np.empty_like(y)
+    y = y.astype(float)
+    x = x.astype(float)
+    _algo.regbeta(r, y, x, periods)
+    return r
+
+def REGRESI(
+  y: np.ndarray | list[np.ndarray], x: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate Regression Residual of Y on X over a moving window
+  
+  Returns the residual of the last point: epsilon = Y - (alpha + beta * X)
+  """
+  if isinstance(y, list) and isinstance(x, list):
+    r = [np.empty_like(x) for x in y]
+    y = [x.astype(float) for x in y]
+    x = [x.astype(float) for x in x]
+    _algo.regresi(r, y, x, periods)
+    return r
+  else:
+    r = np.empty_like(y)
+    y = y.astype(float)
+    x = x.astype(float)
+    _algo.regresi(r, y, x, periods)
+    return r
+
 def RLONGCROSS(
   a: np.ndarray | list[np.ndarray], b: np.ndarray | list[np.ndarray], n: int
 ) -> np.ndarray | list[np.ndarray]:
@@ -352,6 +478,23 @@ def RLONGCROSS(
     _algo.rlongcross(r, a, b, n)
     return r
 
+def SLOPE(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Linear Regression Slope
+  
+  Calculates the slope of the linear regression line for a moving window.
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.slope(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.slope(r, input, periods)
+    return r
+
 def SMA(
   input: np.ndarray | list[np.ndarray], n: int, m: int
 ) -> np.ndarray | list[np.ndarray]:
@@ -422,6 +565,27 @@ def SUMBARS(
     _algo.sumbars(r, input, amount)
     return r
 
+def SUMIF(
+  input: np.ndarray | list[np.ndarray], condition: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate sum of values in preceding `periods` window where `condition` is true
+  
+  Ref: Custom extension
+  """
+  if isinstance(input, list) and isinstance(condition, list):
+    r = [np.empty_like(x) for x in input]
+    input = [x.astype(float) for x in input]
+    condition = [x.astype(float) for x in condition]
+    _algo.sumif(r, input, condition, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    input = input.astype(float)
+    condition = condition.astype(float)
+    _algo.sumif(r, input, condition, periods)
+    return r
+
 def TS_RANK(
   input: np.ndarray | list[np.ndarray], periods: int
 ) -> np.ndarray | list[np.ndarray]:

alpha/algo.md

@@ -4,27 +4,35 @@ the `np.ndarray` is `ndarray` type in `numpy` package
 
 - 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
+- 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.
 - CORR(x: np.ndarray[float], y: np.ndarray[float], periods: int): Calculate Correlation over a moving window  Correlation = Cov(X, Y) / (StdDev(X) * StdDev(Y))
 - COUNT(input: np.ndarray[bool], periods: int): Calculate number of periods where condition is true in passed `periods` window
 - COV(x: np.ndarray[float], y: np.ndarray[float], periods: int): Calculate Covariance over a moving window  Covariance = (SumXY - (SumX * SumY) / N) / (N - 1)
 - CROSS(a: np.ndarray[float], b: np.ndarray[float]): For 2 arrays A and B, return true if A[i-1] < B[i-1] and A[i] >= B[i] alias: golden_cross, cross_ge
 - DMA(input: np.ndarray[float], weight: float): Exponential Moving Average current = weight * current + (1 - weight) * previous
 - EMA(input: np.ndarray[float], periods: int): Exponential Moving Average (variant of well-known EMA) weight = 2 / (n + 1)
+- FRET(open: np.ndarray[float], close: np.ndarray[float], is_calc: np.ndarray[float], delay: int, periods: int): Future Return  Calculates the return from the open price of the delayed day (t+delay) to the close price of the future day (t+delay+periods-1). Return = (Close[t+delay+periods-1] - Open[t+delay]) / Open[t+delay]  If n=1, delay=1, it calculates (Close[t+1] - Open[t+1]) / Open[t+1]. If `is_calc[t+delay]` is 0, returns NaN.
 - HHV(input: np.ndarray[float], periods: int): Find highest value in a preceding `periods` window
 - HHVBARS(input: np.ndarray[float], periods: int): The number of periods that have passed since the array reached its `periods` period high
+- INTERCEPT(input: np.ndarray[float], periods: int): Linear Regression Intercept  Calculates the intercept of the linear regression line for a moving window.
 - LLV(input: np.ndarray[float], periods: int): Find lowest value in a preceding `periods` window
 - LLVBARS(input: np.ndarray[float], periods: int): The number of periods that have passed since the array reached its periods period low
 - 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
+- NEUTRALIZE(category: np.ndarray[float], input: np.ndarray[float]): Neutralize the effect of a categorical variable on a numeric variable
 - PRODUCT(input: np.ndarray[float], periods: int): Calculate product of values in preceding `periods` window  If periods is 0, it calculates the cumulative product from the first valid value.
 - RANK(input: np.ndarray[float]): Calculate rank percentage cross group dimension, the ctx.groups() is the number of groups Same value are averaged
 - RCROSS(a: np.ndarray[float], b: np.ndarray[float]): For 2 arrays A and B, return true if A[i-1] > B[i-1] and A[i] <= B[i] alias: death_cross, cross_le
 - REF(input: np.ndarray[float], periods: int): Right shift input array by `periods`, r[i] = input[i - periods]
+- REGBETA(y: np.ndarray[float], x: np.ndarray[float], periods: int): Calculate Regression Coefficient (Beta) of Y on X over a moving window  Beta = Cov(X, Y) / Var(X)
+- REGRESI(y: np.ndarray[float], x: np.ndarray[float], periods: int): Calculate Regression Residual of Y on X over a moving window  Returns the residual of the last point: epsilon = Y - (alpha + beta * X)
 - 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
+- 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
 - STDDEV(input: np.ndarray[float], periods: int): Calculate Standard Deviation over a moving window
 - 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_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)

alpha/lang/__init__.py

@@ -1 +1,4 @@
+# Copyright 2026 MSD-RS Project LiJia
+# SPDX-License-Identifier: BSD-2-Clause
+
 from .to_python import to_python, to_python_file

alpha/lang/__main__.py

@@ -1,3 +1,6 @@
+# Copyright 2026 MSD-RS Project LiJia
+# SPDX-License-Identifier: BSD-2-Clause
+
 from .to_python import to_python_file
 
 if __name__ == "__main__":

alpha/lang/to_python.py

@@ -1,3 +1,6 @@
+# Copyright 2026 MSD-RS Project LiJia
+# SPDX-License-Identifier: BSD-2-Clause
+
 import sys
 from typing import Callable
 from .parser import Lark_StandAlone, Transformer, v_args
@@ -167,10 +170,7 @@ def to_python(
   if not code.strip():
     return ""
 
-  try:
-    tree = parser.parse(code)
-  except Exception as e:
-    raise ValueError(f"Failed to parse code: {code}") from e
+  tree = parser.parse(code)
 
   transformer = AlphaTransformer(name_convertor=name_convertor)
   converted_expr = transformer.transform(tree)

{py_alpha_lib-0.1.0.dist-info → py_alpha_lib-0.1.1.dist-info}/METADATA

@@ -1,15 +1,17 @@
 Metadata-Version: 2.4
 Name: py-alpha-lib
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: numpy>=2
 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.
-Author: LiJia
+Keywords: financial data analysis,factor research,technical indicator calculation
+Author: ElseJJ
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: repository, https://github.com/msd-rs/py-alpha-lib
 
 # Introduction
 
@@ -21,25 +23,40 @@ For financial data analysis, there are many algorithms required a rolling window
 
 | Name       | Description                                                  | Ref Link                                                                |
 | ---------- | ------------------------------------------------------------ | ----------------------------------------------------------------------- |
-| BARSLAST   | Bars since last condition true                               | https://www.amibroker.com/guide/afl/barslast.html                       |
-| BARSSINCE  | Bars since first condition true                              | https://www.amibroker.com/guide/afl/barssince.html                      |
-| COUNT      | Count periods where condition is true                        | https://www.amibroker.com/guide/afl/count.html                          |
-| CROSS      | CROSS(A, B): Previous A < B, Current A >= B                  | https://www.amibroker.com/guide/afl/cross.html                          |
-| DMA        | Exponential Moving Average                                   | https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average |
-| HHV        | Highest High Value                                           | https://www.amibroker.com/guide/afl/hhv.html                            |
-| HHVBARS    | Bars since Highest High Value                                | https://www.amibroker.com/guide/afl/hhvbars.html                        |
-| LLV        | Lowest Low Value                                             | https://www.amibroker.com/guide/afl/llv.html                            |
-| LLVBARS    | Bars since Lowest Low Value                                  | https://www.amibroker.com/guide/afl/llvbars.html                        |
-| LONGCROSS  | LONGCROSS(A,B,N): Previous N A < B, Current A >= B           |                                                                         |
-| MA         | Moving Average                                               | https://en.wikipedia.org/wiki/Moving_average#Simple_moving_average      |
-| RANK       | rank by group dim                                            |                                                                         |
-| RCROSS     | RCROSE(A, B): Previous A > B, Current A <= B                 |                                                                         |
-| REF        | Reference to value N periods ago                             | https://www.amibroker.com/guide/afl/ref.html                            |
-| RLONGCROSS | RLONGCROSS(A,B,N): Previous N A > B, Current A <= B          |                                                                         |
-| SMA        | Exponential Moving Average (variant of EMA)                  | https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average |
-| SUM        | Sum of value N periods ago                                   | https://www.amibroker.com/guide/afl/sum.html                            |
-| SUMBARS    | Sums X backwards until the sum is greater than or equal to A | https://www.amibroker.com/guide/afl/sumbars.html                        |
-| TS_RANK    | rank by ts dim                                               |
+| BARSLAST   | Calculate number of bars since last condition true           | https://www.amibroker.com/guide/afl/barslast.html                       |
+| BARSSINCE  | Calculate number of bars since first condition true          | https://www.amibroker.com/guide/afl/barssince.html                      |
+| BINS       | 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. |                                                                         |
+| CORR       | Calculate Correlation over a moving window  Correlation = Cov(X, Y) / (StdDev(X) * StdDev(Y)) |                                                                         |
+| COUNT      | Calculate number of periods where condition is true in passed `periods` window | https://www.amibroker.com/guide/afl/count.html                          |
+| COV        | Calculate Covariance over a moving window  Covariance = (SumXY - (SumX * SumY) / N) / (N - 1) |                                                                         |
+| CROSS      | For 2 arrays A and B, return true if A[i-1] < B[i-1] and A[i] >= B[i] alias: golden_cross, cross_ge | https://www.amibroker.com/guide/afl/cross.html                          |
+| DMA        | Exponential Moving Average current = weight * current + (1 - weight) * previous | https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average |
+| EMA        | Exponential Moving Average (variant of well-known EMA) weight = 2 / (n + 1) | https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average |
+| FRET       | Future Return  Calculates the return from the open price of the delayed day (t+delay) to the close price of the future day (t+delay+periods-1). Return = (Close[t+delay+periods-1] - Open[t+delay]) / Open[t+delay]  If n=1, delay=1, it calculates (Close[t+1] - Open[t+1]) / Open[t+1]. If `is_calc[t+delay]` is 0, returns NaN. |                                                                         |
+| HHV        | Find highest value in a preceding `periods` window           | https://www.amibroker.com/guide/afl/hhv.html                            |
+| HHVBARS    | The number of periods that have passed since the array reached its `periods` period high | https://www.amibroker.com/guide/afl/hhvbars.html                        |
+| INTERCEPT  | Linear Regression Intercept  Calculates the intercept of the linear regression line for a moving window. |                                                                         |
+| LLV        | Find lowest value in a preceding `periods` window            | https://www.amibroker.com/guide/afl/llv.html                            |
+| LLVBARS    | The number of periods that have passed since the array reached its periods period low | https://www.amibroker.com/guide/afl/llvbars.html                        |
+| LONGCROSS  | For 2 arrays A and B, return true if previous N periods A < B, Current A >= B |                                                                         |
+| LWMA       | Linear Weighted Moving Average  LWMA = SUM(Price * Weight) / SUM(Weight) |                                                                         |
+| MA         | Simple Moving Average, also known as arithmetic moving average | https://en.wikipedia.org/wiki/Moving_average#Simple_moving_average      |
+| NEUTRALIZE | Neutralize the effect of a categorical variable on a numeric variable |                                                                         |
+| PRODUCT    | Calculate product of values in preceding `periods` window  If periods is 0, it calculates the cumulative product from the first valid value. |                                                                         |
+| RANK       | Calculate rank percentage cross group dimension, the ctx.groups() is the number of groups Same value are averaged |                                                                         |
+| RCROSS     | For 2 arrays A and B, return true if A[i-1] > B[i-1] and A[i] <= B[i] alias: death_cross, cross_le |                                                                         |
+| REF        | Right shift input array by `periods`, r[i] = input[i - periods] | https://www.amibroker.com/guide/afl/ref.html                            |
+| REGBETA    | Calculate Regression Coefficient (Beta) of Y on X over a moving window  Beta = Cov(X, Y) / Var(X) |                                                                         |
+| REGRESI    | Calculate Regression Residual of Y on X over a moving window  Returns the residual of the last point: epsilon = Y - (alpha + beta * X) |                                                                         |
+| RLONGCROSS | For 2 arrays A and B, return true if previous N periods A > B, Current A <= B |                                                                         |
+| SLOPE      | Linear Regression Slope  Calculates the slope of the linear regression line for a moving window. |                                                                         |
+| SMA        | Exponential Moving Average (variant of well-known EMA) weight = m / n | https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average |
+| STDDEV     | Calculate Standard Deviation over a moving window            |                                                                         |
+| SUM        | Calculate sum of values in preceding `periods` window  If periods is 0, it calculates the cumulative sum from the first valid value. | https://www.amibroker.com/guide/afl/sum.html                            |
+| SUMBARS    | Calculate number of periods (bars) backwards until the sum of values is greater than or equal to `amount` | https://www.amibroker.com/guide/afl/sumbars.html                        |
+| SUMIF      | Calculate sum of values in preceding `periods` window where `condition` is true |                                                                         |
+| TS_RANK    | Calculate rank in a sliding window with size `periods`       |                                                                         |
+| VAR        | Calculate Variance over a moving window  Variance = (SumSq - (Sum^2)/N) / (N - 1) |                                                                         |
 
 # Usage
 
@@ -72,7 +89,7 @@ print(result)
 
 # Calculate 3-period exponential moving average, skipping NaN values
 al.set_ctx(flags=al.FLAG_SKIP_NAN)
-data_with_nan = [1, 2, None, 4, 5, 6, 7, 8, 9, 10]
+data_with_nan = np.array([1, 2, None, 4, 5, 6, 7, 8, 9, 10], dtype=np.float64)
 result = al.MA(data_with_nan, 3)
 print(result)
 # Output: [1.  1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5]
@@ -94,6 +111,10 @@ You may notice that some functions have different behaviors based on the context
   - `FLAG_STRICTLY_CYCLE`: When this flag is set, functions will strictly cycle over the data, meaning that initial periods that do not have enough data will be filled with NaN.
   - You can combine multiple flags using bitwise OR operation, e.g., `flags=FLAG_SKIP_NAN | FLAG_STRICTLY_CYCLE`.
 
+## Vibe Coding
+
+When you need LLM to help you implement new factor in python, you can let LLM known which functions are available in `alpha-lib` by providing [the list of supported functions](python/alpha/algo.md) as context.
+
 ## Factor expression to Python code
 
 You can convert factor expressions to Python code using the `lang` module. For example:
@@ -185,4 +206,18 @@ The hardware/soft environment is:
 | #012 | 4              | 4                | 1                             | 0.7                            | -17.012321  | -17.012321    |
 | #013 | 446            | 9                | 49                            | 8                              | -0.58       | -0.58         |
 | #014 | 398            | 8                | 49                            | 18                             | 0.095449    | 0.095449      |
+
+# Development
+
+To contribute to the development of `alpha-lib`, you can clone the repository and set up a development environment.
+
+Toolchain requirements:
+
+- Rust (latest stable)
+- Python (3.11+)
+- [maturin](https://github.com/PyO3/maturin) (for building Python bindings)
+
+## Vibe Coding
+
+This project is co-created with `Gemini-3.0-Pro` , when you want add new algo, use skill [add_algo.md](.agent/skills/add_algo.md) let AI to do correct code change for you.
 

py_alpha_lib-0.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+alpha\__init__.py,sha256=it34OBlXnf1KxXsG3S7gOTo7VUf_29NjYrf5HkyTiBQ,253
+alpha\algo\__init__.py,sha256=AwglMcMEn0P_Stdlr9oUYwFNVDtJ7JRh48LCHnZNRA8,158
+alpha\algo\_algo.pyd,sha256=Mk7q09s63T1J_aL7dTw28n34WXuz0qZUD-m3Y95scQc,2494464
+alpha\algo\algo.py,sha256=48jGJGSypFgGnih-XgIxW2QUnzGsTWq00TGNuDxKHE4,684
+alpha\algo\algo_gen.py,sha256=KlMKCnTZH9jotIW3wmsx2dXWRCejMWeJ6nd-vlzyhG8,17287
+alpha\algo.md,sha256=jh8-TXh5moTmnexFQWKfrtS4xy5oe3n40CXfdGyCX38,5115
+alpha\lang\__init__.py,sha256=2dLimPixRh5vF3PvgF-aJ8DBZ0SuDaHrrkQecmBTC_4,132
+alpha\lang\__main__.py,sha256=wa5DHGSmhL8dswN3v160RXs1qG6_dIr0W1qe_u4b3C8,572
+alpha\lang\alpha.lark,sha256=qqMXJ--F3ErYikNdRs1vwHGKoJe_aRUeNmpo87NaTXs,1046
+alpha\lang\parser.py,sha256=WBpwEUYzGJ1nM7iUh_mEimGLhHzVZXS8BAzF58ZRagU,156846
+alpha\lang\to_python.py,sha256=4i8km91EejlzrIt5QxHrZWtq-A3zlDwRJwlAUew54-8,6563
+py_alpha_lib-0.1.1.dist-info\METADATA,sha256=5Mgzjgy9wEQQVexGOZrmjpAXaUouWlZAW5W152XoFCY,16272
+py_alpha_lib-0.1.1.dist-info\WHEEL,sha256=dsg5IA1tFdLNsJihRQJCX59s7GKfDG9N_2EOwwysnks,96
+py_alpha_lib-0.1.1.dist-info\licenses\LICENSE,sha256=3D2Y67XRAnMSiByf02r4DaFv92CdDLw5U6xHyUVkdI4,1289
+py_alpha_lib-0.1.1.dist-info\RECORD,,

alpha/algo/algo.md

@@ -1,98 +0,0 @@
-# Algo
-## barslast
-Bars since last condition true
-
-Ref: https://www.amibroker.com/guide/afl/barslast.html
-
-## barssince
-Bars since first condition true
-
-Ref: https://www.amibroker.com/guide/afl/barssince.html
-
-## count
-Count periods where condition is true
-
-Ref: https://www.amibroker.com/guide/afl/count.html
-
-## cross
-CROSS(A, B): Previous A < B, Current A >= B
-
-Ref: https://www.amibroker.com/guide/afl/cross.html
-
-## dma
-Exponential Moving Average
-
-https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
-
-current = alpha * current + (1 - alpha) * previous
-
-
-## hhv
-Highest High Value
-
-Ref: https://www.amibroker.com/guide/afl/hhv.html
-
-## hhvbars
-Bars since Highest High Value
-
-Ref: https://www.amibroker.com/guide/afl/hhvbars.html
-
-## llv
-Lowest Low Value
-
-Ref: https://www.amibroker.com/guide/afl/llv.html
-
-## llvbars
-Bars since Lowest Low Value
-
-Ref: https://www.amibroker.com/guide/afl/llvbars.html
-
-## longcross
-LONGCROSS(A,B,N): Previous N A < B, Current A >= B
-
-## ma
-Moving Average
-
-https://en.wikipedia.org/wiki/Moving_average#Simple_moving_average
-
-
-
-## rank
-rank by group dim
-
-## rcross
-RCROSE(A, B): Previous A > B, Current A <= B
-
-## ref
-Reference to value N periods ago
-
-Ref: https://www.amibroker.com/guide/afl/ref.html
-
-## rlongcross
-RLONGCROSS(A,B,N): Previous N A > B, Current A <= B
-
-## sma
-Exponential Moving Average (variant of EMA)
-
-alpha = m / n
-
-https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
-
-
-## sum
-Sum of value N periods ago
-
-If periods is 0, it calculates the cumulative sum from the first valid value.
-
-Ref: https://www.amibroker.com/guide/afl/sum.html
-
-## sumbars
-Sums X backwards until the sum is greater than or equal to A
-
-Returns the number of periods (bars) passed.
-
-Ref: https://www.amibroker.com/guide/afl/sumbars.html
-
-## ts_rank
-rank by ts dim
-

py_alpha_lib-0.1.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-alpha\__init__.py,sha256=rZE0P-d0AT7YG624RuE_EPdwIGKOHz2RMPn6Z-nTu9o,171
-alpha\algo\__init__.py,sha256=F8t1XUjla37_0x-fjGL4HXTZASmSYLotWQbfdOhdfh0,76
-alpha\algo\_algo.pyd,sha256=MK1Nk-4xQngkixcZcQiLLzmKLC5NPE3ZTmDXa3XF4LU,2076672
-alpha\algo\algo.md,sha256=KZjYakkAkTLx4iPDj7hcVZEVv7Fc7Ye9h-zdz7JB7rI,1929
-alpha\algo\algo.py,sha256=Y0R13cZ7uigtsobYd4wo9vtMlPJRwL0ktwPp6GPl0xc,602
-alpha\algo\algo_gen.py,sha256=hSc8c8yJrGcNnZohc56TgJj_7V6Bcxnf_7K04mOiSYc,12269
-alpha\algo.md,sha256=Av1UP0Tj7RHaksHD-0kM4uvppXyvDMlyEQZ6CG7PNYY,3521
-alpha\lang\__init__.py,sha256=JdMw9vZv-4CQgChVfMxIYwpb5pQsYc9d_GleocYfFg4,50
-alpha\lang\__main__.py,sha256=aemLHkuKarwc2x8aejCWBpFsYY49NzQOUhHcUFf19BE,490
-alpha\lang\alpha.lark,sha256=qqMXJ--F3ErYikNdRs1vwHGKoJe_aRUeNmpo87NaTXs,1046
-alpha\lang\parser.py,sha256=WBpwEUYzGJ1nM7iUh_mEimGLhHzVZXS8BAzF58ZRagU,156846
-alpha\lang\to_python.py,sha256=G-bcISR1ItW6AxfccuEZo-xwukl-TtVLgmo3n2nnrPE,6579
-py_alpha_lib-0.1.0.dist-info\METADATA,sha256=clwi8ljMxqv3YKDgmCaufgZ6-jPOpwnndEKSY8jI7vw,11880
-py_alpha_lib-0.1.0.dist-info\WHEEL,sha256=dsg5IA1tFdLNsJihRQJCX59s7GKfDG9N_2EOwwysnks,96
-py_alpha_lib-0.1.0.dist-info\licenses\LICENSE,sha256=3D2Y67XRAnMSiByf02r4DaFv92CdDLw5U6xHyUVkdI4,1289
-py_alpha_lib-0.1.0.dist-info\RECORD,,