添加None确认

TF_DF.py

@@ -1698,7 +1698,8 @@ class TF_DF():
 
 			# 移动到下一组
 			start_idx += 4
-
+		if last_zs:
+			last_zs.is_sure = seg_list[-1].is_sure
 		# 处理最后一个未确认的中枢 - 不自动扩展，保持未完成状态
 		if last_zs and not last_zs.is_sure:
 			# 获取中枢最后一个线段的索引

data_provider/main.py

@@ -1,3 +1,8 @@
+"""
+Chan 数据服务：用 ccxt 从交易所拉取 K 线，内存缓存 + CSV 落盘；
+后台线程定期增量刷新，断线时记录 resume_since 以免漏 K；
+配置中的基础周期（如 1m/1h）可合成 DERIVED_TIMEFRAME_PLAN 中的衍生周期。
+"""
 import asyncio
 import csv
 import json
@@ -20,14 +25,17 @@ from technical.util import resample_to_interval
 # docker compose logs --tail=200
 # docker compose down && docker compose build --no-cache && docker compose up -d
 
+# 基础周期枚举顺序（用于衍生周期展示顺序）；仅允许集合内周期作为交易所直接拉取的 tf
 TIMEFRAME_ORDER = ["1m", "1h", "1d", "1w"]
 ALLOWED_TIMEFRAMES = set(TIMEFRAME_ORDER)
+# 各基础周期一根 K 线的毫秒长度（用于历史分页与断线回退）
 TIMEFRAME_TO_MS: Dict[str, int] = {
     "1m": 60_000,
     "1h": 3_600_000,
     "1d": 86_400_000,
     "1w": 604_800_000,
 }
+# 每个基础周期可派生出的合成周期列表（由该基础周期 K 线 resample 得到）
 DERIVED_TIMEFRAME_PLAN: Dict[str, List[str]] = {
     "1m": ["2m", "3m", "4m", "5m", "10m", "15m", "20m", "25m", "30m", "45m"],
     "1h": ["2h", "3h", "4h", "5h", "6h", "7h", "8h", "9h", "10", "11h", "12h", "16h", "20h"],
@@ -37,8 +45,8 @@ DERIVED_TIMEFRAME_PLAN: Dict[str, List[str]] = {
 CSV_FIELDNAMES = ["timestamp", "datetime", "open", "high", "low", "close", "volume"]
 DEFAULT_LIMIT = 500
 RECENT_CANDLE_LIMIT = 10
-RECENT_FETCH_INTERVAL = 5
+RECENT_FETCH_INTERVAL = 5  # 后台刷新循环休眠秒数
-PERSIST_INTERVAL = 600
+PERSIST_INTERVAL = 600  # 全量落盘周期（秒）
 
 
 logger = logging.getLogger("data_provider")
@@ -49,11 +57,13 @@ logging.basicConfig(
 
 
 def to_utc_iso(timestamp_ms: int) -> str:
+    """将毫秒时间戳格式化为 UTC ISO 字符串（末尾 Z）。"""
     dt = datetime.fromtimestamp(timestamp_ms / 1000, tz=timezone.utc)
     return dt.isoformat().replace("+00:00", "Z")
 
 
 def parse_timestamp(value: Optional[object]) -> Optional[int]:
+    """解析查询参数中的时间为 UTC 毫秒时间戳；支持数字或 ISO 字符串。"""
     if value is None:
         return None
     if isinstance(value, (int, float)):
@@ -79,6 +89,7 @@ def parse_timestamp(value: Optional[object]) -> Optional[int]:
 
 
 def candle_to_dict(candle: Iterable[float]) -> Dict[str, float]:
+    """ccxt OHLCV 单根 [ts, o, h, l, c, v] 转为内部字典结构。"""
     ts = int(candle[0])
     return {
         "timestamp": ts,
@@ -92,6 +103,7 @@ def candle_to_dict(candle: Iterable[float]) -> Dict[str, float]:
 
 
 def timeframe_to_minutes(tf: str) -> Optional[int]:
+    """将如 15m、2h 转为「分钟数」，供 resample 与衍生周期计算。"""
     if not tf:
         return None
     unit = tf[-1]
@@ -111,6 +123,8 @@ def timeframe_to_minutes(tf: str) -> Optional[int]:
 
 
 class DataProvider:
+    """封装交易所连接、本地 CSV、内存缓存、断线恢复与衍生周期聚合。"""
+
     def __init__(self, config_path: Path) -> None:
         self.config_path = config_path
         self.config = self._load_config()
@@ -126,10 +140,12 @@ class DataProvider:
         self.data: Dict[str, Dict[str, List[Dict[str, float]]]] = {
             symbol: {tf: [] for tf in self.timeframes} for symbol in self.symbols
         }
+        # 衍生周期 -> 用于合成的交易所基础周期（每个衍生只对应一个 base）
         self.derived_map: Dict[str, str] = {}
         for base_tf in self.timeframes:
             for derived_tf in DERIVED_TIMEFRAME_PLAN.get(base_tf, []):
                 self.derived_map.setdefault(derived_tf, base_tf)
+        # 衍生周期展示顺序：按 TIMEFRAME_ORDER 中的基础周期依次展开
         derived_order: List[str] = []
         for base_tf in TIMEFRAME_ORDER:
             if base_tf not in self.timeframes:
@@ -151,12 +167,14 @@ class DataProvider:
         self._load_resume_since()
 
     def _load_config(self) -> Dict[str, object]:
+        """读取 JSON 配置文件。"""
         if not self.config_path.exists():
             raise FileNotFoundError(f"未找到配置文件: {self.config_path}")
         with self.config_path.open("r", encoding="utf-8") as fp:
             return json.load(fp)
 
     def _load_symbols(self, config: Dict[str, object]) -> List[str]:
+        """从 symbols 列表、逗号分隔字符串或单字段 symbol 解析交易对，去重保序。"""
         raw_symbols: List[str] = []
         symbols_value = config.get("symbols")
         if isinstance(symbols_value, list):
@@ -175,6 +193,7 @@ class DataProvider:
         return unique
 
     def _validate_timeframes(self, configured: Optional[Iterable[str]]) -> List[str]:
+        """校验周期在允许集合内；未配置则默认 TIMEFRAME_ORDER 全部；顺序优先按 TIMEFRAME_ORDER。"""
         if not configured:
             return list(TIMEFRAME_ORDER)
         invalid = [tf for tf in configured if tf not in ALLOWED_TIMEFRAMES]
@@ -193,6 +212,7 @@ class DataProvider:
         return unique
 
     def _init_exchange(self):
+        """实例化 ccxt 交易所，币安期货默认 defaultType=future，并 load_markets。"""
         if not hasattr(ccxt, self.exchange_name):
             raise ValueError(f"不支持的交易所: {self.exchange_name}")
         exchange_class = getattr(ccxt, self.exchange_name)
@@ -204,10 +224,12 @@ class DataProvider:
         return exchange
 
     def _data_file_path(self, symbol: str, timeframe: str) -> Path:
+        """单交易对单周期的 CSV 路径：data_dir/tf/exchange_symbol_tf.csv。"""
         symbol_safe = symbol.replace("/", "_").replace(":", "_")
         return self.data_dir / timeframe / f"{self.exchange.id}_{symbol_safe}_{timeframe}.csv"
 
     def _load_local(self, symbol: str, timeframe: str) -> List[Dict[str, float]]:
+        """启动时从磁盘加载已有 K 线，损坏行跳过，按时间排序。"""
         path = self._data_file_path(symbol, timeframe)
         if not path.exists():
             return []
@@ -239,6 +261,7 @@ class DataProvider:
         base: List[Dict[str, float]],
         new_candles: Iterable[Iterable[float]],
     ) -> List[Dict[str, float]]:
+        """按 timestamp 去重合并，新数据覆盖同时间戳旧数据。"""
         merged = {entry["timestamp"]: entry for entry in base}
         for candle in new_candles:
             entry = candle_to_dict(candle)
@@ -248,6 +271,7 @@ class DataProvider:
         return ordered
 
     def _write_to_disk(self, symbol: str, timeframe: str, data: List[Dict[str, float]]) -> None:
+        """先写临时文件再 replace，避免写入中断导致 CSV 损坏。"""
         path = self._data_file_path(symbol, timeframe)
         path.parent.mkdir(parents=True, exist_ok=True)
         tmp_path = path.with_suffix(path.suffix + ".tmp")
@@ -266,6 +290,7 @@ class DataProvider:
         logger.info("交易对 %s 时间周期 %s 已写入磁盘 (%s 根K线)", symbol, timeframe, len(data))
 
     def _fetch_history(self, symbol: str, timeframe: str, since_ms: int) -> List[List[float]]:
+        """从 since_ms 分页拉取直到接近当前时间；遇限频则 sleep 重试。"""
         results: List[List[float]] = []
         limit = 1500
         now_ms = self.exchange.milliseconds()
@@ -302,6 +327,7 @@ class DataProvider:
         return results
 
     def initialize(self) -> None:
+        """阻塞式启动：加载本地、从倒数第二根或配置起点补历史、写盘并 set _ready。"""
         logger.info("开始初始化数据提供商")
         for symbol in self.symbols:
             for timeframe in self.timeframes:
@@ -310,6 +336,7 @@ class DataProvider:
                 last_ts = existing[-1]["timestamp"] if existing else None
                 if last_ts is not None:
                     if len(existing) >= 2:
+                        # 从倒数第二根起拉，避免最后一根未收盘重复/缺口
                         fetch_since = existing[-2]["timestamp"]
                     else:
                         fetch_since = max(0, last_ts - tf_ms)
@@ -334,9 +361,11 @@ class DataProvider:
         logger.info("数据初始化完成")
         
     def resample_df(self, df: pd.DataFrame, interval: int) -> pd.DataFrame:
+        """将基础周期 DataFrame 聚合为 interval 分钟周期（freqtrade technical.util）。"""
         return resample_to_interval(df, interval)
     
     def _save_resume_since(self) -> None:
+        """将断线恢复点持久化到 resume_since.json（原子替换）。"""
         path = self._resume_file
         path.parent.mkdir(parents=True, exist_ok=True)
         tmp_path = path.with_suffix(path.suffix + ".tmp")
@@ -358,6 +387,7 @@ class DataProvider:
         logger.debug("恢复点已保存到磁盘: %s", path)
     
     def _load_resume_since(self) -> None:
+        """启动时加载恢复点；与内存合并时取更早的 since，避免漏拉。"""
         path = self._resume_file
         if not path.exists():
             return
@@ -395,10 +425,12 @@ class DataProvider:
         logger.info("已加载恢复点: %s", path)
     
     def _get_resume_since(self, symbol: str, timeframe: str) -> Optional[int]:
+        """若曾断线，返回应从哪一毫秒起补拉该 symbol/tf。"""
         with self._lock:
             return self._resume_since.get(symbol, {}).get(timeframe)
     
     def _set_resume_since(self, symbol: str, timeframe: str, since_ms: int) -> None:
+        """断线时写入恢复点（取更早的 since 以免漏数据），并持久化到磁盘。"""
         with self._lock:
             per_symbol = self._resume_since.setdefault(symbol, {})
             prev = per_symbol.get(timeframe)
@@ -416,6 +448,7 @@ class DataProvider:
         self._save_resume_since()
     
     def _clear_resume_since(self, symbol: str, timeframe: str) -> None:
+        """补数成功后清除该 symbol/tf 的恢复点。"""
         with self._lock:
             if symbol in self._resume_since and timeframe in self._resume_since[symbol]:
                 del self._resume_since[symbol][timeframe]
@@ -426,6 +459,7 @@ class DataProvider:
         self._save_resume_since()
     
     def start_background_workers(self) -> None:
+        """启动增量刷新线程与周期性落盘线程。"""
         if self._fetch_thread and self._fetch_thread.is_alive():
             return
         self._stop_event.clear()
@@ -436,6 +470,7 @@ class DataProvider:
         logger.info("后台线程已启动")
 
     def stop(self) -> None:
+        """停止后台线程（应用关闭时 lifespan finally 调用）。"""
         self._stop_event.set()
         if self._fetch_thread:
             self._fetch_thread.join(timeout=5)
@@ -444,6 +479,7 @@ class DataProvider:
         logger.info("数据提供商已停止")
 
     def _refresh_loop(self) -> None:
+        """轮询各 symbol/tf：有恢复点则先补历史，否则 fetch 最近 RECENT_CANDLE_LIMIT 根。"""
         while not self._stop_event.is_set():
             for symbol in self.symbols:
                 for timeframe in self.timeframes:
@@ -496,10 +532,12 @@ class DataProvider:
                 break
 
     def _persist_loop(self) -> None:
+        """每隔 PERSIST_INTERVAL 秒把内存快照写 CSV 并保存恢复点。"""
         while not self._stop_event.wait(PERSIST_INTERVAL):
             self._persist_all()
 
     def _persist_all(self) -> None:
+        """在锁内复制 data 后落盘，避免长时间持锁。"""
         if not self._ready.is_set():
             return
         with self._lock:
@@ -533,6 +571,7 @@ class DataProvider:
         end_ms: Optional[int],
         limit: Optional[int],
     ) -> List[Dict[str, float]]:
+        """从内存读取已缓存的基础周期 K 线并按时间/limit 裁剪。"""
         with self._lock:
             candles = list(self.data.get(symbol, {}).get(timeframe, []))
         if start_ms is not None:
@@ -551,6 +590,7 @@ class DataProvider:
         end_time: Optional[object] = None,
         limit: Optional[int] = None,
     ) -> List[Dict[str, float]]:
+        """对外查询：基础周期直接返回；衍生周期从 derived_map 取 base，resample 后对齐时间戳再裁剪。"""
         if symbol not in self.symbols:
             raise HTTPException(status_code=404, detail=f"symbol {symbol} 不可用")
         self.wait_ready()
@@ -565,6 +605,7 @@ class DataProvider:
         if target_minutes is None:
             raise HTTPException(status_code=400, detail=f"不支持的时间周期: {timeframe}")
         target_ms = target_minutes * 60_000
+        # 起点前移一根目标周期长度，保证首根合成 K 边界完整
         adjusted_start = None if start_ms is None else max(0, start_ms - target_ms)
         base_candles = self._get_base_klines(symbol, base_tf, adjusted_start, end_ms, None)
         if not base_candles:
@@ -574,9 +615,11 @@ class DataProvider:
             return []
         df = df.drop_duplicates(subset=["timestamp"], keep="last").sort_values("timestamp")
         df["date"] = pd.to_datetime(df["timestamp"], unit="ms", utc=True)
+        # resample_to_interval 按「分钟」目标周期聚合 OHLCV
         resampled = self.resample_df(df, target_minutes)
         if resampled is None or resampled.empty:
             return []
+        # 统一得到毫秒 timestamp 列（resample 可能返回 date 或 DatetimeIndex）
         if "timestamp" in resampled.columns:
             resampled_df = resampled.copy()
         else:
@@ -621,6 +664,8 @@ class DataProvider:
 
 
 def create_app(provider: DataProvider) -> FastAPI:
+    """构造 FastAPI 应用：lifespan 内同步 initialize 并启动后台拉数。"""
+
     @asynccontextmanager
     async def lifespan(app: FastAPI):
         loop = asyncio.get_running_loop()
@@ -643,6 +688,7 @@ def create_app(provider: DataProvider) -> FastAPI:
 
     @app.get("/health")
     async def health() -> Dict[str, object]:
+        """存活检查：交易所、交易对、基础/衍生周期、是否已完成冷启动。"""
         return {
             "status": "ok",
             "exchange": provider.exchange_name,
@@ -655,6 +701,7 @@ def create_app(provider: DataProvider) -> FastAPI:
 
     @app.get("/timeframes")
     async def list_timeframes() -> Dict[str, List[str]]:
+        """返回配置的基础周期与可合成的衍生周期列表。"""
         provider.wait_ready()
         return {
             "base_timeframes": provider.timeframes,
@@ -670,11 +717,13 @@ def create_app(provider: DataProvider) -> FastAPI:
         end: Optional[int] = Query(None, description="结束时间戳(ms)"),
         limit: Optional[int] = Query(None, description="可选，限制返回数量"),
     ):
+        """按交易对与时间周期返回 OHLCV；tf 支持配置的基础周期及衍生合成周期。"""
         data = provider.get_klines(symbol=symbol, timeframe=tf, start_time=start, end_time=end, limit=limit)
         return data
 
     @app.get("/")
     async def root() -> Dict[str, object]:
+        """根路径：服务名、交易所、交易对与可用周期（含 ready 标志）。"""
         return {
             "service": "Data Provider",
             "exchange": provider.exchange_name,
@@ -689,6 +738,7 @@ def create_app(provider: DataProvider) -> FastAPI:
 
 
 def build_app() -> FastAPI:
+    """默认入口：从环境变量 CONFIG_PATH（或 config.json）加载配置并创建 FastAPI app。"""
     config_path = Path(os.getenv("CONFIG_PATH", "config.json"))
     provider = DataProvider(config_path)
     return create_app(provider)
@@ -698,6 +748,7 @@ app = build_app()
 
 
 def main() -> None:
+    """直接运行本模块时启动 uvicorn（监听 UVICORN_HOST / UVICORN_PORT）。"""
     host = os.getenv("UVICORN_HOST", "0.0.0.0")
     port = int(os.getenv("UVICORN_PORT", "9009"))
 

缠论.txt

@@ -1,26 +1,78 @@
+### 线段生成（get_seg_list，按代码实现）
+
+输入为已生成的笔列表 bi_list，输出为线段列表 seg_list。线段 ChanSEG 由若干笔 ChanBI 顺序组成。缠论里用「特征序列」刻画线段划分；本实现中 ChanSBI 即特征序列的元素（由同向笔经包含处理合并而成的一段区间，链成特征序列），在反向笔方向上维护 down_sbi_list / up_sbi_list 即维护该方向上的特征序列。当出现「非包含的新笔」、特征序列上可构成三元素结构时，对前一个 ChanSBI 做分型判断，决定是否结束当前线段并生成反向线段。循环末尾会维护 last_up_bi、last_down_bi 及 up_bi_list、down_bi_list；最后调用 cal_bi_zs(seg_list) 做线段与笔中枢的后续计算。函数末尾大段被注释掉的「线段破坏重划」逻辑当前未执行，以下不描述。
+
+1.  首根线段的产生（seg_list 为空时）
+
+    仅当当前笔 bi 满足 bi.check_overlap() 为真时才允许生成第一段线段；否则该笔不会开启线段。check_overlap 要求：bi 之后至少还有两笔（next、next.next），且 next.next 已确认（is_sure）。在此前提下：
+    - 若 bi 为向上笔：须满足 bi.high > bi.next.low 且 bi.high < bi.next.next.high（当前向上笔的高点落在后两笔的重叠/交错区间内）；
+    - 若 bi 为向下笔：须满足 bi.high > bi.next.high 且 bi.low > bi.next.next.low。
+    满足后：向上笔则新建方向为「上涨」的 ChanSEG，并以该笔初始化一条向上 ChanSBI；向下笔则新建「下跌」线段并初始化向下 ChanSBI。
+
+2.  已有线段时的同向延伸（笔与线段方向相同）
+
+    - 当前线段为上涨、新笔仍为向上：若已有 last_up_sbi，则用 ChanSBI.check_bi_included 判断新笔是否被并入当前向上的特征序列末项；不并入则链上追加新的 ChanSBI。当前笔始终 last_seg.add_bi(bi) 并入该线段。
+    - 当前线段为下跌、新笔仍为向下：对称地维护 last_down_sbi 与向下特征序列，并 last_seg.add_bi(bi)。
+
+3.  反向笔与特征序列（ChanSBI 链，为分型做准备）
+
+    - 当前线段为上涨、新笔为向下：在向下笔序列上维护 down_sbi_list（向下特征序列）。若链上已有不止一个向下 ChanSBI，且新向下笔不能 check_bi_included 入上一档 last_down_sbi，则先为当前笔新建 ChanSBI 并接到链上，再对「原来的」last_down_sbi 调用 check_fx()（此时该节点已有 pre 与 next，特征序列上相邻三元素可验分型）。
+    - 若向下链上仅有一个 ChanSBI：同样先判包含；若不包含则追加第二个节点；若尚未形成多节点，则用当前笔直接新建 ChanSBI 加入链。
+    - 当前线段为下跌、新笔为向上：在 up_sbi_list 上对称处理，对 last_up_sbi 调用 check_fx()。
+
+4.  ChanSBI.check_bi_included（特征序列元素的笔包含）
+
+    若当前特征序列项区间「左包含」新笔（实现上：当前 high、low 与新笔 high、low 满足代码中的包含关系，且与 pre 组合满足扩展条件），则将新笔并入当前 ChanSBI，并按方向更新极值（向下特征序列取更低价为 low，向上特征序列取更高价为 high），返回已包含；否则返回不包含，由上层新建下一档 ChanSBI。
+
+5.  ChanSBI.check_fx 与 has_fx_gap（特征序列上的分型与缺口）
+
+    当某 ChanSBI 同时存在 pre、next 且已 set_end_bi 时（特征序列上相邻三元素齐备）：
+    - 顶分型 TOP：中间元素高点高于前、后特征序列元素的高点；若中间低点高于前一段的高点，则 has_fx_gap 为真（顶分型处出现缺口类关系）。
+    - 底分型 BOTTOM：中间元素低点低于前、后特征序列元素的低点；若中间高点低于前一段的低点，则 has_fx_gap 为真。
+
+6.  出现分型后如何结束当前线段并开新线段（核心分支）
+
+    在上涨线段末端、向下笔链上形成顶分型 TOP 时（对 last_down_sbi.check_fx() 得到 TOP）：
+    - 若此前处于 look_for_top 状态：对 seg_list 中倒数第二条线段调用 set_sure(bi)，并清除 look_for_top。
+    - 若该顶分型 has_fx_gap：置 look_for_bottom；对当前线段 pre_set_end_bi（结束笔取到分型前一笔等，按代码索引）；以 last_down_sbi.start_bi 为起点新建下跌线段；向上特征序列（up_sbi_list）重置为仅含 last_up_bi 的新链。
+    - 若无缺口：若当前处于 look_for_bottom，则做「回补」式调整（如 set_start_bi、倒数第二条 set_end_bi、重置 up_sbi 等）并 last_seg.add_bi(bi)；否则对当前线段 set_end_bi，再新建下跌线段，并同样重置向上特征序列链。
+
+    在下跌线段末端、向上笔链上形成底分型 BOTTOM 时：与上对称，使用 look_for_bottom / look_for_top、last_up_sbi.has_fx_gap，并新开上涨线段、重置向下特征序列（down_sbi_list）。
+
+    上述分支中凡未单独说明的，仍会按路径将当前笔 add_bi 到相应线段。
+
+7.  小结
+
+    线段方向由首段 check_overlap 与后续「反向笔方向上的特征序列分型」共同决定；同向笔持续并入当前线段；反向笔先经包含处理叠成特征序列（ChanSBI 链），在三元素结构成立时识别顶/底分型，再结合是否缺口（has_fx_gap）与 look_for_top / look_for_bottom 状态机切换线段，并标记确认（set_sure）。
+
+
 ### 缠论中枢识别核心逻辑（按代码实现）
 
-1.  **基础中枢生成规则**
+依据缠论线段中枢定义计算中枢：`get_zs_list` 从第 4 根线段开始（线段列表索引 3），每 3 根线段为一组检查；上涨中枢为后中枢 zd > 前中枢 zg（不重叠上移），下跌中枢为后中枢 zg < 前中枢 zd（不重叠下移），盘整 / 扩张为后中枢与前中枢的整体区间（GG / DD）存在交集；中枢在初成三段之后，可按两段一组继续并入线段，扩展为 5 根、7 根……
-    - 从第4根线段起，每连续3段已确认的线段为一组；
+
-    - 3段线段极值须有重叠（min(三高点) > max(三低点)），否则跳过本组；
+1.  基础中枢生成规则
+    - 从第4根线段起（索引3），每连续3段已确认的线段为一组；
+    - 3段线段极值须有重叠（min(三高点) > max(三低点)，即 zg > zd），否则跳过本组；
     - 中枢核心区间（只读、扩展时不变）：
       - zg = 初始3段高点的最小值（重叠区间上沿）；
       - zd = 初始3段低点的最大值（重叠区间下沿）；
     - 中枢极值（扩展时可更新）：
       - GG = 参与中枢的所有线段的高点最大值；
       - DD = 参与中枢的所有线段的低点最小值。
-    - 上涨中枢：后中枢 zd > 前中枢 zg（后中枢整体上移且与前中枢不重叠）；
+    - 相对前一中枢的区间关系（用于区分走势类型）：
-    - 下跌中枢：后中枢 zg < 前中枢 zd（后中枢整体下移且与前中枢不重叠）；
+      - 上涨中枢：后中枢 zd > 前中枢 zg（与前一中枢 [zd,zg] 不重叠、整体上移，即「不重叠上移」）；
-    - 方向严格交替：上涨中枢 down→up→down，下跌中枢 up→down→up；
+      - 下跌中枢：后中枢 zg < 前中枢 zd（与前一中枢不重叠、整体下移，即「不重叠下移」）；
+      - 盘整 / 扩张：后中枢与前中枢在整体区间（GG / DD）上存在交集（与上述纯阶梯式上移、下移相区别）。
+    - 线段方向：在判定为上涨 / 下跌中枢时，须满足与中枢类型对应的严格交替——上涨中枢 down→up→down，下跌中枢 up→down→up（首段中枢仅按前三段形态定方向）。
 
-2.  **中枢扩展规则**
+2.  中枢扩展规则
-    - 当形成三段中枢后，找到中枢后已完成的两段线段为一组看是否满足中枢扩展规则
+    - 当形成三段中枢后，以中枢之后已完成的线段每两段为一组（与本中枢离开、回抽相关的成对线段）检查是否满足扩展条件；满足时可继续并入，使中枢覆盖 5 根、7 根……线段；
     - 若下一组两段的第二段与当前中枢区间有重叠（第二段高点≥当前zd且第二段低点≤当前zg），则进行扩展，不新建中枢；
     - 若下一组两段的第二段与当前中枢区间没有重叠，那么这两段都不并入当前中枢，当前中枢结束；从该两段组的第二段开始作为后续扫描起点，按中枢离开判断规则和新中枢生成规则继续；
     - 扩展时仅更新 GG、DD 和 seg_list；zg、zd 永不修改；
 
-3.  **新中枢生成规则**
+3.  新中枢生成规则
-    - 若下一组3段与当前中枢区间不重叠，且本组内逐根检查后没有任何线段与前中枢 [zd,zg] 重叠（即没有“离开后回抽回到前中枢”）但是需要满足上涨中枢和下跌中枢的规则；
+    - 若下一组3段与当前中枢区间不重叠，且本组内逐根检查后没有任何线段与前中枢 [zd,zg] 重叠（即没有“离开后回抽回到前中枢”），并满足上涨中枢或下跌中枢的区间关系（后中枢 zd > 前中枢 zg，或后中枢 zg < 前中枢 zd）及对应线段方向；
     - 新中枢类型按区间关系判定：后中枢 zd > 前中枢 zg → 上涨中枢（down→up→down）；后中枢 zg < 前中枢 zd → 下跌中枢（up→down→up）；
     - 新中枢的 zg/zd/GG/DD 仅基于自身初始3段计算；zg、zd 之后不再修改。
     
@@ -29,10 +81,3 @@
 注意，这里必须提醒一句，就是这在以前也曾说过，就是，如果线段中，最高或最低点不是线段的端点，那么，在任何以线段为基础的分析中，例如把线段为基础构成最小级别的中枢等，都可以把该线段标准化为最高低点都在端点。因为， 在以线段为基础的分析中，都把线段当成一个没有内部 结构的基本部件，所以，只需要关心这线段的实际区间就可以，这样就可以只看其高低点。
 经过标准化处理后，所有向上线段都是以最低点开始最高点结束，向下线段都是以最高点开始最低点结束，这样，所以线段的连接，就形成一条延续不断、首尾相连的折线，这样，复杂的图形，就会十分地标准化，也为后面的中枢、走势类型等分析提供了最标准且基础的部件。
 
-
-
-概率引擎
-
-
-策略引擎
-分批建仓