hikyuu 2.1.4__cp311-none-win_amd64.whl → 2.2.0__cp311-none-win_amd64.whl

hikyuu/include/hikyuu/trade_sys/environment/EnvironmentBase.h

@@ -151,12 +151,12 @@ private:                                                          \
 typedef shared_ptr<EnvironmentBase> EnvironmentPtr;
 typedef shared_ptr<EnvironmentBase> EVPtr;
 
-#define ENVIRONMENT_IMP(classname)            \
-public:                                       \
-    virtual EnvironmentPtr _clone() {         \
-        return std::make_shared<classname>(); \
-    }                                         \
-    virtual void _calculate();
+#define ENVIRONMENT_IMP(classname)             \
+public:                                        \
+    virtual EnvironmentPtr _clone() override { \
+        return std::make_shared<classname>();  \
+    }                                          \
+    virtual void _calculate() override;
 
 /**
  * 输出Environment信息，如：Environment(name, params[...])

hikyuu/include/hikyuu/trade_sys/environment/build_in.h

@@ -11,5 +11,6 @@
 
 #include "crt/EV_TwoLine.h"
 #include "crt/EV_Bool.h"
+#include "crt/EV_Manual.h"
 
 #endif /* ENVIRONMENT_BUILD_IN_H */

hikyuu/include/hikyuu/trade_sys/environment/crt/EV_Manual.h

@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2019~2023, hikyuu.org
+ *
+ *  History:
+ *    1. 20240916 added by fasiondog
+ */
+
+#pragma once
+
+#include "../EnvironmentBase.h"
+
+namespace hku {
+
+/**
+ * 仅能手工添加系统环境有效性的EV，用于测试或其他用途
+ * @return EVPtr
+ */
+EVPtr HKU_API EV_Manual();
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/environment/imp/ManualEnvironment.h

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

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

@@ -29,7 +29,7 @@ public:
     MultiFactorBase();
     explicit MultiFactorBase(const string& name);
     MultiFactorBase(const IndicatorList& inds, const StockList& stks, const KQuery& query,
-                    const Stock& ref_stk, const string& name, int ic_n);
+                    const Stock& ref_stk, const string& name, int ic_n, bool spearman);
     MultiFactorBase(const MultiFactorBase&);
     virtual ~MultiFactorBase() = default;
 

hikyuu/include/hikyuu/trade_sys/multifactor/crt/MF_EqualWeight.h

@@ -17,10 +17,12 @@ namespace hku {
  * @param query 日期范围
  * @param ref_stk 参考证券
  * @param ic_n 默认 IC 对应的 N 日收益率
+ * @param spearman 默认使用 spearman 计算相关系数，否则为 pearson
  * @return MultiFactorPtr
  */
 MultiFactorPtr HKU_API MF_EqualWeight(const IndicatorList& inds, const StockList& stks,
-                                      const KQuery& query, const Stock& ref_stk, int ic_n = 5);
+                                      const KQuery& query, const Stock& ref_stk, int ic_n = 5,
+                                      bool spearman = true);
 
 MultiFactorPtr HKU_API MF_EqualWeight();
 

hikyuu/include/hikyuu/trade_sys/multifactor/crt/MF_ICIRWeight.h

@@ -19,11 +19,12 @@ namespace hku {
  * @param ref_stk 参考证券
  * @param ic_n 默认 IC 对应的 N 日收益率
  * @param ic_rolling_n IC 滚动窗口
+ * @param spearman 默认使用 spearman 计算相关系数，否则为 pearson
  * @return MultiFactorPtr
  */
 MultiFactorPtr HKU_API MF_ICIRWeight(const IndicatorList& inds, const StockList& stks,
                                      const KQuery& query, const Stock& ref_stk, int ic_n = 5,
-                                     int ic_rolling_n = 120);
+                                     int ic_rolling_n = 120, bool spearman = true);
 
 MultiFactorPtr HKU_API MF_ICIRWeight();
-}
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/crt/MF_ICWeight.h

@@ -19,10 +19,12 @@ namespace hku {
  * @param ref_stk 参考证券
  * @param ic_n 默认 IC 对应的 N 日收益率
  * @param ic_rolling_n IC 滚动窗口
+ * @param spearman 默认使用 spearman 计算相关系数，否则为 pearson
  * @return MultiFactorPtr
  */
 MultiFactorPtr HKU_API MF_ICWeight(const IndicatorList& inds, const StockList& stks,
                                    const KQuery& query, const Stock& ref_stk, int ic_n = 5,
-                                   int ic_rolling_n = 120);
+                                   int ic_rolling_n = 120, bool spearman = true);
 MultiFactorPtr HKU_API MF_ICWeight();
-}
+
+}  // namespace hku

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

@@ -18,7 +18,7 @@ class EqualWeightMultiFactor : public MultiFactorBase {
 public:
     EqualWeightMultiFactor();
     EqualWeightMultiFactor(const vector<Indicator>& inds, const StockList& stks,
-                           const KQuery& query, const Stock& ref_stk, int ic_n);
+                           const KQuery& query, const Stock& ref_stk, int ic_n, bool spearman);
     virtual ~EqualWeightMultiFactor() = default;
 };
 

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

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

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

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

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

@@ -34,10 +34,10 @@ public:
     /**
      * @brief 构造函数
      * @param tm 账户
-     * @param st 选择器
+     * @param se 选择器
      * @param af 资产分配算法
      */
-    Portfolio(const TradeManagerPtr& tm, const SelectorPtr& st, const AFPtr& af);
+    Portfolio(const TradeManagerPtr& tm, const SelectorPtr& se, const AFPtr& af);
 
     /** 析构函数 */
     virtual ~Portfolio();

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

@@ -122,13 +122,15 @@ public:
     virtual void _removeAll() {}
 
     /* 仅供PF调用，由PF通知其实际运行的系统列表，并启动计算 */
-    void calculate(const SystemList& pf_realSysList, const KQuery& query);
+    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();
 

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

@@ -11,7 +11,8 @@
 
 #include "crt/SE_Fixed.h"
 #include "crt/SE_MultiFactor.h"
-#include "crt/SE_Operator.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_MultiFactor.h

@@ -28,12 +28,13 @@ SelectorPtr HKU_API SE_MultiFactor(const MFPtr& mf, int topn = 10);
  * @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(),
-                                   const string& mode = "MF_ICIRWeight");
+                                   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/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_ */