hikyuu 2.6.8.3__py3-none-manylinux2014_x86_64.whl → 2.6.9__py3-none-manylinux2014_x86_64.whl

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

hikyuu/include/hikyuu/trade_sys/multifactor/ScoresFilterBase.h

@@ -0,0 +1,125 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_manage/TradeManagerBase.h"
+#include "ScoreRecord.h"
+
+namespace hku {
+
+/**
+ * 评分过滤器
+ * @note 虽然直接使用 std::function 即可，但如果使用 python 函数会造成并行死锁
+ * @ingroup Selector
+ */
+class HKU_API ScoresFilterBase {
+    PARAMETER_SUPPORT_WITH_CHECK
+    friend HKU_API std::ostream& operator<<(std::ostream&, const ScoresFilterBase&);
+
+public:
+    ScoresFilterBase() = default;
+    ScoresFilterBase(const ScoresFilterBase&) = default;
+    ScoresFilterBase(const string& name) : m_name(name) {}
+    virtual ~ScoresFilterBase() = default;
+
+    const string& name() const {
+        return m_name;
+    }
+
+    void name(const string& name) {
+        m_name = name;
+    }
+
+    ScoreRecordList filter(const ScoreRecordList& scores, const Datetime& date,
+                           const KQuery& query);
+
+    virtual ScoreRecordList _filter(const ScoreRecordList& scores, const Datetime& date,
+                                    const KQuery& query) = 0;
+
+    typedef std::shared_ptr<ScoresFilterBase> ScoresFilterPtr;
+    ScoresFilterPtr clone();
+
+    virtual ScoresFilterPtr _clone() = 0;
+
+public:
+    friend HKU_API ScoresFilterPtr operator|(const ScoresFilterPtr& a, const ScoresFilterPtr& b);
+
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
+protected:
+    string m_name;
+    ScoresFilterPtr m_child;
+
+//============================================
+// 序列化支持
+//============================================
+#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);
+        ar& BOOST_SERIALIZATION_NVP(m_child);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
+        ar& BOOST_SERIALIZATION_NVP(m_child);
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+#if HKU_SUPPORT_SERIALIZATION
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(ScoresFilterBase)
+#endif
+
+#if HKU_SUPPORT_SERIALIZATION
+#define SCORESFILTER_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(ScoresFilterBase); \
+    }
+#else
+#define SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+typedef std::shared_ptr<ScoresFilterBase> ScoresFilterPtr;
+typedef std::shared_ptr<ScoresFilterBase> SCFilterPtr;
+
+#define SCORESFILTER_IMP(classname)                                                      \
+public:                                                                                  \
+    virtual ScoresFilterPtr _clone() override {                                          \
+        return std::make_shared<classname>();                                            \
+    }                                                                                    \
+    virtual ScoreRecordList _filter(const ScoreRecordList& scores, const Datetime& date, \
+                                    const KQuery& query) override;
+
+HKU_API std::ostream& operator<<(std::ostream&, const ScoresFilterBase&);
+HKU_API std::ostream& operator<<(std::ostream&, const ScoresFilterPtr&);
+
+HKU_API ScoresFilterPtr operator|(const ScoresFilterPtr& a, const ScoresFilterPtr& b);
+
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::ScoresFilterBase> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<hku::ScoresFilterPtr> : ostream_formatter {};
+#endif

hikyuu/include/hikyuu/trade_sys/multifactor/build_in.h

@@ -7,6 +7,9 @@
 
 #pragma once
 
+#include "buildin_norm.h"
+#include "buildin_scfilter.h"
+
 #include "crt/MF_Weight.h"
 #include "crt/MF_EqualWeight.h"
 #include "crt/MF_ICWeight.h"

hikyuu/include/hikyuu/trade_sys/multifactor/buildin_norm.h

@@ -0,0 +1,36 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "NormalizeBase.h"
+
+namespace hku {
+
+/**
+ * @ingroup MultiFactor
+ * @{
+ */
+
+inline NormPtr NORM_NOTHING() {
+    return NormPtr();
+}
+
+/** 最小-最大标准化 */
+NormPtr HKU_API NORM_MinMax();
+
+/** 正态标准化 */
+NormPtr HKU_API NORM_Zscore(bool outExtreme = false, double nsigma = 3.0, bool recursive = false);
+
+/** 分位数分布标准化 */
+NormPtr HKU_API NORM_Quantile(double quantile_min = 0.01, double quantile_max = 0.99);
+
+/** 分位数均匀分布标准化 */
+NormPtr HKU_API NORM_Quantile_Uniform(double quantile_min = 0.01, double quantile_max = 0.99);
+
+/* @} */
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/buildin_scfilter.h

@@ -0,0 +1,51 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "ScoresFilterBase.h"
+
+namespace hku {
+
+/**
+ * @ingroup MultiFactor
+ * @{
+ */
+
+ScoresFilterPtr HKU_API SCFilter_IgnoreNan();
+
+ScoresFilterPtr HKU_API SCFilter_LessOrEqualValue(double value = 0.0);
+
+ScoresFilterPtr HKU_API SCFilter_TopN(int topn = 10);
+
+/**
+ * 过滤掉成交金额在评分列表末尾百分比范围内的截面
+ * @note
+ * 和传入的截面评分列表顺序相关，如果是降序，过滤的是成交金额较小的系统评分记录；反之，则是金额较大的系统评分记录
+ * @param min_amount_percent_limit 最小成交金额百分比限制
+ * @return ScoresFilterPtr
+ */
+ScoresFilterPtr HKU_API SCFilter_AmountLimit(double min_amount_percent_limit = 0.1);
+
+/**
+ * 筛选指定分组的截面
+ * @param group 分组数量
+ * @param group_index 分组索引，从0开始
+ * @return ScoresFilterPtr
+ */
+ScoresFilterPtr HKU_API SCFilter_Group(int group = 10, int group_index = 0);
+
+/**
+ * 筛选指定价格范围 [min_price, max_price] 内的截面
+ * @param min_price 最低价格
+ * @param max_price 最高价格
+ * @return ScoresFilterPtr
+ */
+ScoresFilterPtr HKU_API SCFilter_Price(double min_price = 10., double max_price = 100000.);
+
+/* @} */
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/GroupSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API GroupSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(GroupSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    GroupSCFilter();
+    virtual ~GroupSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/IgnoreLessOrEqualValueSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-14
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API IgnoreLessOrEqualValueSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(IgnoreLessOrEqualValueSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IgnoreLessOrEqualValueSCFilter();
+    virtual ~IgnoreLessOrEqualValueSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/IgnoreNanSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-14
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API IgnoreNanSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(IgnoreNanSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IgnoreNanSCFilter();
+    virtual ~IgnoreNanSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/MinAmountPercentSCFilter.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API MinAmountPercentSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(MinAmountPercentSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    MinAmountPercentSCFilter();
+    virtual ~MinAmountPercentSCFilter() override = default;
+
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/PriceSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API PriceSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(PriceSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    PriceSCFilter();
+    virtual ~PriceSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/TopNSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-14
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API TopNSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(TopNSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    TopNSCFilter();
+    virtual ~TopNSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/multifactor/imp/EqualWeightMultiFactor.h

@@ -20,7 +20,7 @@ public:
     EqualWeightMultiFactor(const vector<Indicator>& inds, const StockList& stks,
                            const KQuery& query, const Stock& ref_stk, int ic_n, bool spearman,
                            int mode, bool save_all_factors);
-    virtual ~EqualWeightMultiFactor() = default;
+    virtual ~EqualWeightMultiFactor() override = default;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/imp/ICIRMultiFactor.h

@@ -20,7 +20,7 @@ public:
     ICIRMultiFactor(const IndicatorList& inds, const StockList& stks, const KQuery& query,
                     const Stock& ref_stk, int ic_n, int ic_rolling_n, bool spearman, int mode,
                     bool save_all_factors);
-    virtual ~ICIRMultiFactor() = default;
+    virtual ~ICIRMultiFactor() override = default;
 
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/trade_sys/multifactor/imp/ICMultiFactor.h

@@ -20,7 +20,7 @@ public:
     ICMultiFactor(const IndicatorList& inds, const StockList& stks, const KQuery& query,
                   const Stock& ref_stk, int ic_n, int ic_rolling_n, bool spearman, int mode,
                   bool save_all_factors);
-    virtual ~ICMultiFactor() = default;
+    virtual ~ICMultiFactor() override = default;
 
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/trade_sys/multifactor/imp/WeightMultiFactor.h

@@ -22,7 +22,7 @@ public:
     WeightMultiFactor(const vector<Indicator>& inds, const PriceList& weights,
                       const StockList& stks, const KQuery& query, const Stock& ref_stk, int ic_n,
                       bool spearman, int mode, bool save_all_factors);
-    virtual ~WeightMultiFactor() = default;
+    virtual ~WeightMultiFactor() override = default;
 
 private:
     PriceList m_weights;  // 每个指标权重，与输入 inds 列表等长

hikyuu/include/hikyuu/trade_sys/multifactor/normalize/NormMinMax.h

@@ -0,0 +1,23 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../NormalizeBase.h"
+
+namespace hku {
+
+class NormMinMax : public NormalizeBase {
+    NORMALIZE_IMP(NormMinMax)
+    NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    NormMinMax();
+    virtual ~NormMinMax() override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/normalize/NormQuantile.h

@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../NormalizeBase.h"
+
+namespace hku {
+
+/*
+ * 分位数均匀分布标准化
+ */
+class NormQuantile : public NormalizeBase {
+    NORMALIZE_IMP(NormQuantile)
+    NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    NormQuantile();
+    NormQuantile(double quantile_min, double quantile_max);
+    virtual ~NormQuantile() override;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/normalize/NormQuantileUniform.h

@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../NormalizeBase.h"
+
+namespace hku {
+
+/*
+ * 分位数均匀分布标准化
+ */
+class NormQuantileUniform : public NormalizeBase {
+    NORMALIZE_IMP(NormQuantileUniform)
+    NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    NormQuantileUniform();
+    NormQuantileUniform(double quantile_min, double quantile_max);
+    virtual ~NormQuantileUniform() override;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/normalize/NormZScore.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../NormalizeBase.h"
+
+namespace hku {
+
+class NormZScore : public NormalizeBase {
+    NORMALIZE_IMP(NormZScore)
+    NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    NormZScore();
+    NormZScore(bool outExtreme, double nsigma, bool recursive);
+    virtual ~NormZScore() override;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/normalize/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/multifactor/normalize/quantile_trunc.h

@@ -0,0 +1,16 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-15
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/DataType.h"
+
+namespace hku {
+
+PriceList quantile_trunc(const PriceList &src, double quantile_min, double quantile_max);
+
+}

hikyuu/include/hikyuu/trade_sys/portfolio/Portfolio.h

@@ -105,6 +105,13 @@ public:
 
     virtual void _readyForRun() {}
     virtual void _runMoment(const Datetime& date, const Datetime& nextCycle, bool adjust) {}
+    virtual void _runMomentOnOpen(const Datetime& date, const Datetime& nextCycle, bool adjust) {}
+    virtual void _runMomentOnClose(const Datetime& date, const Datetime& nextCycle, bool adjust) {}
+
+    /**
+     * 回测完成后，返回最后一天交易记录，以及需要延迟的买入和卖出延迟请求
+     */
+    virtual json lastSuggestion() const;
 
 private:
     void initParam();