hikyuu 2.6.7__py3-none-win_amd64.whl → 2.6.8.2__py3-none-win_amd64.whl

hikyuu/include/hikyuu/global/agent/SpotAgent.h

@@ -68,6 +68,10 @@ public:
         return m_server_addr;
     }
 
+    bool isConnected() const {
+        return m_connected;
+    }
+
     /**
      * 增加收到 Spot 数据时的处理函数
      * @note 仅能在停止状态时执行此操作，否则将抛出异常
@@ -99,9 +103,9 @@ public:
     static void setQuotationServer(const string& server);
 
 private:
-    static string ms_pubUrl;  // 数据发送服务地址
-    static const char* ms_startTag;  // 批次数据接收起始标记，用于判断启动了新的批次数据接收
-    static const char* ms_endTag;  // 批次数据接收接收标记，用于判断该批次数据更新结束
+    static string ms_pubUrl;                 // 数据发送服务地址
+    static const char* ms_startTag;          // 批次数据接收起始标记，用于判断启动了新的批次数据接收
+    static const char* ms_endTag;            // 批次数据接收接收标记，用于判断该批次数据更新结束
     static const char* ms_spotTopic;         // 向数据发送服务订阅的主题
     static const size_t ms_startTagLength;   // 批次数据接收起始标记长度
     static const size_t ms_endTagLength;     // 批次数据接收结束标记长度
@@ -121,9 +125,10 @@ private:
     void work_thread();
 
 private:
-    enum STATUS { WAITING, RECEIVING };  // 等待新的批次数据，正在接收批次数据中
-    enum STATUS m_status = WAITING;      // 当前内部状态
-    std::atomic_bool m_stop = true;      // 结束代理工作标识
+    enum STATUS { WAITING, RECEIVING };    // 等待新的批次数据，正在接收批次数据中
+    enum STATUS m_status = WAITING;        // 当前内部状态
+    std::atomic_bool m_stop = true;        // 结束代理工作标识
+    std::atomic_bool m_connected = false;  // 是否已连接数据服务
 
     int m_revTimeout = 100;                         // 连接数据服务超时时长（毫秒）
     std::thread m_receiveThread;                    // 数据接收线程
@@ -137,7 +142,7 @@ private:
     // 下面属性被修改时需要加锁，以便可以使用多线程方式运行 strategy
     std::mutex m_mutex;
     list<std::function<void(const SpotRecord&)>> m_processList;  // 已注册的 spot 处理函数列表
-    list<std::function<void(Datetime)>> m_postProcessList;  // 已注册的批次后处理函数列表
+    list<std::function<void(Datetime)>> m_postProcessList;       // 已注册的批次后处理函数列表
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/indicator/Indicator.h

@@ -110,6 +110,9 @@ public:
      */
     value_t get(size_t pos, size_t num = 0) const;
 
+    value_t front(size_t num = 0) const;
+    value_t back(size_t num = 0) const;
+
     /**
      * 获取指定位置的日期
      * @param pos 结果集中的位置
@@ -322,6 +325,14 @@ inline Indicator::value_t Indicator::get(size_t pos, size_t num) const {
     return m_imp->get(pos, num);
 }
 
+inline Indicator::value_t Indicator::front(size_t num) const {
+    return m_imp->front(num);
+}
+
+inline Indicator::value_t Indicator::back(size_t num) const {
+    return m_imp->back(num);
+}
+
 inline Datetime Indicator::getDatetime(size_t pos) const {
     return m_imp ? m_imp->getDatetime(pos) : Null<Datetime>();
 }

hikyuu/include/hikyuu/indicator/Indicator2InImp.h

@@ -11,6 +11,7 @@
 
 namespace hku {
 
+/* note: 双输入但同一上下文*/
 class Indicator2InImp : public IndicatorImp {
 public:
     Indicator2InImp();
@@ -21,6 +22,14 @@ public:
 
     virtual IndicatorImpPtr _clone() override;
 
+    virtual bool needSelfAlikeCompare() const noexcept override {
+        return true;
+    }
+
+    virtual bool selfAlike(const IndicatorImp& other) const noexcept override;
+
+    virtual void getSelfInnerNodesWithInputConext(vector<IndicatorImpPtr>& nodes) const override;
+
 protected:
     Indicator prepare(const Indicator& ind);
 

hikyuu/include/hikyuu/indicator/IndicatorImp.h

@@ -78,6 +78,9 @@ public:
 
     value_t get(size_t pos, size_t num = 0) const;
 
+    value_t front(size_t num = 0) const;
+    value_t back(size_t num = 0) const;
+
     value_t getByDate(Datetime, size_t num = 0);
 
     Datetime getDatetime(size_t pos) const;
@@ -92,12 +95,6 @@ public:
     /** 以Indicator的方式获取指定的输出集，该方式包含了discard的信息 */
     IndicatorImpPtr getResult(size_t result_num);
 
-    /** 判断是否和另一个指标等效，即计算效果相同 */
-    bool alike(const IndicatorImp& other) const;
-
-    /** 判断指标公式中是否包含指定名称的指标（特殊用途） */
-    bool contains(const string& name) const;
-
     /**
      * 使用IndicatorImp(const Indicator&...)构造函数后，计算结果使用该函数,
      * 未做越界保护
@@ -149,9 +146,6 @@ public:
     typedef std::map<string, IndicatorImpPtr> ind_param_map_t;
     const ind_param_map_t& getIndParams() const;
 
-    value_t* data(size_t result_idx = 0);
-    value_t const* data(size_t result_idx = 0) const;
-
     // ===================
     //  子类接口
     // ===================
@@ -179,6 +173,45 @@ public:
 
     virtual void _dyn_calculate(const Indicator&);
 
+public:
+    // ===================
+    //  内部特殊用途公共接口
+    // ===================
+
+    /** 判断是否和另一个指标等效，即计算效果相同 */
+    bool alike(const IndicatorImp& other) const;
+
+    /** 判断指标公式中是否包含指定名称的指标（特殊用途） */
+    bool contains(const string& name) const;
+
+    value_t* data(size_t result_idx = 0);
+    value_t const* data(size_t result_idx = 0) const;
+
+    void getAllSubNodes(vector<IndicatorImpPtr>& nodes) const;
+
+    IndicatorImpPtr getRightNode() const;
+    IndicatorImpPtr getLeftNode() const;
+    IndicatorImpPtr getThreeNode() const;
+    void printTree(bool show_long_name = false) const;
+    void printAllSubTrees(bool show_long_name = false) const;
+    void printLeaves(bool show_long_name = false) const;
+
+    /* 特殊指标需自己实现 selfAlike 函数的, needSelfAlikeCompare 应返回 true */
+    virtual bool needSelfAlikeCompare() const noexcept {
+        return false;
+    }
+
+    // 特殊指标需自己实现 selfAlike 函数，返回true表示两个指标等效
+    virtual bool selfAlike(const IndicatorImp& other) const noexcept {
+        return false;
+    }
+
+    // 使用输入上下文的特殊指标获取内部节点，以便合入指标树优化
+    virtual void getSelfInnerNodesWithInputConext(vector<IndicatorImpPtr>& nodes) const {}
+
+    // 指定独立 ktype 的叶子节点重载获取内部子节点
+    virtual void getSeparateKTypeLeafSubNodes(vector<IndicatorImpPtr>& nodes) const {}
+
 private:
     void initContext();
     bool needCalculate();
@@ -198,17 +231,32 @@ private:
     void execute_weave();
     void execute_if();
 
-    std::vector<IndicatorImpPtr> getAllSubNodes() const;
+    static void inner_repeatALikeNodes(vector<IndicatorImpPtr>& sub_nodes);
     void repeatALikeNodes();
+    void repeatSeparateKTypeLeafALikeNodes();
+
+    void generateSpecialLeafSet();
 
     void _clearBuffer();
 
+    void _printTree(int depth = 0, bool isLast = true, bool show_long_name = false) const;
+
+    // 获取所有子树
+    vector<IndicatorImp*> getAllSubTrees() const;
+
+    // 获取子树中节点的数量
+    static size_t treeSize(IndicatorImp* tree);
+
+    static bool nodeInTree(IndicatorImp* node, IndicatorImp* tree);
+
 protected:
     static size_t _get_step_start(size_t pos, size_t step, size_t discard);
 
     // 用于动态参数时，更新 discard
     void _update_discard();
 
+    virtual bool isPythonObject() const;
+
 protected:
     string m_name;
     size_t m_discard;
@@ -296,17 +344,17 @@ private:
             ar& bs::make_nvp<size_t>(format("count_{}", i).c_str(), count);
             vector<value_t>& values = *m_pBuffer[i];
             values.resize(count);
-            for (size_t i = 0; i < count; i++) {
+            for (size_t j = 0; j < count; j++) {
                 std::string vstr;
                 ar >> boost::serialization::make_nvp<string>("item", vstr);
                 if (vstr == "nan") {
-                    values[i] = std::numeric_limits<double>::quiet_NaN();
+                    values[j] = std::numeric_limits<double>::quiet_NaN();
                 } else if (vstr == "+inf") {
-                    values[i] = std::numeric_limits<double>::infinity();
+                    values[j] = std::numeric_limits<double>::infinity();
                 } else if (vstr == "-inf") {
-                    values[i] = 0.0 - std::numeric_limits<double>::infinity();
+                    values[j] = 0.0 - std::numeric_limits<double>::infinity();
                 } else {
-                    values[i] = std::atof(vstr.c_str());
+                    values[j] = std::atof(vstr.c_str());
                 }
             }
         }
@@ -392,6 +440,10 @@ inline KData IndicatorImp::getContext() const {
     return getParam<KData>("kdata");
 }
 
+inline void IndicatorImp::setContext(const Stock& stock, const KQuery& query) {
+    setContext(stock.getKData(query));
+}
+
 inline const IndicatorImp::ind_param_map_t& IndicatorImp::getIndParams() const {
     return m_ind_params;
 }
@@ -412,6 +464,22 @@ inline size_t IndicatorImp::_get_step_start(size_t pos, size_t step, size_t disc
     return step == 0 || pos < discard + step ? discard : pos + 1 - step;
 }
 
+inline bool IndicatorImp::isPythonObject() const {
+    return false;
+}
+
+inline IndicatorImpPtr IndicatorImp::getRightNode() const {
+    return m_right;
+}
+
+inline IndicatorImpPtr IndicatorImp::getLeftNode() const {
+    return m_left;
+}
+
+inline IndicatorImpPtr IndicatorImp::getThreeNode() const {
+    return m_three;
+}
+
 } /* namespace hku */
 
 #if FMT_VERSION >= 90000

hikyuu/include/hikyuu/indicator/build_in.h

@@ -90,6 +90,7 @@
 #include "crt/PRICELIST.h"
 #include "crt/RECOVER.h"
 #include "crt/REF.h"
+#include "crt/REFX.h"
 #include "crt/REPLACE.h"
 #include "crt/RESULT.h"
 #include "crt/REVERSE.h"

hikyuu/include/hikyuu/indicator/crt/AMA.h

@@ -18,7 +18,8 @@ namespace hku {
  * @param n 计算均值的周期窗口，必须为大于2的整数，默认为10天
  * @param fast_n 对应快速周期N，默认为2
  * @param slow_n 对应慢速EMA线的N值，默认为30，不过当超过60左右该指标会收敛不会有太大的影响
- * @ingroup Indicator 具有2个结果集，result(0)为AMA，result(1)为ER
+ * @return 具有2个结果集，result(0)为AMA，result(1)为ER
+ * @ingroup Indicator
  */
 Indicator HKU_API AMA(int n = 10, int fast_n = 2, int slow_n = 30);
 Indicator HKU_API AMA(int n, int fast_n, const IndParam& slow_n);

hikyuu/include/hikyuu/indicator/crt/ATR.h

@@ -22,7 +22,7 @@ Indicator HKU_API ATR(int n = 14);
 
 /**
  * 平均真实波幅(Average True Range)
- * @param data 待计算的源数据
+ * @param kdata 待计算的源数据
  * @param n 计算均值的周期窗口，必须为大于1的整数
  * @ingroup Indicator
  */

hikyuu/include/hikyuu/indicator/crt/CONTEXT.h

@@ -15,6 +15,8 @@ namespace hku {
  * 独立上下文指标
  * @param ind 待包装指标
  * @param fill_null 是否填充空值，默认为 false
+ * @param use_self_ktype 使用自身独立上下文的K线类型，否则计算时将使用计算上下文中K线类型
+ * @param use_self_recover_type 使用自身独立上下文的复权类型，否则计算时将使用计算上下文中的复权类型
  * @ingroup Indicator
  */
 Indicator HKU_API CONTEXT(const Indicator& ind, bool fill_null = false, bool use_self_ktype = false,

hikyuu/include/hikyuu/indicator/crt/CYCLE.h

@@ -14,6 +14,9 @@ namespace hku {
 /**
  * PF调仓周期指标，主要用于PF调仓日验证，及作为SG
  * @param k 关联的K线数据
+ * @param adjust_cycle 调仓周期，默认为1
+ * @param adjust_mode 调仓方式，默认为"query" day|week|month|quarter|year|query
+ * @param delay_to_trading_day 延迟至交易日，当调仓日为非交易日时，自动延迟至下一个交易日作为调仓日
  * @ingroup Indicator
  */
 Indicator CYCLE(const KData& k, int adjust_cycle = 1, const string& adjust_mode = "query",

hikyuu/include/hikyuu/indicator/crt/DMA.h

@@ -23,7 +23,7 @@ namespace hku {
  * 算法：若Y=DMA(X,A) 则 Y=A*X+(1-A)*Y',其中Y'表示上一周期Y值。
  * 例如：DMA(CLOSE,VOL/CAPITAL)表示求以换手率作平滑因子的平均价
  * </pre>
- * @param ind1 待计算的数据
+ * @param x 待计算的数据
  * @param a 动态系数
  * @param fill_null 日期对齐时缺失数据填充nan值
  * @ingroup Indicator

hikyuu/include/hikyuu/indicator/crt/IC.h

@@ -14,28 +14,36 @@ namespace hku {
 
 /**
  * @brief 计算指定的因子相对于参考证券的 IC （实际为 RankIC）
+ * @note IC 原本需要 “t 时刻因子值→t+1 时刻收益”，改为计算 “t 时刻因子值→t 时刻之前 N
+        天的收益”（比如过去 5 天的收益），并称之为 “当前 IC”。(否则当前值都会是缺失NA)
+        如需严格“t 时刻因子值→t+1 时刻收益“计算，请设置 strict=True (注意此模式下, 后n位为 NA)
  * @param stks 证券组合
  * @param query 查询条件
  * @param ref_stk 参照证券，默认 sh000300 沪深300
  * @param n 时间窗口 (对应 n 日收益率)
  * @param spearman 使用 spearman 相关系数，否则为 pearson
+ * @param strict 严格模式， 遵循IC定义“t 时刻因子值→t+1 时刻收益”
  * @return Indicator
  * @ingroup Indicator
  */
 Indicator HKU_API IC(const StockList& stks, const KQuery& query,
-                     const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true);
+                     const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true,
+                     bool strict = false);
 
 Indicator HKU_API IC(const Block& blk, const KQuery& query,
-                     const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true);
+                     const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true,
+                     bool strict = false);
 
 inline Indicator IC(const Indicator& ind, const StockList& stks, const KQuery& query,
-                    const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true) {
-    return IC(stks, query, ref_stk, n, spearman)(ind);
+                    const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true,
+                    bool strict = false) {
+    return IC(stks, query, ref_stk, n, spearman, strict)(ind);
 }
 
 inline Indicator IC(const Indicator& ind, const Block& blk, const KQuery& query,
-                    const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true) {
-    return IC(blk, query, ref_stk, n, spearman)(ind);
+                    const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true,
+                    bool strict = false) {
+    return IC(blk, query, ref_stk, n, spearman, strict)(ind);
 }
 
 }  // namespace hku

hikyuu/include/hikyuu/indicator/crt/ICIR.h

@@ -16,6 +16,9 @@ namespace hku {
  * @brief 计算指定的因子相对于参考证券的 ICIR （实际为 RankIC）
  * @details IR:信息比率(Information Ratio,简称IR)=
  * IC的多周期均值/IC的标准方差，代表因子获取稳定Alpha的能力。
+ * @note IC 原本需要 “t 时刻因子值→t+1 时刻收益”，改为计算 “t 时刻因子值→t 时刻之前 N
+ *       天的收益”（比如过去 5 天的收益），并称之为 “当前 IC”。(否则当前值都会是缺失NA)
+ *       如需严格“t 时刻因子值→t+1 时刻收益“计算，请设置 strict=True (注意此模式下, 后n位为 NA)
  * @param ind 因子公式
  * @param stks 证券组合
  * @param query 查询条件
@@ -23,13 +26,14 @@ namespace hku {
  * @param n IC对应的N日收益率
  * @param rolling_n 滚动时间窗口
  * @param spearman 使用 spearman 相关系数，否则为 pearson
+ * @param strict 是否严格模式
  * @return Indicator
  * @ingroup Indicator
  */
 inline Indicator ICIR(const Indicator& ind, const StockList& stks, const KQuery& query,
                       const Stock& ref_stk = getStock("sh000300"), int n = 1, int rolling_n = 120,
-                      bool spearman = true) {
-    Indicator ic = IC(ind, stks, query, ref_stk, n, spearman);
+                      bool spearman = true, bool strict = false) {
+    Indicator ic = IC(ind, stks, query, ref_stk, n, spearman, strict);
     Indicator x = MA(ic, rolling_n) / STDEV(ic, rolling_n);
     x.name("ICIR");
     x.setParam<int>("n", n);
@@ -39,8 +43,8 @@ inline Indicator ICIR(const Indicator& ind, const StockList& stks, const KQuery&
 
 inline Indicator ICIR(const Indicator& ind, const Block& blk, const KQuery& query,
                       const Stock& ref_stk = getStock("sh000300"), int n = 1, int rolling_n = 120,
-                      bool spearman = true) {
-    Indicator ic = IC(ind, blk, query, ref_stk, n, spearman);
+                      bool spearman = true, bool strict = false) {
+    Indicator ic = IC(ind, blk, query, ref_stk, n, spearman, strict);
     Indicator x = MA(ic, rolling_n) / STDEV(ic, rolling_n);
     x.name("ICIR");
     x.setParam<int>("n", n);

hikyuu/include/hikyuu/indicator/crt/INSUM.h

@@ -28,4 +28,6 @@ Indicator HKU_API INSUM(const Block& block, const KQuery& query, const Indicator
 
 Indicator HKU_API INSUM(const Block& block, const Indicator& ind, int mode, bool fill_null = true);
 
+Indicator HKU_API INSUM(const Block& block, int mode, bool fill_null);
+
 }  // namespace hku

hikyuu/include/hikyuu/indicator/crt/PRICELIST.h

@@ -23,6 +23,8 @@ namespace hku {
  */
 Indicator HKU_API PRICELIST(const PriceList& data, int discard = 0);
 Indicator HKU_API PRICELIST(const PriceList& data, const DatetimeList& ds, int discard = 0);
+Indicator HKU_API PRICELIST(size_t size, double value, int discard = 0);
+Indicator HKU_API PRICELIST(const DatetimeList& dates, double value, int discard = 0);
 Indicator HKU_API PRICELIST();
 
 /**

hikyuu/include/hikyuu/indicator/crt/REFX.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-08-22
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/**
+ * REF增强（不安全引用）, 用于数据左移或右移，周期为整数时，功能同 REF
+ * @note 不应用于回测，通常用于AI模型训练等场景
+ * @param n 引用周期
+ * @ingroup Indicator
+ */
+Indicator HKU_API REFX(int n);
+inline Indicator HKU_API REFX(const Indicator& ind, int n) {
+    return REFX(n)(ind);
+}
+
+}  // namespace hku

hikyuu/include/hikyuu/indicator/crt/SLICE.h

@@ -24,20 +24,20 @@ Indicator HKU_API SLICE(const PriceList& data, int64_t start, int64_t end);
  * 获取某指标中指定范围的数据
  * @param start 起始范围，可为负数
  * @param end 终止范围（不包含本身），可为负数
- * @param result_index 源数据中指定的结果集
+ * @param result_index 源数据中指定的结果集, 小于0时表示全部
  * @ingroup Indicator
  */
-Indicator HKU_API SLICE(int64_t start, int64_t end, int result_index = 0);
+Indicator HKU_API SLICE(int64_t start, int64_t end, int result_index = -1);
 
 /**
  * 获取某指标中指定范围的数据
  * @param ind 源数据
  * @param start 起始范围，可为负数
  * @param end 终止范围（不包含本身），可为负数
- * @param result_index 源数据中指定的结果集
+ * @param result_index 源数据中指定的结果集，小于0时表示全部
  * @ingroup Indicator
  */
-inline Indicator SLICE(const Indicator& ind, int64_t start, int64_t end, int result_index = 0) {
+inline Indicator SLICE(const Indicator& ind, int64_t start, int64_t end, int result_index = -1) {
     return SLICE(start, end, result_index)(ind);
 }
 

hikyuu/include/hikyuu/indicator/crt/SPEARMAN.h

@@ -12,9 +12,10 @@ namespace hku {
 
 /**
  * Spearman 相关系数
- * @param ind1 指标1
- * @param ind2 指标2
+ * @param ind 指标1
+ * @param ref_ind 指标2
  * @param n 滚动窗口(大于2 或 等于0)，等于0时，代表 n 实际使用 ind 的长度
+ * @param fill_null 填充缺失值
  * @ingroup Indicator
  */
 Indicator HKU_API SPEARMAN(const Indicator& ind, const Indicator& ref_ind, int n = 0,

hikyuu/include/hikyuu/indicator/imp/IContext.h

@@ -21,6 +21,11 @@ public:
     virtual string formula() const override;
     virtual void _calculate(const Indicator& data) override;
     virtual IndicatorImpPtr _clone() override;
+    virtual bool needSelfAlikeCompare() const noexcept override {
+        return true;
+    }
+
+    virtual bool selfAlike(const IndicatorImp& other) const noexcept override;
 
     KData getContextKdata() const;
 

hikyuu/include/hikyuu/indicator/imp/ICval.h

@@ -22,6 +22,12 @@ public:
     ICval(double value, size_t discard);
     virtual ~ICval();
     virtual void _checkParam(const string& name) const override;
+
+    virtual bool needSelfAlikeCompare() const noexcept override {
+        return true;
+    }
+
+    virtual bool selfAlike(const IndicatorImp& other) const noexcept override;
 };
 
 } /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/IDropna.h

@@ -22,6 +22,15 @@ class IDropna : public IndicatorImp {
 public:
     IDropna();
     virtual ~IDropna();
+
+    virtual bool needSelfAlikeCompare() const noexcept override {
+        return true;
+    }
+
+    // 禁止子节点合并, 上级默认已为 false
+    // virtual bool selfAlike(const IndicatorImp& other) const noexcept override {
+    //     return false;
+    // }
 };
 
 } /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/IIc.h

@@ -14,7 +14,8 @@ namespace hku {
 class IIc : public IndicatorImp {
 public:
     IIc();
-    IIc(const StockList& stks, const KQuery& query, int n, const Stock& ref_stk, bool spearman);
+    IIc(const StockList& stks, const KQuery& query, int n, const Stock& ref_stk, bool spearman,
+        bool strict);
     virtual ~IIc();
 
     virtual void _checkParam(const string& name) const override;

hikyuu/include/hikyuu/indicator/imp/IPriceList.h

@@ -21,6 +21,7 @@ class IPriceList : public IndicatorImp {
 public:
     IPriceList();
     IPriceList(const PriceList&, int discard);
+    IPriceList(size_t size, double value, int discard);
     virtual ~IPriceList();
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/indicator/imp/IRefX.h

@@ -0,0 +1,23 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-08-22
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class IRefX : public IndicatorImp {
+    INDICATOR_IMP(IRefX)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IRefX();
+    virtual ~IRefX();
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/plugin/backtest.h

@@ -22,6 +22,8 @@ namespace hku {
  * @param ref_market 所属市场
  * @param mode 模式  0: 当前bar收盘价执行买卖操作；1: 下一bar开盘价执行买卖操作;
  * @param support_short 是否支持做空
+ * @param slip 滑点算法
+ * @ingroup Strategy
  */
 void HKU_API backtest(const StrategyContext& context, const std::function<void(Strategy*)>& on_bar,
                       const TradeManagerPtr& tm, const Datetime& start_date,

hikyuu/include/hikyuu/plugin/extind.h

@@ -11,6 +11,11 @@
 
 namespace hku {
 
+/**
+ * @ingroup Indicator
+ * @{
+ */
+
 /**
  * @brief 将指标数据转换到指定周期
  * @param ktype 指定周期
@@ -146,5 +151,45 @@ inline Indicator WITHHOUR4(const Indicator& ind, bool fill_null = false) {
  */
 Indicator HKU_API RANK(const Block& block, const Indicator& ref_ind, int mode = 0,
                        bool fill_null = true, const string& market = "SH");
+Indicator HKU_API RANK(const Block& block, int mode = 0, bool fill_null = true,
+                       const string& market = "SH");
 
+/**
+ * @brief 聚合其他K线周期统计值，聚合计算指定K线类型数据均值到以上下文中的K线周期
+ * @param ktype 指定K线周期
+ * @param fill_null 是否填充null数据
+ * @param unit 聚合周期单位，默认为1。按上下文K线 unit 个周期计算
+ * @return Indicator
+ */
+#define AGG_FUNC_DEFINE(agg_name)                                                              \
+    Indicator HKU_API agg_name(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN, \
+                               bool fill_null = false, int unit = 1);
+
+#define AGG_FUNC_IMP(agg_name)                                                                   \
+    Indicator HKU_API agg_name(const Indicator& ind, const KQuery::KType& ktype, bool fill_null, \
+                               int unit) {                                                       \
+        Parameter params;                                                                        \
+        params.set<string>("ktype", ktype);                                                      \
+        params.set<bool>("fill_null", fill_null);                                                \
+        params.set<int>("unit", unit);                                                           \
+        return getExtIndicator(#agg_name, ind, params);                                          \
+    }
+
+AGG_FUNC_DEFINE(AGG_MEAN)
+AGG_FUNC_DEFINE(AGG_COUNT)
+AGG_FUNC_DEFINE(AGG_SUM)
+AGG_FUNC_DEFINE(AGG_MAX)
+AGG_FUNC_DEFINE(AGG_MIN)
+AGG_FUNC_DEFINE(AGG_MAD)
+AGG_FUNC_DEFINE(AGG_MEDIAN)
+AGG_FUNC_DEFINE(AGG_PROD)
+
+Indicator HKU_API AGG_STD(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN,
+                          bool fill_null = false, int unit = 1, int ddof = 1);
+Indicator HKU_API AGG_VAR(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN,
+                          bool fill_null = false, int unit = 1, int ddof = 1);
+Indicator HKU_API AGG_QUANTILE(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN,
+                               bool fill_null = false, int unit = 1, double quantile = 0.75);
+
+/** @} */
 }  // namespace hku