hikyuu 2.6.8.5__py3-none-win_amd64.whl → 2.7.0__py3-none-win_amd64.whl

hikyuu/include/hikyuu/indicator/crt/HSL.h

@@ -20,8 +20,8 @@ namespace hku {
  * @param k 关联的K线数据
  * @ingroup Indicator
  */
-Indicator HSL(const KData& k);
-Indicator HSL();
+Indicator HKU_API HSL(const KData& k);
+Indicator HKU_API HSL();
 
 }  // namespace hku
 #endif /* INDICATOR_CRT_HSL_H_ */

hikyuu/include/hikyuu/indicator/crt/QUANTILE_TRUNC.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/**
+ * 使用分位数法则进行数据截断处理
+ * @param int n 窗口大小
+ * @param quantile_min 最小分位数
+ * @param quantile_max 最大分位数
+ * @return Indicator
+ * @ingroup Indicator
+ */
+Indicator HKU_API QUANTILE_TRUNC(int n = 60, double quantile_min = 0.01,
+                                 double quantile_max = 0.99);
+
+inline Indicator HKU_API QUANTILE_TRUNC(const Indicator& data, int n = 60,
+                                        double quantile_min = 0.01, double quantile_max = 0.99) {
+    return QUANTILE_TRUNC(n, quantile_min, quantile_max)(data);
+}
+
+}  // namespace hku

hikyuu/include/hikyuu/indicator/crt/TURNOVER.h

@@ -5,6 +5,7 @@
  *      Author: fasiondog
  */
 
+#pragma once
 #include "../Indicator.h"
 
 namespace hku {

hikyuu/include/hikyuu/indicator/crt/ZSCORE.h

@@ -12,9 +12,9 @@
 namespace hku {
 
 /**
- * 对数据进行ZScore标准化，可选进行极值排除
+ * 对数据进行ZScore标准化(3sigma)进行极值处理
  * @note 非窗口滚动，如需窗口滚动的标准化，直接 (x - MA(x, n)) / STDEV(x, n) 即可
- * @param outExtreme 指示剔除极值
+ * @param outExtreme 指示剔除极值（即截断极值，超过限制的用限制值替代）
  * @param nsigma 剔除极值时使用的 nsigma 倍 sigma
  * @param recursive 是否进行递归剔除极值
  * @return Indicator

hikyuu/include/hikyuu/indicator/imp/IQuantileTrunc.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/* 分位数截断处理 */
+class IQuantileTrunc : public IndicatorImp {
+    INDICATOR_IMP(IQuantileTrunc)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IQuantileTrunc();
+    virtual ~IQuantileTrunc();
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/misc.h

@@ -0,0 +1,38 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-17
+ *      Author: fasiondog
+ *
+ *  部分杂类函数
+ */
+
+#pragma once
+
+#include "trade_sys/system/System.h"
+#include "trade_sys/portfolio/Portfolio.h"
+
+namespace hku {
+
+/**
+ * @brief 并行运行系统
+ * @param system_list 系统列表
+ * @param query 系统运行查询条件
+ * @param reset 执行前是否依据系统部件共享属性复位
+ * @param resetAll 强制复位所有部件
+ * @return 各系统Query周期内各时间点的资金列表
+ */
+vector<FundsList> HKU_API parallel_run_sys(const SystemList& system_list, const KQuery& query,
+                                           bool reset = true, bool resetAll = false);
+
+/**
+ * @brief 并行运行组合
+ * @param pf_list 组合列表
+ * @param query 组合运行查询条件
+ * @param force 强制复位
+ * @return vector<FundsList>
+ */
+vector<FundsList> HKU_API parallel_run_pf(const vector<PFPtr>& pf_list, const KQuery& query,
+                                          bool force = false);
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/dataserver.h

@@ -14,7 +14,8 @@
 namespace hku {
 
 void HKU_API startDataServer(const std::string& addr = "tcp://0.0.0.0:9201", size_t work_num = 2,
-                             bool save_tick = false, bool buf_tick = false);
+                             bool save_tick = false, bool buf_tick = false,
+                             const std::string& parquet_path = std::string());
 
 void HKU_API stopDataServer();
 

hikyuu/include/hikyuu/plugin/device.h

@@ -11,6 +11,13 @@
 
 namespace hku {
 
+/**
+ * @brief 绑定授权码
+ * @param email 邮箱
+ * @param active_code 授权码
+ */
+void HKU_API bindEmail(const std::string& email, const std::string& active_code);
+
 /**
  * @brief 激活设备
  * @param active_code 授权码
@@ -30,4 +37,7 @@ std::string HKU_API fetchTrialLicense(const std::string& email);
 /** 检查授权是否有效 */
 bool HKU_API isValidLicense();
 
+/** 获取授权到期时间 */
+Datetime HKU_API getExpireDate();
+
 }  // namespace hku

hikyuu/include/hikyuu/plugin/extind.h

@@ -191,5 +191,42 @@ Indicator HKU_API AGG_VAR(const Indicator& ind, const KQuery::KType& ktype = KQu
 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);
 
+using agg_func_t = std::function<double(const DatetimeList& src_ds, const Indicator::value_t* src,
+                                        size_t group_start, size_t group_last)>;
+Indicator HKU_API AGG_FUNC(const Indicator& ind, agg_func_t agg_func,
+                           const KQuery::KType& ktype = KQuery::MIN, bool fill_null = false,
+                           int unit = 1);
+
+/**
+ * @brief 按周期分组就散
+ * @param ktype 指定K线周期
+ * @param unit 分组周期单位，默认为1。按 ktype 参数 unit 个周期计算
+ * @return Indicator
+ */
+#define GROUP_FUNC_DEFINE(group_name)                                                            \
+    Indicator HKU_API group_name(const Indicator& ind, const KQuery::KType& ktype = KQuery::DAY, \
+                                 int unit = 1);
+
+#define GROUP_FUNC_IMP(group_name)                                                             \
+    Indicator HKU_API group_name(const Indicator& ind, const KQuery::KType& ktype, int unit) { \
+        Parameter params;                                                                      \
+        params.set<string>("ktype", ktype);                                                    \
+        params.set<int>("unit", unit);                                                         \
+        return getExtIndicator(#group_name, ind, params);                                      \
+    }
+
+GROUP_FUNC_DEFINE(GROUP_COUNT)
+GROUP_FUNC_DEFINE(GROUP_SUM)
+GROUP_FUNC_DEFINE(GROUP_MEAN)
+GROUP_FUNC_DEFINE(GROUP_PROD)
+GROUP_FUNC_DEFINE(GROUP_MIN)
+GROUP_FUNC_DEFINE(GROUP_MAX)
+
+using group_func_t =
+  std::function<void(Indicator::value_t* dst, const DatetimeList& src_ds,
+                     const Indicator::value_t* src, size_t group_start, size_t group_last)>;
+Indicator HKU_API GROUP_FUNC(const Indicator& ind, group_func_t group_func,
+                             const KQuery::KType& ktype = KQuery::DAY, int unit = 1);
+
 /** @} */
 }  // namespace hku

hikyuu/include/hikyuu/plugin/interface/DataServerPluginInterface.h

@@ -16,8 +16,8 @@ public:
     DataServerPluginInterface() = default;
     virtual ~DataServerPluginInterface() = default;
 
-    virtual void start(const std::string& addr, size_t work_num, bool save_tick,
-                       bool buf_tick) noexcept = 0;
+    virtual void start(const std::string& addr, size_t work_num, bool save_tick, bool buf_tick,
+                       const std::string& parquet_path) noexcept = 0;
     virtual void stop() noexcept = 0;
 };
 

hikyuu/include/hikyuu/plugin/interface/DevicePluginInterface.h

@@ -16,11 +16,13 @@ public:
     DevicePluginInterface() = default;
     virtual ~DevicePluginInterface() = default;
 
+    virtual void bind(const std::string& email, const std::string& active_code) noexcept = 0;
     virtual void activate(const std::string& active_code, bool replace) noexcept = 0;
     virtual std::string viewLicense() noexcept = 0;
     virtual void removeLicense() noexcept = 0;
     virtual std::string fetchTrialLicense(const std::string& email) noexcept = 0;
     virtual bool isValidLicsense() noexcept = 0;
+    virtual Datetime getExpireDate() const noexcept = 0;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/plugin/interface/ExtendIndicatorsPluginInterface.h

@@ -21,6 +21,18 @@ public:
 
     virtual Indicator getIndicator(const std::string& name, const Indicator& ref_ind,
                                    const Parameter& params) const = 0;
+
+    using agg_func_t =
+      std::function<Indicator::value_t(const DatetimeList& src_ds, const Indicator::value_t* src,
+                                       size_t group_start, size_t group_last)>;
+    virtual Indicator getAggFuncIndicator(const Indicator& ref_ind, agg_func_t agg_func,
+                                          const Parameter& params) const = 0;
+
+    using group_func_t =
+      std::function<void(Indicator::value_t* dst, const DatetimeList& src_ds,
+                         const Indicator::value_t* src, size_t group_start, size_t group_last)>;
+    virtual Indicator getGroupFuncIndicator(const Indicator& ref_ind, group_func_t group_func,
+                                            const Parameter& params) const = 0;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/plugin/interface/plugins.h

@@ -18,10 +18,6 @@
 #include "DataDriverPluginInterface.h"
 #include "HkuExtraPluginInterface.h"
 
-#if HKU_ENABLE_ARROW
-#include "HkuViewsPluginInterface.h"
-#endif
-
 namespace hku {
 
 #define HKU_PLUGIN_BACKTEST "backtest"
@@ -32,6 +28,5 @@ namespace hku {
 #define HKU_PLUGIN_TMREPORT "tmreport"
 #define HKU_PLUGIN_CLICKHOUSE_DRIVER "clickhousedriver"
 #define HKU_PLUGIN_HKU_EXTRA "hkuextra"
-#define HKU_PLUGIN_HKU_VIEWS "hkuviews"
 
 }  // namespace hku

hikyuu/include/hikyuu/python/pybind_utils.h

@@ -10,9 +10,6 @@
 #define HIKYUU_PYTHON_BIND_UTILS_H
 
 #include <hikyuu/config.h>
-#if HKU_ENABLE_ARROW
-#include <arrow/api.h>
-#endif
 #include <pybind11/pybind11.h>
 
 #include <pybind11/operators.h>
@@ -127,15 +124,6 @@ inline bool check_pyfunction_arg_num(const py::object& func, size_t arg_num) {
  */
 size_t utf8_to_utf32(const std::string& utf8_str, int32_t* out, size_t out_len) noexcept;
 
-#if HKU_ENABLE_ARROW
-/*
- * 将arrow::Table转换为 pyarrow::Table
- * @param table 待转换的arrow::Table
- * @return 转换后的py::object
- */
-py::object to_pyarrow_table(const std::shared_ptr<arrow::Table>& table);
-#endif
-
 }  // namespace hku
 
 #endif  // HIKYUU_PYTHON_BIND_UTILS_H

hikyuu/include/hikyuu/strategy/RunSystemInStrategy.h

@@ -20,6 +20,9 @@ public:
 
     void run(const Stock& stock);
 
+    void runMomentOnOpen(const Stock& stock);
+    void runMomentOnClose(const Stock& stock);
+
 private:
     SYSPtr m_sys;
     OrderBrokerPtr m_broker;

hikyuu/include/hikyuu/trade_manage/Performance.h

@@ -6,14 +6,15 @@
  */
 
 #pragma once
-#ifndef PERFORMANCE_H_
-#define PERFORMANCE_H_
 
-#include <boost/function.hpp>
 #include "TradeManagerBase.h"
 
 namespace hku {
 
+#if defined(_MSC_VER)
+#pragma warning(disable : 4251)
+#endif
+
 /**
  * 简单绩效统计
  * @ingroup Performance
@@ -84,4 +85,3 @@ private:
 };
 
 } /* namespace hku */
-#endif /* PERFORMANCE_H_ */

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include "../utilities/Parameter.h"
 #include "TradeRecord.h"
 #include "PositionRecord.h"
 #include "PositionExtInfo.h"
@@ -17,6 +16,7 @@
 #include "TradeCostBase.h"
 #include "OrderBrokerBase.h"
 #include "crt/TC_Zero.h"
+#include "../utilities/Parameter.h"
 
 namespace hku {
 
@@ -825,6 +825,15 @@ inline void TradeManagerBase::paramChanged() {}
 typedef shared_ptr<TradeManagerBase> TradeManagerPtr;
 typedef shared_ptr<TradeManagerBase> TMPtr;
 
+/**
+ * 从账户列表中一次性获取资金列表
+ * @param tm_list
+ * @param ref_dates
+ * @return vector<FundsList>
+ * @ingroup TradeManagerClass
+ */
+vector<FundsList> HKU_API getFundsList(const vector<TMPtr>& tm_list, const DatetimeList& ref_dates);
+
 inline std::ostream& operator<<(std::ostream& os, const TradeManagerBase& tm) {
     os << tm.str();
     return os;

hikyuu/include/hikyuu/trade_sys/moneymanager/imp/FixedCapitalFundsMM.h

@@ -6,8 +6,6 @@
  */
 
 #pragma once
-#ifndef TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_
-#define TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_
 
 #include "../MoneyManagerBase.h"
 
@@ -24,5 +22,3 @@ public:
 };
 
 } /* namespace hku */
-
-#endif /* TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_ */

hikyuu/include/hikyuu/trade_sys/multifactor/MultiFactorBase.h

@@ -8,7 +8,8 @@
 #pragma once
 
 #include "hikyuu/KData.h"
-#include "ScoreRecord.h"
+#include "ScoresFilterBase.h"
+#include "buildin_norm.h"
 
 namespace hku {
 
@@ -108,6 +109,9 @@ public:
     ScoreRecordList getScores(const Datetime& date, size_t start, size_t end,
                               std::function<bool(const Datetime&, const ScoreRecord&)>&& filter);
 
+    ScoreRecordList getScores(const Datetime& date, size_t start, size_t end,
+                              const ScoresFilterPtr& filter);
+
     /** 获取所有截面数据，已按降序排列 */
     const vector<ScoreRecordList>& getAllScores();
 
@@ -128,12 +132,29 @@ public:
     Indicator getICIR(int ir_n, int ic_n = 0);
 
     /**
-     * 获取所有处理过的原始因子值（归一化、标准化）
+     * 获取所有处理过的原始因子值（归一化、标准化）。每次都会计算。
      * @note 考虑到内存占用，该数据没有缓存，一般用与测试或者想查看处理过的原始因子值
      * @return vector<IndicatorList>  stks x inds
      */
     vector<IndicatorList> getAllSrcFactors();
 
+    /**
+     * 设置因子标准化/归一化操作
+     * @param norm 标准化操作
+     */
+    void setNormalize(NormPtr norm);
+
+    /**
+     * 对指定名称的指标应用特定的标准化/归一化、行业中性化、风格因子中性化操作。
+     * @note 标准化操作、行业中性化、风格因子中性化彼此无关，可同时指定也可分开指定。
+     * @param name 指标名称
+     * @param norm 标准化操作
+     * @param category 指标所属板块类别(需要中性化指定)
+     * @param style_inds 指标风格列表
+     */
+    void addSpecialNormalize(const string& name, NormalizePtr norm, const string& category = "",
+                             const IndicatorList& style_inds = IndicatorList());
+
     void reset();
 
     typedef std::shared_ptr<MultiFactorBase> MultiFactorPtr;
@@ -154,7 +175,9 @@ private:
 
     void initParam();
 
-protected:
+    // 构造每个指标构造行业哑变量，以便进行行业中性化处理
+    unordered_map<string, PriceList> _buildDummyIndex();
+
     void _buildIndex();      // 计算完成后创建截面索引
     void _buildIndexDesc();  // 创建降序排列的索引
     void _buildIndexAsc();   // 创建升序排列的索引
@@ -178,6 +201,12 @@ protected:
     vector<ScoreRecordList> m_stk_factor_by_date;
     Indicator m_ic;
 
+    NormPtr m_norm;                                    // 全局标准化/归一化操作
+    unordered_map<string, NormPtr> m_special_norms;    // 对特定指标执行特定的标准化操作
+    unordered_map<string, string> m_special_category;  // 对特定指标执行行业中性化时指定的板块分类
+    unordered_map<string, IndicatorList>
+      m_special_style_inds;  // 对特定指标执行风格因子中性化时指定的风格因子
+
 private:
     std::mutex m_mutex;
     bool m_calculated{false};
@@ -197,6 +226,8 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_ref_stk);
         ar& BOOST_SERIALIZATION_NVP(m_query);
         ar& BOOST_SERIALIZATION_NVP(m_ref_dates);
+        ar& BOOST_SERIALIZATION_NVP(m_special_norms);
+        ar& BOOST_SERIALIZATION_NVP(m_special_category);
         // 以下不需要保存，加载后重新计算
         // ar& BOOST_SERIALIZATION_NVP(m_stk_map);
         // ar& BOOST_SERIALIZATION_NVP(m_all_factors);
@@ -215,6 +246,8 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_ref_stk);
         ar& BOOST_SERIALIZATION_NVP(m_query);
         ar& BOOST_SERIALIZATION_NVP(m_ref_dates);
+        ar& BOOST_SERIALIZATION_NVP(m_special_norms);
+        ar& BOOST_SERIALIZATION_NVP(m_special_category);
         // ar& BOOST_SERIALIZATION_NVP(m_stk_map);
         // ar& BOOST_SERIALIZATION_NVP(m_all_factors);
         // ar& BOOST_SERIALIZATION_NVP(m_date_index);

hikyuu/include/hikyuu/trade_sys/multifactor/NormalizeBase.h

@@ -0,0 +1,125 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/utilities/Parameter.h"
+
+namespace hku {
+
+/**
+ * 时间截面数据归一化基类
+ */
+class HKU_API NormalizeBase {
+    PARAMETER_SUPPORT_WITH_CHECK
+
+public:
+    NormalizeBase() = default;
+    NormalizeBase(const string& name) : m_name(name) {}
+
+    NormalizeBase(const NormalizeBase& other) : m_params(other.m_params), m_name(other.m_name) {}
+
+    virtual ~NormalizeBase() = default;
+
+    /** 获取名称 */
+    const string& name() const {
+        return m_name;
+    }
+
+    /** 设置名称 */
+    void name(const string& name) {
+        m_name = name;
+    }
+
+    typedef std::shared_ptr<NormalizeBase> NormPtr;
+    NormPtr clone();
+
+    virtual NormPtr _clone() = 0;
+
+    virtual PriceList normalize(const PriceList& data) = 0;
+
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
+protected:
+    string m_name;
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void save(Archive& ar, const unsigned int version) const {
+        ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+#if HKU_SUPPORT_SERIALIZATION
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(MultiFactorBase)
+#endif
+
+#if HKU_SUPPORT_SERIALIZATION
+/**
+ * 对于没有私有变量的继承子类，可直接使用该宏定义序列化
+ * @code
+ * class Drived: public NormalizeBase {
+ *     NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+ *
+ * public:
+ *     Drived();
+ *     ...
+ * };
+ * @endcode
+ * @ingroup MultiFactor
+ */
+#define NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION               \
+private:                                                        \
+    friend class boost::serialization::access;                  \
+    template <class Archive>                                    \
+    void serialize(Archive& ar, const unsigned int version) {   \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(NormalizeBase); \
+    }
+#else
+#define NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+typedef std::shared_ptr<NormalizeBase> NormPtr;
+typedef std::shared_ptr<NormalizeBase> NormalizePtr;
+
+#define NORMALIZE_IMP(classname)              \
+public:                                       \
+    virtual NormalizePtr _clone() override {  \
+        return std::make_shared<classname>(); \
+    }                                         \
+    PriceList normalize(const PriceList& data) override;
+
+HKU_API std::ostream& operator<<(std::ostream&, const NormalizeBase&);
+HKU_API std::ostream& operator<<(std::ostream&, const NormalizePtr&);
+
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::NormalizeBase> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<hku::NormalizePtr> : ostream_formatter {};
+#endif