hikyuu 2.1.5__cp312-none-win_amd64.whl → 2.2.0__cp312-none-win_amd64.whl

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/imp/{OperatorSelector.h → logic/OperatorSelector.h}

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "../SelectorBase.h"
+#include "hikyuu/trade_sys/selector/SelectorBase.h"
 
 namespace hku {
 

hikyuu/include/hikyuu/trade_sys/selector/imp/{OperatorValueSelector.h → logic/OperatorValueSelector.h}

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "../SelectorBase.h"
+#include "hikyuu/trade_sys/selector/SelectorBase.h"
 
 namespace hku {
 

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

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/MaxFundsOptimalSelector.h

@@ -0,0 +1,27 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-22
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_TRADE_SYS_MAX_FUNDS_OPTIMAL_SELECTOR_H_
+#define HKU_TRADE_SYS_MAX_FUNDS_OPTIMAL_SELECTOR_H_
+
+#include "OptimalSelectorBase.h"
+
+namespace hku {
+
+class MaxFundsOptimalSelector : public OptimalSelectorBase {
+    OPTIMAL_SELECTOR_IMP(MaxFundsOptimalSelector)
+    OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    MaxFundsOptimalSelector();
+    virtual ~MaxFundsOptimalSelector();
+};
+
+}  // namespace hku
+
+#endif /* HKU_TRADE_SYS_MAX_FUNDS_OPTIMAL_SELECTOR_H_ */

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/OptimalSelectorBase.h

@@ -0,0 +1,86 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+#include "hikyuu/trade_sys/selector/SelectorBase.h"
+
+namespace hku {
+
+//
+// start ------ run_start --end
+// | train_len | test_len
+//
+struct RunRanges {
+    Datetime start;
+    Datetime run_start;
+    Datetime end;
+
+    RunRanges(const Datetime& start_, const Datetime& run_start_, const Datetime end_)
+    : start(start_), run_start(run_start_), end(end_) {}
+};
+
+class HKU_API OptimalSelectorBase : public SelectorBase {
+    CLASS_LOGGER_IMP(SE_Optimal)
+    SELECTOR_IMP(OptimalSelectorBase)
+    SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    OptimalSelectorBase();
+    explicit OptimalSelectorBase(const string& name);
+    virtual ~OptimalSelectorBase() = default;
+
+    virtual void _checkParam(const string& name) const override;
+    virtual void calculate(const SystemList& pf_realSysList, const KQuery& query) override;
+
+    virtual void _reset() override;
+
+    virtual string str() const override;
+
+    // 以便继承子类只需要实现 _clone 和 该接口即可
+    // 该接口实现系统绩效评估，getSelected 时将取评估结果最大的系统
+    // 使用 std::function 的话，在 C++ 中无法序列化，所以使用继承
+    virtual double evaluate(const SYSPtr& sys, const Datetime& endDate) noexcept {
+        return Null<double>();
+    }
+
+    const vector<RunRanges>& getRunRanges() const {
+        return m_run_ranges;
+    }
+
+private:
+    void _initParams();
+    void _calculate_single(const vector<std::pair<size_t, size_t>>& train_ranges,
+                           const DatetimeList& dates, size_t test_len, bool trace);
+
+    void _calculate_parallel(const vector<std::pair<size_t, size_t>>& train_ranges,
+                             const DatetimeList& dates, size_t test_len, bool trace);
+
+protected:
+    unordered_map<Datetime, std::shared_ptr<SystemWeightList>> m_sys_dict;
+    vector<RunRanges> m_run_ranges;
+};
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPTIMAL_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 OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+#define OPTIMAL_SELECTOR_IMP(classname)       \
+public:                                       \
+    virtual SelectorPtr _clone() override {   \
+        return std::make_shared<classname>(); \
+    }                                         \
+    virtual double evaluate(const SYSPtr&, const Datetime& endDate) noexcept override;
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/PerformanceOptimalSelector.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OptimalSelectorBase.h"
+
+namespace hku {
+
+class PerformanceOptimalSelector : public OptimalSelectorBase {
+    CLASS_LOGGER_IMP(SE_Optimal)
+    OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    PerformanceOptimalSelector();
+    virtual ~PerformanceOptimalSelector() = default;
+
+    virtual void _checkParam(const string& name) const override;
+    virtual void calculate(const SystemList& pf_realSysList, const KQuery& query) override;
+
+    virtual SystemWeightList getSelected(Datetime date);
+    virtual SelectorPtr _clone() override;
+    virtual void _reset() override;
+
+private:
+    void _calculate_single(const vector<std::pair<size_t, size_t>>& train_ranges,
+                           const DatetimeList& dates, const string& key, int mode, size_t test_len,
+                           bool trace);
+
+    void _calculate_parallel(const vector<std::pair<size_t, size_t>>& train_ranges,
+                             const DatetimeList& dates, const string& key, int mode,
+                             size_t test_len, bool trace);
+
+private:
+    unordered_map<Datetime, SYSPtr> m_sys_dict;
+};
+
+}  // namespace hku

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

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/signal/build_in.h

@@ -17,5 +17,6 @@
 #include "crt/SG_Single.h"
 #include "crt/SG_Bool.h"
 #include "crt/SG_Band.h"
+#include "crt/SG_Manual.h"
 
 #endif /* SIGNAL_BUILD_IN_H_ */

hikyuu/include/hikyuu/trade_sys/signal/crt/SG_Manual.h

@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2019~2023, hikyuu.org
+ *
+ *  History:
+ *    1. 20240916 added by fasiondog
+ */
+
+#pragma once
+
+#include "../SignalBase.h"
+
+namespace hku {
+
+/**
+ * 仅能手动添加信号的信号指示器，用于测试或其他特殊用途
+ * @return SignalPtr
+ */
+SignalPtr HKU_API SG_Manual();
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/signal/imp/ManualSignal.h

@@ -0,0 +1,23 @@
+/*
+ *  Copyright (c) 2019~2023, hikyuu.org
+ *
+ *  History:
+ *    1. 20240916 added by fasiondog
+ */
+
+#pragma once
+
+#include "../SignalBase.h"
+
+namespace hku {
+
+class ManualSignal : public SignalBase {
+    SIGNAL_IMP(ManualSignal)
+    SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    ManualSignal();
+    virtual ~ManualSignal() = default;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/system/System.h

@@ -27,6 +27,7 @@ namespace hku {
 
 class HKU_API Portfolio;
 class HKU_API AllocateFundsBase;
+class HKU_API WalkForwardSystem;
 
 /**
  * 交易系统基类
@@ -36,6 +37,7 @@ class HKU_API System {
     PARAMETER_SUPPORT_WITH_CHECK
     friend class HKU_API Portfolio;
     friend class HKU_API AllocateFundsBase;
+    friend class HKU_API WalkForwardSystem;
 
 public:
     /** 默认构造函数 */
@@ -63,6 +65,8 @@ public:
            const StoplossPtr& tp, const ProfitGoalPtr& pg, const SlippagePtr& sp,
            const string& name);
 
+    System(const System&) = default;
+
     /** 析构函数 */
     virtual ~System();
 
@@ -151,6 +155,9 @@ public:
     const TradeRequest& getSellShortTradeRequest() const;
     const TradeRequest& getBuyShortTradeRequest() const;
 
+    /** 将所有组件全部置为非共享 */
+    void setNotSharedAll();
+
     /**
      * 复位，但不包括已有的交易对象，以及共享的部件
      * @note 实际复位操作依赖于系统中各个部件的共享参数
@@ -196,48 +203,58 @@ public:
      * @param reset 执行前是否依据系统部件共享属性复位
      * @param resetAll 强制复位所有部件
      */
-    void run(const KData& kdata, bool reset = true, bool resetAll = false);
+    virtual void run(const KData& kdata, bool reset = true, bool resetAll = false);
 
     /**
      * @brief 在指定的日期执行一步，仅由 PF 调用
      * @param datetime 指定的日期
      * @return TradeRecord
      */
-    TradeRecord runMoment(const Datetime& datetime);
+    virtual TradeRecord runMoment(const Datetime& datetime);
 
     // 运行前准备工作, 失败将抛出异常
-    void readyForRun();
-
-    TradeRecord sell(const KRecord& today, const KRecord& src_today, Part from) {
-        return _sell(today, src_today, from);
-    }
+    virtual void readyForRun();
 
     // 由各个相关组件调用，用于组件参数变化时通知 sys，以便重算
     void partChangedNotify() {
         m_calculated = false;
     }
 
-private:
+    virtual void _reset() {}
+    virtual void _forceResetAll() {}
+
+    /** 子类克隆接口 */
+    virtual SystemPtr _clone() {
+        return make_shared<System>();
+    }
+
+    virtual string str() const;
+
+public:
+    //-------------------------
+    // 仅供 PF/AF 内部调用
+    //-------------------------
+
     // 强制以开盘价卖出，仅供 PF/AF 内部调用
-    TradeRecord sellForceOnOpen(const Datetime& date, double num, Part from) {
+    virtual TradeRecord sellForceOnOpen(const Datetime& date, double num, Part from) {
         HKU_ASSERT(from == PART_ALLOCATEFUNDS || from == PART_PORTFOLIO);
         return _sellForce(date, num, from, true);
     }
 
     // 强制以收盘价卖出，仅供 PF/AF 内部调用
-    TradeRecord sellForceOnClose(const Datetime& date, double num, Part from) {
+    virtual TradeRecord sellForceOnClose(const Datetime& date, double num, Part from) {
         HKU_ASSERT(from == PART_ALLOCATEFUNDS || from == PART_PORTFOLIO);
         return _sellForce(date, num, from, false);
     }
 
     // 清除已有的交易请求，供Portfolio使用
-    void clearDelayBuyRequest();
+    virtual void clearDelayBuyRequest();
 
     // 当前是否存在延迟的操作请求，供Portfolio
-    bool haveDelaySellRequest() const;
+    virtual bool haveDelaySellRequest() const;
 
     // 处理延迟买入请求，仅供 PF 调用
-    TradeRecord pfProcessDelaySellRequest(const Datetime& date);
+    virtual TradeRecord pfProcessDelaySellRequest(const Datetime& date);
 
 private:
     bool _environmentIsValid(const Datetime& datetime);

hikyuu/include/hikyuu/trade_sys/system/TradeRequest.h

@@ -20,19 +20,19 @@ namespace hku {
  */
 class HKU_API TradeRequest {
 public:
-    TradeRequest();
-    void clear();
+    TradeRequest() = default;
+    void clear() noexcept;
 
-    bool valid;
-    BUSINESS business;
+    bool valid{false};
+    BUSINESS business{BUSINESS_INVALID};
     Datetime datetime;
-    price_t stoploss;
-    price_t goal;
-    double number;  //计划的买入/卖出数量，使用发出请求时刻的收盘价，
-                    //用于避免实际买入时需用重新计算数量时，人工执行速度较慢
-                    //可通过系统参数进行设置，是否使用
-    SystemPart from;  //记录SystemBase::Part
-    int count;        //因操作失败，连续延迟的次数
+    price_t stoploss{0.0};
+    price_t goal{0.0};
+    double number{0.0};  // 计划的买入/卖出数量，使用发出请求时刻的收盘价，
+                         // 用于避免实际买入时需用重新计算数量时，人工执行速度较慢
+                         // 可通过系统参数进行设置，是否使用
+    SystemPart from{PART_INVALID};  // 记录SystemBase::Part
+    int count{0};                   // 因操作失败，连续延迟的次数
     KRecord krecord;
 
 //============================================
@@ -82,5 +82,13 @@ private:
 #endif /* HKU_SUPPORT_SERIALIZATION */
 };
 
+HKU_API std::ostream& operator<<(std::ostream& os, const TradeRequest& tr);
+
 } /* namespace hku */
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::TradeRequest> : ostream_formatter {};
+#endif
+
 #endif /* TRADEREQUEST_H_ */

hikyuu/include/hikyuu/trade_sys/system/build_in.h

@@ -10,5 +10,6 @@
 #define SYSTEM_BUILD_IN_H_
 
 #include "crt/SYS_Simple.h"
+#include "crt/SYS_WalkForward.h"
 
 #endif /* BUILD_IN_H_ */

hikyuu/include/hikyuu/trade_sys/system/crt/SYS_WalkForward.h

@@ -0,0 +1,27 @@
+/*
+ *  Copyright (c) 2019~2023, hikyuu.org
+ *
+ *  History:
+ *    1. 20240916 added by fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/system/System.h"
+#include "hikyuu/trade_sys/selector/crt/SE_Optimal.h"
+
+namespace hku {
+
+// SystemPtr HKU_API SYS_WalkForward(const SystemList& candidate_sys_list,
+//                                   const TradeManagerPtr& tm = TradeManagerPtr(),
+//                                   size_t train_len = 100, size_t test_len = 20,
+//                                   const string& key = "帐户平均年收益率%",
+//                                   const TradeManagerPtr& train_tm = TradeManagerPtr());
+
+SystemPtr HKU_API SYS_WalkForward(const SystemList& candidate_sys_list,
+                                  const TradeManagerPtr& tm = TradeManagerPtr(),
+                                  size_t train_len = 100, size_t test_len = 20,
+                                  const SelectorPtr& se = SE_MaxFundsOptimal(),
+                                  const TradeManagerPtr& train_tm = TradeManagerPtr());
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/system/imp/DelegateSystem.h

@@ -0,0 +1,51 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+#include "../System.h"
+
+namespace hku {
+
+class HKU_API DelegateSystem : public System {
+public:
+    DelegateSystem() = default;
+    explicit DelegateSystem(const string& name) : System(name) {}
+    explicit DelegateSystem(const SystemPtr& sys) : m_sys(sys) {}
+    virtual ~DelegateSystem() = default;
+
+    virtual void run(const KData& kdata, bool reset = true, bool resetAll = false) override;
+    virtual TradeRecord runMoment(const Datetime& datetime) override;
+
+    virtual void _reset() override;
+    virtual void _forceResetAll() override;
+    virtual SystemPtr _clone() override;
+
+public:
+    virtual TradeRecord sellForceOnOpen(const Datetime& date, double num, Part from) override;
+    virtual TradeRecord sellForceOnClose(const Datetime& date, double num, Part from) override;
+    virtual void clearDelayBuyRequest() override;
+    virtual bool haveDelaySellRequest() const override;
+    virtual TradeRecord pfProcessDelaySellRequest(const Datetime& date) override;
+
+private:
+    SystemPtr m_sys;
+
+//========================================
+// 序列化支持
+//========================================
+#if HKU_SUPPORT_SERIALIZATION
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(System);
+        ar& BOOST_SERIALIZATION_NVP(m_sys);
+    }
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/system/imp/WalkForwardSystem.h

@@ -0,0 +1,70 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/selector/SelectorBase.h"
+#include "../System.h"
+
+namespace hku {
+
+class HKU_API WalkForwardSystem : public System {
+    CLASS_LOGGER_IMP(SYS_WalkForward)
+
+public:
+    WalkForwardSystem();
+    WalkForwardSystem(const SystemList& candidate_sys_list, const SelectorPtr& se,
+                      const TradeManagerPtr& train_tm);
+    virtual ~WalkForwardSystem() = default;
+
+    virtual void readyForRun() override;
+    virtual void run(const KData& kdata, bool reset = true, bool resetAll = false) override;
+    virtual TradeRecord runMoment(const Datetime& datetime) override;
+
+    virtual void _checkParam(const string& name) const override;
+    virtual void _reset() override;
+    virtual void _forceResetAll() override;
+    virtual SystemPtr _clone() override;
+
+    virtual string str() const override;
+
+public:
+    virtual TradeRecord sellForceOnOpen(const Datetime& date, double num, Part from) override;
+    virtual TradeRecord sellForceOnClose(const Datetime& date, double num, Part from) override;
+    virtual void clearDelayBuyRequest() override;
+    virtual bool haveDelaySellRequest() const override;
+    virtual TradeRecord pfProcessDelaySellRequest(const Datetime& date) override;
+
+private:
+    void initParam();
+    void syncDataFromSystem(const SYSPtr&, bool isMoment);
+    void syncDataToSystem(const SYSPtr&);
+
+private:
+    SEPtr m_se;        // 寻优SE
+    TMPtr m_train_tm;  // 用于优化评估计算的账户
+    SYSPtr m_cur_sys;
+    size_t m_cur_kdata{0};
+    vector<KData> m_train_kdata_list;
+    vector<RunRanges> m_run_ranges;
+
+//========================================
+// 序列化支持
+//========================================
+#if HKU_SUPPORT_SERIALIZATION
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(System);
+        ar& BOOST_SERIALIZATION_NVP(m_se);
+        ar& BOOST_SERIALIZATION_NVP(m_train_tm);
+    }
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+}  // namespace hku