hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

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,34 @@
+/*
+ *  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);
+
+/**
+ * 使用自定义评估函数进行寻优的选择器
+ * @param evaluate
+ * @return SEPtr
+ */
+SEPtr HKU_API
+SE_EvaluateOptimal(std::function<double(const SystemPtr&, const Datetime&)>&& evaluate);
+
+}  // 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,59 @@
+/*
+ *  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:
+    ScoreRecordList filterOnlyShouldBuy(Datetime date, const ScoreRecordList& scores, size_t topn);
+    ScoreRecordList filterTopN(Datetime date, const ScoreRecordList& raw_scores, size_t topn,
+                               bool only_should_buy);
+    ScoreRecordList filterTopNReverse(Datetime date, const ScoreRecordList& raw_scores, size_t topn,
+                                      bool only_should_buy, bool ignore_null);
+
+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

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorDivValueSelector.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 OperatorDivValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorDivValueSelector, "SE_DivValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorInvertDivValueSelector.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 OperatorInvertDivValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorInvertDivValueSelector, "SE_DivValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorInvertSubValueSelector.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 OperatorInvertSubValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorInvertSubValueSelector, "SE_SubValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorMulSelector.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 OperatorMulSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorMulSelector, "SE_Multi")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorMulValueSelector.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 OperatorMulValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorMulValueSelector, "SE_MultiValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,108 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/selector/SelectorBase.h"
+
+namespace hku {
+
+class HKU_API OperatorSelector : public SelectorBase {
+public:
+    OperatorSelector();
+    explicit OperatorSelector(const string& name);
+    OperatorSelector(const string& name, const SelectorPtr& se1, const SelectorPtr& se2);
+    virtual ~OperatorSelector();
+
+    virtual void _reset() override;
+    virtual SelectorPtr _clone() override;
+    virtual bool isMatchAF(const AFPtr& af) override;
+    virtual void _calculate() override;
+    virtual SystemWeightList _getSelected(Datetime date) override {
+        return SystemWeightList();
+    }
+
+    virtual void _addSystem(const SYSPtr& sys) override;
+    virtual void _removeAll() override;
+
+protected:
+    virtual void bindRealToProto(const SYSPtr& real, const SYSPtr& proto) override {
+        m_real_to_proto[real] = proto;
+    }
+
+    SystemWeightList getUnionSelected(Datetime date,
+                                      const std::function<double(double, double)>&& func);
+
+    SystemWeightList getIntersectionSelected(Datetime date,
+                                             const std::function<double(double, double)>&& func);
+
+protected:
+    static void sortSystemWeightList(SystemWeightList& swlist);
+
+    void build();
+    void cloneRebuild(const SelectorPtr& se1, const SelectorPtr& se2);
+
+protected:
+    SelectorPtr m_se1;
+    SelectorPtr m_se2;
+    std::unordered_set<SYSPtr> m_se1_set;  // se1 的原型系统实例集合
+    std::unordered_set<SYSPtr> m_se2_set;  // se2 的原型系统实例集合
+    std::unordered_map<SYSPtr, SYSPtr> m_real_to_proto;
+
+private:
+    static std::unordered_set<System*> findIntersection(const SelectorPtr& se1,
+                                                        const SelectorPtr& se2);
+
+private:
+    //============================================
+    // 序列化支持
+    //============================================
+#if HKU_SUPPORT_SERIALIZATION
+    friend class boost::serialization::access;
+    template <class Archive>
+    void save(Archive& ar, const unsigned int version) const {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SelectorBase);
+        ar& BOOST_SERIALIZATION_NVP(m_se1);
+        ar& BOOST_SERIALIZATION_NVP(m_se2);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SelectorBase);
+        ar& BOOST_SERIALIZATION_NVP(m_se1);
+        ar& BOOST_SERIALIZATION_NVP(m_se2);
+        build();
+    }
+#endif
+};
+
+#define OPERATOR_SELECTOR_IMP(classname, name)                     \
+public:                                                            \
+    classname() : OperatorSelector(name) {}                        \
+    classname(const SelectorPtr& se1, const SelectorPtr& se2)      \
+    : OperatorSelector(name, se1, se2) {}                          \
+    virtual ~classname() {}                                        \
+                                                                   \
+    virtual SystemWeightList _getSelected(Datetime date) override; \
+                                                                   \
+    virtual SelectorPtr _clone() override {                        \
+        HKU_THROW("OperatorSelector Could't support clone!");      \
+    }
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPERATOR_SELECTOR_SERIALIZATION                            \
+private:                                                           \
+    friend class boost::serialization::access;                     \
+    template <class Archive>                                       \
+    void serialize(Archive& ar, const unsigned int version) {      \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(OperatorSelector); \
+    }
+#else
+#define OPERATOR_SELECTOR_SERIALIZATION
+#endif
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorSubSelector.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 OperatorSubSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorSubSelector, "SE_Sub")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorSubValueSelector.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 OperatorSubValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorSubValueSelector, "SE_SubValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku