hikyuu 2.2.2__py3-none-win_amd64.whl

hikyuu/include/hikyuu/trade_sys/selector/SelectorBase.h

@@ -0,0 +1,245 @@
+/*
+ * SelectorBase.h
+ *
+ *  Created on: 2016年2月21日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_SELECTOR_SELECTORBASE_H_
+#define TRADE_SYS_SELECTOR_SELECTORBASE_H_
+
+#include "../system/System.h"
+#include "../../KData.h"
+#include "../../utilities/Parameter.h"
+#include "hikyuu/trade_sys/allocatefunds/AllocateFundsBase.h"
+#include "SystemWeight.h"
+
+namespace hku {
+
+/**
+ * 交易对象选择模块
+ * @ingroup Selector
+ */
+class HKU_API SelectorBase : public enable_shared_from_this<SelectorBase> {
+    PARAMETER_SUPPORT_WITH_CHECK
+
+public:
+    /** 默认构造函数 */
+    SelectorBase();
+    SelectorBase(const SelectorBase&) = default;
+
+    /**
+     * 构造函数，同时指定算法名称
+     * @param name 指定名称
+     */
+    explicit SelectorBase(const string& name);
+
+    /** 析构函数 */
+    virtual ~SelectorBase();
+
+    /** 获取算法名称 */
+    const string& name() const;
+
+    /** 设置算法名称 */
+    void name(const string& name);
+
+    /**
+     * 添加备选股票及其交易策略原型
+     * @param stock 备选股票
+     * @param protoSys 交易系统策略原型
+     * @return 如果 protoSys 无效 或 stock 无效，则返回 false， 否则返回 true
+     */
+    void addStock(const Stock& stock, const SystemPtr& protoSys);
+
+    /**
+     * 加入一组相同交易策略的股票
+     * @note 如果存在无效的stock，则自动忽略，不会返回false
+     * @param stkList 备选股票列表
+     * @param protoSys 交易系统策略原型
+     * @return 如果 protoSys 无效则返回false，否则返回 true
+     */
+    void addStockList(const StockList& stkList, const SystemPtr& protoSys);
+
+    /**
+     * 直接加入已有系统策略示例
+     * @note 应该已经绑定 stock
+     * @param sys
+     */
+    void addSystem(const SYSPtr& sys);
+
+    /**
+     * 直接加入已有系统策略示例
+     * @note 应该已经绑定 stock
+     * @param sys
+     */
+    void addSystemList(const SystemList& sys);
+
+    /**
+     * @brief 获取原型系统列表
+     * @return const SystemList&
+     */
+    const SystemList& getProtoSystemList() const;
+
+    /**
+     * @brief 获取由 PF 实际运行的系统列表
+     * @return const SystemList&
+     */
+    const SystemList& getRealSystemList() const;
+
+    /**
+     * @brief 复位
+     * @note 复位不会清除已有的原型系统
+     */
+    void reset();
+
+    /**
+     * 清除已有的系统原型
+     */
+    void removeAll();
+
+    typedef shared_ptr<SelectorBase> SelectorPtr;
+    SelectorPtr clone();
+
+    /** 子类复位接口 */
+    virtual void _reset() {}
+
+    /** 子类克隆接口 */
+    virtual SelectorPtr _clone() = 0;
+
+    /** 子类计算接口 */
+    virtual void _calculate() = 0;
+
+    /** 子类获取指定时刻收盘时选中的标的 */
+    virtual SystemWeightList getSelected(Datetime date) = 0;
+
+    virtual bool isMatchAF(const AFPtr& af) = 0;
+
+    /** 用于逻辑运算的子类中添加原型系统，一般不需要子类实现 */
+    virtual void _addSystem(const SYSPtr& sys) {}
+
+    /** 用于逻辑运算的子类中添加原型系统，一般不需要子类实现 */
+    virtual void _removeAll() {}
+
+    /* 仅供PF调用，由PF通知其实际运行的系统列表，并启动计算 */
+    virtual void calculate(const SystemList& pf_realSysList, const KQuery& query);
+
+    /* 仅供PF调用，建立实际系统到原型系统映射 */
+    virtual void bindRealToProto(const SYSPtr& real, const SYSPtr& proto) {}
+
+    void calculate_proto(const KQuery& query);
+
+    virtual string str() const;
+
+private:
+    void initParam();
+
+protected:
+    string m_name;
+    bool m_calculated{false};  // 是否已计算过
+    bool m_proto_calculated{false};
+    KQuery m_query;
+    KQuery m_proto_query;
+
+    SystemList m_pro_sys_list;  // 原型系统列表
+    SystemList m_real_sys_list;  // PF组合中实际运行的系统，有PF执行时设定，顺序与原型列表一一对应
+
+//============================================
+// 序列化支持
+//============================================
+#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_pro_sys_list);
+    }
+
+    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_pro_sys_list);
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+#if HKU_SUPPORT_SERIALIZATION
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(SelectorBase)
+#endif
+
+#if HKU_SUPPORT_SERIALIZATION
+/**
+ * 对于没有私有变量的继承子类，可直接使用该宏定义序列化
+ * @code
+ * class Drived: public SelectorBase {
+ *     SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+ *
+ * public:
+ *     Drived();
+ *     ...
+ * };
+ * @endcode
+ * @ingroup Selector
+ */
+#define SELECTOR_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(SelectorBase); \
+    }
+#else
+#define SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+#define SELECTOR_IMP(classname)                                   \
+public:                                                           \
+    virtual SelectorPtr _clone() override {                       \
+        return std::make_shared<classname>();                     \
+    }                                                             \
+    virtual SystemWeightList getSelected(Datetime date) override; \
+    virtual bool isMatchAF(const AFPtr& af) override;             \
+    virtual void _calculate() override;
+
+/**
+ * 客户程序都应使用该指针类型
+ * @ingroup Selector
+ */
+typedef shared_ptr<SelectorBase> SelectorPtr;
+typedef shared_ptr<SelectorBase> SEPtr;
+
+HKU_API std::ostream& operator<<(std::ostream&, const SelectorBase&);
+HKU_API std::ostream& operator<<(std::ostream&, const SelectorPtr&);
+
+inline const string& SelectorBase::name() const {
+    return m_name;
+}
+
+inline void SelectorBase::name(const string& name) {
+    m_name = name;
+}
+
+inline const SystemList& SelectorBase::getRealSystemList() const {
+    return m_real_sys_list;
+}
+
+inline const SystemList& SelectorBase::getProtoSystemList() const {
+    return m_pro_sys_list;
+}
+
+} /* namespace hku */
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::SelectorBase> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<hku::SelectorPtr> : ostream_formatter {};
+#endif
+
+#endif /* TRADE_SYS_SELECTOR_SELECTORBASE_H_ */

hikyuu/include/hikyuu/trade_sys/selector/SystemWeight.h

@@ -0,0 +1,70 @@
+/*
+ * SystemWeight.h
+ *
+ *  Created on: 2018年1月29日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_ALLOCATEFUNDS_SYSTEMWEIGHT_H_
+#define TRADE_SYS_ALLOCATEFUNDS_SYSTEMWEIGHT_H_
+
+#include "../system/System.h"
+
+namespace hku {
+
+/**
+ * 系统权重，权重有效范围为 [0.0, 1.0]
+ * @details 用于指定系统对应权重告知资产分配算法
+ * @ingroup Selector
+ */
+struct HKU_API SystemWeight {
+    SystemPtr sys;
+    double weight{1.0};
+
+    SystemWeight() = default;
+    SystemWeight(const SystemPtr& sys_, double weight_) : sys(sys_), weight(weight_) {}
+    SystemWeight(const SystemWeight&) = default;
+    SystemWeight(SystemWeight&& sw) : sys(std::move(sw.sys)), weight(sw.weight) {}
+    SystemWeight& operator=(const SystemWeight& other) = default;
+    SystemWeight& operator=(SystemWeight&& other);
+
+private:
+//============================================
+// 序列化支持
+//============================================
+#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(sys);
+        ar& BOOST_SERIALIZATION_NVP(weight);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_NVP(sys);
+        ar& BOOST_SERIALIZATION_NVP(weight);
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+typedef vector<SystemWeight> SystemWeightList;
+
+HKU_API std::ostream& operator<<(std::ostream&, const SystemWeight&);
+
+inline bool operator==(const SystemWeight& d1, const SystemWeight& d2) {
+    return d1.sys == d2.sys && std::abs(d1.weight - d2.weight) < 0.0001;
+}
+
+} /* namespace hku */
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::SystemWeight> : ostream_formatter {};
+#endif
+
+#endif /* TRADE_SYS_ALLOCATEFUNDS_SYSTEMWEIGHT_H_ */

hikyuu/include/hikyuu/trade_sys/selector/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/selector/build_in.h

@@ -0,0 +1,18 @@
+/*
+ * build_in.h
+ *
+ *  Created on: 2016年3月28日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_SELECTOR_BUILD_IN_H_
+#define TRADE_SYS_SELECTOR_BUILD_IN_H_
+
+#include "crt/SE_Fixed.h"
+#include "crt/SE_MultiFactor.h"
+#include "crt/SE_Logic.h"
+#include "crt/SE_Optimal.h"
+#include "crt/SE_Signal.h"
+
+#endif /* TRADE_SYS_SELECTOR_BUILD_IN_H_ */

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_Fixed.h

@@ -0,0 +1,38 @@
+/*
+ * SE_Fixed.h
+ *
+ *  Created on: 2018年1月13日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_SELECTOR_CRT_SE_FIXED_H_
+#define TRADE_SYS_SELECTOR_CRT_SE_FIXED_H_
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+/**
+ * @brief 固定选择器，每天都选择指定的交易系统
+ * @param weight 固定权重
+ * @return SelectorPtr
+ * @ingroup Selector
+ */
+SelectorPtr HKU_API SE_Fixed(double weight = 1.0);
+
+/**
+ * @brief 固定选择器，每天都选择指定的交易系统
+ * @details 对指定的每个股票以原型系统创建相应的交易系统
+ * @param stock_list 指定的股票列表
+ * @param sys 原型系统
+ * @param weight 固定权重
+ * @return SelectorPtr
+ * @ingroup Selector
+ */
+SelectorPtr HKU_API SE_Fixed(const StockList& stock_list, const SystemPtr& sys,
+                             double weight = 1.0);
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_SELECTOR_CRT_SE_FIXED_H_ */

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_Logic.h

@@ -0,0 +1,43 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+HKU_API SelectorPtr operator+(const SelectorPtr& se1, const SelectorPtr& se2);
+HKU_API SelectorPtr operator-(const SelectorPtr& se1, const SelectorPtr& se2);
+HKU_API SelectorPtr operator*(const SelectorPtr& se1, const SelectorPtr& se2);
+HKU_API SelectorPtr operator/(const SelectorPtr& se1, const SelectorPtr& se2);
+
+inline SelectorPtr operator&(const SelectorPtr& se1, const SelectorPtr& se2) {
+    return se1 * se2;
+}
+
+inline SelectorPtr operator|(const SelectorPtr& se1, const SelectorPtr& se2) {
+    return se1 + se2;
+}
+
+HKU_API SelectorPtr operator+(const SelectorPtr& se, double value);
+inline SelectorPtr operator+(double value, const SelectorPtr& se) {
+    return se + value;
+}
+
+HKU_API SelectorPtr operator-(const SelectorPtr& se, double value);
+HKU_API SelectorPtr operator-(double value, const SelectorPtr& se);
+
+HKU_API SelectorPtr operator*(const SelectorPtr& se, double value);
+inline SelectorPtr operator*(double value, const SelectorPtr& se) {
+    return se * value;
+}
+
+HKU_API SelectorPtr operator/(const SelectorPtr& se, double value);
+HKU_API SelectorPtr operator/(double value, const SelectorPtr& se);
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_MultiFactor.h

@@ -0,0 +1,40 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-03-30
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/multifactor/MultiFactorBase.h"
+#include "../SelectorBase.h"
+
+namespace hku {
+
+/**
+ * 基于 MultiFactor 选股算法
+ * @param mf MultiFactor 实例
+ * @param topn 只选取时间截面中前 topn 个系统
+ * @return SelectorPtr
+ * @ingroup Selector
+ */
+SelectorPtr HKU_API SE_MultiFactor(const MFPtr& mf, int topn = 10);
+
+/**
+ * 基于 MultiFactor 选股算法
+ * @param src_inds 原始因子公式
+ * @param topn 只选取时间截面中前 topn 个系统，小于等于0时代表不限制
+ * @param ic_n ic 对应的 ic_n 日收益率
+ * @param ic_rolling_n 计算滚动 IC （即 IC 的 n 日移动平均）周期
+ * @param ref_stk 参照对比证券，未指定时，默认使用 sh000300 沪深300指数
+ * @param spearman 默认使用 spearman 计算相关系数，否则为 pearson
+ * @param mode "MF_ICIRWeight" | "MF_ICWeight" | "MF_EqualWeight" 因子合成算法名称
+ * @return SelectorPtr
+ * @ingroup Selector
+ */
+SelectorPtr HKU_API SE_MultiFactor(const IndicatorList& src_inds, int topn = 10, int ic_n = 5,
+                                   int ic_rolling_n = 120, const Stock& ref_stk = Stock(),
+                                   bool spearman = true, const string& mode = "MF_ICIRWeight");
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_Optimal.h

@@ -0,0 +1,26 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-14
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+/**
+ * 账户资产最大寻优选择器
+ * @return SEPtr
+ */
+SEPtr HKU_API SE_MaxFundsOptimal();
+
+/**
+ * 使用 Performance 统计结果进行寻优的选择器
+ * @return SEPtr
+ */
+SEPtr HKU_API SE_PerformanceOptimal(const string& key = "帐户平均年收益率%", int mode = 0);
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_Signal.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2022-02-19
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+/**
+ * @brief 信号选择器，仅依靠系统买入信号进行选中
+ * @return SEPtr
+ * @ingroup Selector
+ */
+SEPtr HKU_API SE_Signal();
+
+/**
+ * @brief 信号选择器，仅依靠系统买入信号进行选中
+ * @param stock_list 股票列表
+ * @param sys 原型系统
+ * @return SEPtr
+ * @ingroup Selector
+ */
+SEPtr HKU_API SE_Signal(const StockList& stock_list, const SystemPtr& sys);
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/crt/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/selector/imp/FixedSelector.h

@@ -0,0 +1,28 @@
+/*
+ * FixedSelector.h
+ *
+ *  Created on: 2018年1月12日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_SELECTOR_IMP_FIXEDSELECTOR_H_
+#define TRADE_SYS_SELECTOR_IMP_FIXEDSELECTOR_H_
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+class FixedSelector : public SelectorBase {
+    SELECTOR_IMP(FixedSelector)
+    SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    FixedSelector();
+    explicit FixedSelector(double weight);
+    virtual ~FixedSelector();
+};
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_SELECTOR_IMP_FIXEDSELECTOR_H_ */

hikyuu/include/hikyuu/trade_sys/selector/imp/MultiFactorSelector.h

@@ -0,0 +1,52 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-03-30
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/multifactor/MultiFactorBase.h"
+#include "../SelectorBase.h"
+
+namespace hku {
+
+class MultiFactorSelector : public SelectorBase {
+public:
+    MultiFactorSelector();
+    MultiFactorSelector(const MFPtr& mf, int topn);
+    virtual ~MultiFactorSelector();
+
+    virtual void _checkParam(const string& name) const override;
+    virtual void _reset() override;
+    virtual SelectorPtr _clone() override;
+    virtual SystemWeightList getSelected(Datetime date) override;
+    virtual bool isMatchAF(const AFPtr& af) override;
+    virtual void _calculate() override;
+
+    void setIndicators(const IndicatorList& inds) {
+        HKU_ASSERT(!inds.empty());
+        m_inds = inds;
+    }
+
+private:
+    IndicatorList m_inds;
+    MFPtr m_mf;
+    unordered_map<Stock, SYSPtr> m_stk_sys_dict;
+
+    //============================================
+    // 序列化支持
+    //============================================
+#if HKU_SUPPORT_SERIALIZATION
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SelectorBase);
+        ar& BOOST_SERIALIZATION_NVP(m_inds);
+        ar& BOOST_SERIALIZATION_NVP(m_mf);
+    }
+#endif
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/SignalSelector.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2022-02-19
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+class SignalSelector : public SelectorBase {
+    SELECTOR_IMP(SignalSelector)
+    SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    SignalSelector();
+    virtual ~SignalSelector();
+
+    virtual void _reset() override {
+        m_sys_dict.clear();
+    }
+
+private:
+    unordered_map<Datetime, SystemWeightList> m_sys_dict;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorAddSelector.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorAddSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorAddSelector, "SE_Add")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorAddValueSelector.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorAddValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorAddValueSelector, "SE_AddValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorDivSelector.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorDivSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorDivSelector, "SE_Div")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku