tdxformula 0.1.0__py3-none-any.whl

tdxformula/__init__.py

@@ -0,0 +1,18 @@
+"""tdxformula — 通达信指标公式 Python 转译器。
+
+把通达信技术指标公式（DSL）解析并求值为 numpy 序列，语义经通达信
+真实数据逐根核对（MACD/KDJ 已验证）。
+
+    from tdxformula import eval_formula, gen_python
+
+    src = "DIF:EMA(CLOSE,12)-EMA(CLOSE,26);DEA:EMA(DIF,9);MACD:(DIF-DEA)*2;"
+    r = eval_formula(src, {"CLOSE": close_array})
+    print(r["DIF"], r["__outputs__"])
+
+    print(gen_python(src))   # -> "DIF = (EMA(CLOSE, 12.0) - EMA(CLOSE, 26.0))..."
+"""
+
+from .formula import (FUNCS, eval_formula, gen_python, tokenize)
+
+__version__ = "0.1.0"
+__all__ = ["eval_formula", "gen_python", "tokenize", "FUNCS", "__version__"]

tdxformula/formula.py

@@ -0,0 +1,330 @@
+# -*- coding: utf-8 -*-
+"""通达信公式 → Python 转译器原型（POC）。
+
+支持语法（指标公式子集）：
+    赋值语句:   名称:表达式;    （输出线）
+    中间变量:   名称:=表达式;   （不输出）
+    表达式:     数字 / 标识符 / 函数调用 / 四则运算 / 比较 / AND OR && ||
+内置函数（numpy 序列语义）:
+    MA EMA SMA REF HHV LLV CROSS COUNT EVERY EXIST BARSLAST
+    SUM ABS MAX MIN
+
+用法:
+    env = {"OPEN":..., "HIGH":..., "LOW":..., "CLOSE":..., "VOL":...}
+    result = eval_formula(src, env)
+    result -> {"DIF": array, "DEA": array, "MACD": array, "__outputs__": [...]}
+"""
+
+from __future__ import annotations
+
+import re
+
+import numpy as np
+
+# ==================== 词法分析 ====================
+
+TOKEN_RE = re.compile(r"""
+    (?P<ws>\s+)
+  | (?P<comment>\{[^}]*\})
+  | (?P<num>\d+\.?\d*)
+  | (?P<id>[A-Za-z_\u4e00-\u9fff][A-Za-z0-9_\u4e00-\u9fff]*)
+  | (?P<op>:=|<=|>=|<>|!=|&&|\|\||[-+*/<>=(),;:])
+""", re.VERBOSE)
+
+
+def tokenize(src: str):
+    tokens, pos = [], 0
+    while pos < len(src):
+        m = TOKEN_RE.match(src, pos)
+        if not m:
+            raise SyntaxError(f"无法识别的字符 {src[pos]!r} @ {pos}")
+        pos = m.end()
+        if m.lastgroup in ("ws", "comment"):
+            continue
+        tokens.append((m.lastgroup, m.group()))
+    tokens.append(("eof", ""))
+    return tokens
+
+
+# ==================== 语法分析（递归下降 → AST 元组） ====================
+
+class Parser:
+    def __init__(self, tokens):
+        self.toks = tokens
+        self.i = 0
+
+    def peek(self):
+        return self.toks[self.i]
+
+    def eat(self, val=None):
+        kind, v = self.toks[self.i]
+        if val and v != val:
+            raise SyntaxError(f"期望 {val!r}，实际 {v!r}")
+        self.i += 1
+        return v
+
+    # 语句层
+    def parse_program(self):
+        stmts = []
+        while self.peek()[0] != "eof":
+            name = self.eat()
+            kind = "output" if self.eat() in (":",) else "hidden"   # ':' or ':='
+            expr = self.parse_expr()
+            self.eat(";")
+            stmts.append((kind, name, expr))
+        return stmts
+
+    # 表达式层（优先级从低到高）
+    def parse_expr(self):
+        return self.parse_or()
+
+    def parse_or(self):
+        left = self.parse_and()
+        while self.peek()[1] in ("OR", "||"):
+            self.eat()
+            left = ("or", left, self.parse_and())
+        return left
+
+    def parse_and(self):
+        left = self.parse_cmp()
+        while self.peek()[1] in ("AND", "&&"):
+            self.eat()
+            left = ("and", left, self.parse_cmp())
+        return left
+
+    def parse_cmp(self):
+        left = self.parse_add()
+        while self.peek()[1] in (">", "<", ">=", "<=", "=", "<>", "!="):
+            op = self.eat()
+            left = ("cmp", op, left, self.parse_add())
+        return left
+
+    def parse_add(self):
+        left = self.parse_mul()
+        while self.peek()[1] in ("+", "-"):
+            op = self.eat()
+            left = ("bin", op, left, self.parse_mul())
+        return left
+
+    def parse_mul(self):
+        left = self.parse_unary()
+        while self.peek()[1] in ("*", "/"):
+            op = self.eat()
+            left = ("bin", op, left, self.parse_unary())
+        return left
+
+    def parse_unary(self):
+        kind, v = self.peek()
+        if v in ("+", "-"):
+            self.eat()
+            return ("neg" if v == "-" else "pos", self.parse_unary())
+        return self.parse_atom()
+
+    def parse_atom(self):
+        kind, v = self.peek()
+        if v == "(":
+            self.eat("(")
+            e = self.parse_expr()
+            self.eat(")")
+            return e
+        if kind == "num":
+            self.eat()
+            return ("const", float(v))
+        if kind == "id":
+            self.eat()
+            if self.peek()[1] == "(":
+                self.eat("(")
+                args = []
+                if self.peek()[1] != ")":
+                    args.append(self.parse_expr())
+                    while self.peek()[1] == ",":
+                        self.eat(",")
+                        args.append(self.parse_expr())
+                self.eat(")")
+                return ("call", v.upper(), args)
+            return ("var", v)
+        raise SyntaxError(f"意外的记号 {v!r}")
+
+
+# ==================== 序列函数库（numpy 实现） ====================
+
+def MA(x, n):
+    n = int(n)
+    c = np.cumsum(np.insert(np.asarray(x, float), 0, 0.0))
+    out = (c[n:] - c[:-n]) / n
+    return np.concatenate([np.full(n - 1, np.nan), out])
+
+
+def EMA(x, n):
+    a = 2.0 / (n + 1)
+    out = np.empty_like(np.asarray(x, float))
+    prev = x[0]
+    for i, v in enumerate(x):
+        prev = a * v + (1 - a) * prev
+        out[i] = prev
+    return out
+
+
+def SMA(x, n, m):
+    """通达信特有：SMA(X,N,M) = (M*X + (N-M)*SMA') / N。
+
+    种子取首个有效值（与通达信一致，从第一根就出值）。
+    """
+    x = np.asarray(x, float)
+    out = np.full_like(x, np.nan)
+    start = int(np.argmax(~np.isnan(x))) if np.isnan(x).any() else 0
+    prev = x[start]
+    for i in range(start, len(x)):
+        prev = (m * x[i] + (n - m) * prev) / n
+        out[i] = prev
+    return out
+
+
+def REF(x, n):
+    n = int(n)
+    out = np.full_like(np.asarray(x, float), np.nan)
+    out[n:] = x[:-n] if n > 0 else x
+    return out
+
+
+def HHV(x, n):
+    n = int(n)
+    out = np.full_like(np.asarray(x, float), np.nan)
+    for i in range(len(x)):
+        lo = max(0, i - n + 1)
+        out[i] = np.max(x[lo:i + 1])
+    return out
+
+
+def LLV(x, n):
+    n = int(n)
+    out = np.full_like(np.asarray(x, float), np.nan)
+    for i in range(len(x)):
+        lo = max(0, i - n + 1)
+        out[i] = np.min(x[lo:i + 1])
+    return out
+
+
+def CROSS(a, b):
+    return (a > b) & (np.roll(a, 1) <= np.roll(b, 1))
+
+
+def COUNT(cond, n):
+    n = int(n)
+    out = np.zeros(len(cond), float)
+    for i in range(n - 1, len(cond)):
+        out[i] = np.sum(cond[i - n + 1:i + 1])
+    return out
+
+
+def EVERY(cond, n):
+    return COUNT(cond, n) == n
+
+
+def EXIST(cond, n):
+    return COUNT(cond, n) > 0
+
+
+def BARSLAST(cond):
+    out = np.full(len(cond), np.nan)
+    last = np.nan
+    for i, c in enumerate(cond):
+        if c:
+            last = 0
+        elif not np.isnan(last):
+            last += 1
+        out[i] = last
+    return out
+
+
+FUNCS = {
+    "MA": MA, "EMA": EMA, "SMA": SMA, "REF": REF, "HHV": HHV, "LLV": LLV,
+    "CROSS": CROSS, "COUNT": COUNT, "EVERY": EVERY, "EXIST": EXIST,
+    "BARSLAST": BARSLAST, "SUM": lambda x, n: COUNT(x, n) * np.nan,  # 占位
+    "ABS": lambda x: np.abs(x),
+    "MAX": lambda a, b: np.maximum(a, b),
+    "MIN": lambda a, b: np.minimum(a, b),
+}
+
+
+# ==================== 求值 ====================
+
+def _eval(node, env):
+    op = node[0]
+    if op == "const":
+        return float(node[1])
+    if op == "var":
+        if node[1] not in env:
+            raise NameError(f"未定义变量: {node[1]}")
+        return env[node[1]]
+    if op == "neg":
+        return -_eval(node[1], env)
+    if op == "pos":
+        return _eval(node[1], env)
+    if op == "bin":
+        a, b = _eval(node[2], env), _eval(node[3], env)
+        return {"+": lambda: a + b, "-": lambda: a - b,
+                "*": lambda: a * b, "/": lambda: a / b}[node[1]]()
+    if op == "cmp":
+        a, b = _eval(node[2], env), _eval(node[3], env)
+        return {">": a > b, "<": a < b, ">=": a >= b, "<=": a <= b,
+                "=": a == b, "==": a == b, "<>": a != b, "!=": a != b}[node[1]]
+    if op == "and":
+        return np.logical_and(_eval(node[1], env), _eval(node[2], env))
+    if op == "or":
+        return np.logical_or(_eval(node[1], env), _eval(node[2], env))
+    if op == "call":
+        fn = FUNCS.get(node[1])
+        if fn is None:
+            raise ValueError(f"函数未实现: {node[1]}")
+        args = [_eval(a, env) for a in node[2]]
+        return fn(*args)
+    raise ValueError(op)
+
+
+def eval_formula(src: str, env: dict) -> dict:
+    """解析并求值通达信指标公式，返回 {线名: numpy 数组}。
+
+    env 需提供 OPEN/HIGH/LOW/CLOSE/VOL 等序列；__len__ 自动推断。
+    """
+    env = dict(env)
+    env.setdefault("__len__", len(next(iter(env.values()))))
+    outputs, results = [], {}
+    for kind, name, expr in Parser(tokenize(src)).parse_program():
+        results[name] = _eval(expr, env)
+        env[name] = results[name]          # 后续语句可引用前面的线
+        if kind == "output":
+            outputs.append(name)
+    results["__outputs__"] = outputs
+    return results
+
+
+# ==================== 代码生成（可选：导出 Python 源码） ====================
+
+def gen_python(src: str) -> str:
+    lines = []
+    for kind, name, expr in Parser(tokenize(src)).parse_program():
+        lines.append(f"{name} = {_gen(expr)}")
+    return "\n".join(lines)
+
+
+def _gen(node):
+    op = node[0]
+    if op == "const":
+        return repr(node[1])
+    if op == "var":
+        return node[1]
+    if op == "neg":
+        return f"(-{_gen(node[1])})"
+    if op == "bin":
+        return f"({_gen(node[2])} {node[1]} {_gen(node[3])})"
+    if op == "cmp":
+        sym = {"<>": "!=", "=": "=="}.get(node[1], node[1])
+        return f"({_gen(node[2])} {sym} {_gen(node[3])})"
+    if op == "and":
+        return f"({_gen(node[1])} & {_gen(node[2])})"
+    if op == "or":
+        return f"({_gen(node[1])} | {_gen(node[2])})"
+    if op == "call":
+        return f"{node[1]}({', '.join(_gen(a) for a in node[2])})"
+    raise ValueError(op)

tdxformula-0.1.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: tdxformula
+Version: 0.1.0
+Summary: 通达信指标公式 Python 转译器：逐根对齐通达信真实计算结果
+Author: mengyiheng
+License: MIT
+Keywords: tdx,tongdaxin,formula,indicator,quant,dsl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+
+<p align="center"><img src="assets/cover.png" alt="tdxformula" width="720"/></p>
+
+# tdxformula — 通达信公式 Python 转译器
+
+把**通达信技术指标公式**（DSL）解析并转译为 numpy 序列运算，语义经通达信
+真实数据**逐根核对**（MACD 与 pandas 独立实现误差为 0；KDJ 由作者在通达信
+客户端逐值核对一致）。
+
+- 📖 **解析指标公式 DSL**：赋值线 / 中间变量（`:=`）/ 四则 / 比较 / `AND OR` / 注释
+- 🧮 **序列语义对齐通达信**：`HHV/LLV` 前端增长窗口、`SMA(X,N,M)` 加权递推种子等
+  特殊行为全部按通达信真实行为实现（市面开源实现的重灾区）
+- 🐍 **双模式**：直接求值返回 numpy 数组，或生成 Python 源码
+- ✅ **可信度**：KDJ 在上证指数 2026-06-08 实测 K=17.98 / D=21.68 / J=10.59，
+  与通达信客户端显示完全一致（测试内置该断言）
+
+## 安装
+
+```bash
+pip install tdxformula numpy
+```
+
+## 快速开始
+
+```python
+import numpy as np
+from tdxdata import read_day
+from tdxformula import eval_formula, gen_python
+
+bars = read_day(r"D:\new_tdx64\vipdoc\sh\lday\sh000001.day")
+env = {k.upper(): np.array([getattr(b, k) for b in bars], float)
+       for k in ("open", "high", "low", "close", "vol")}
+
+macd = """
+DIF:EMA(CLOSE,12)-EMA(CLOSE,26);
+DEA:EMA(DIF,9);
+MACD:(DIF-DEA)*2;
+"""
+r = eval_formula(macd, env)
+print(r["DIF"][-1], r["DEA"][-1])     # numpy 序列，直接进你的回测框架
+print(r["__outputs__"])               # ['DIF', 'DEA', 'MACD']
+
+kdj = """
+RSV:=(CLOSE-LLV(LOW,9))/(HHV(HIGH,9)-LLV(LOW,9))*100;
+K:SMA(RSV,3,1);
+D:SMA(K,3,1);
+J:3*K-2*D;
+"""
+r2 = eval_formula(kdj, env)
+
+print(gen_python(macd))
+# DIF = (EMA(CLOSE, 12.0) - EMA(CLOSE, 26.0))
+# DEA = EMA(DIF, 9.0)
+# MACD = ((DIF - DEA) * 2.0)
+```
+
+## 已支持的函数
+
+| 类别 | 函数 |
+|---|---|
+| 均线 | `MA` `EMA` `SMA`（通达信加权版） |
+| 引用 | `REF` `HHV` `LLV` `BARSLAST` |
+| 统计 | `COUNT` `EVERY` `EXIST` `SUM` |
+| 逻辑 | `CROSS` `AND/OR/&&/\|\|`、比较运算 |
+| 算术 | `+ - * /` `ABS` `MAX` `MIN` |
+
+已在路线图：`DRAW*` 系列转 [tdxdraw](https://gitee.com/mengyiheng/tdxdraw) 画线、
+公式参数、跨公式引用（`"MACD.DEA"#DAY`）、更多函数。
+
+## 通达信语义对齐说明（本项目存在的理由）
+
+| 行为 | 通达信真实语义 | 本库实现 |
+|---|---|---|
+| `HHV/LLV` 前 N-1 根 | 用现有数据增长窗口，照常出值 | ✅ |
+| `SMA(X,N,M)` 种子 | 首个有效值，第一根即出值 | ✅ |
+| `MA` 前 N-1 根 | 无值 | ✅ NaN |
+| `EMA` 递推 | `(2X+(N-1)EMA')/(N+1)` | ✅ 与 pandas ewm(span) 误差 0 |
+
+## 免责声明
+
+本项目仅为公式文本的格式转换工具，不提供任何行情数据，不构成任何投资建议。
+使用前请[阅读完整免责声明](DISCLAIMER.md)。
+
+## License
+
+MIT
+
+## 量化相关定制需求
+
+作者承接公式迁移与转译器扩展的定制开发：
+
+| 方向 | 示例 |
+|---|---|
+| 📦 公式批量迁移 | 你的私藏公式库整批转译 + 与通达信逐根比对验收 |
+| 🧮 函数扩充 | 按需实现未覆盖的序列函数（对齐通达信语义） |
+| 🔗 深度集成 | 选股公式转盘中扫描（接 tdxalert）、绘图指令转 tdxdraw |
+
+**联系合作**：[Gitee Issues](https://gitee.com/mengyiheng/tdxformula/issues) 或 [Gitee 私信](https://gitee.com/mengyiheng)。迁移类需求请附：公式数量、是否含绘图指令。

tdxformula-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+tdxformula/__init__.py,sha256=gJhRrz1RAEEGWZmUugh0u7FFedgBI8lUUZiqFABfXvM,678
+tdxformula/formula.py,sha256=6RR1ZhPUoycz_0oKh6L0r1KH1JoSoDFuq9PdmSZB4Fk,9526
+tdxformula-0.1.0.dist-info/METADATA,sha256=as-Ba3IeiMc0b6fry1J3xzBDWOnU7CUo0aqSteTGH_w,4186
+tdxformula-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+tdxformula-0.1.0.dist-info/top_level.txt,sha256=faacM-nwUWuIiYakj0Y9NSzizH7n8an-kqLGDkk9tcw,11
+tdxformula-0.1.0.dist-info/RECORD,,

tdxformula-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tdxformula-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tdxformula