hikyuu 2.1.5__cp38-none-win_amd64.whl → 2.2.1__cp38-none-win_amd64.whl

hikyuu/include/hikyuu/StockWeight.h

@@ -20,13 +20,13 @@ namespace hku {
 class HKU_API StockWeight {
 public:
     /** 默认构造函数，返回Null<StockWeight>() */
-    StockWeight();
+    StockWeight() = default;
 
     explicit StockWeight(const Datetime& datetime);
 
     StockWeight(const Datetime& datetime, price_t countAsGift, price_t countForSell,
                 price_t priceForSell, price_t bonus, price_t increasement, price_t totalCount,
-                price_t freeCount);
+                price_t freeCount, price_t suogu);
 
     /** 权息日期 */
     Datetime datetime() const {
@@ -68,15 +68,21 @@ public:
         return m_freeCount;
     }
 
+    /** 扩缩股比例 */
+    price_t suogu() const {
+        return m_suogu;
+    }
+
 private:
-    Datetime m_datetime;     // 权息日期
-    price_t m_countAsGift;   // 每10股送X股
-    price_t m_countForSell;  // 每10股配X股
-    price_t m_priceForSell;  // 配股价
-    price_t m_bonus;         // 每10股红利
-    price_t m_increasement;  // 每10股转增X股
-    price_t m_totalCount;    // 总股本（万股）
-    price_t m_freeCount;     // 流通股（万股）
+    Datetime m_datetime;         // 权息日期
+    price_t m_countAsGift{0.};   // 每10股送X股
+    price_t m_countForSell{0.};  // 每10股配X股
+    price_t m_priceForSell{0.};  // 配股价
+    price_t m_bonus{0.};         // 每10股红利
+    price_t m_increasement{0.};  // 每10股转增X股
+    price_t m_totalCount{0.};    // 总股本（万股）
+    price_t m_freeCount{0.};     // 流通股（万股）
+    price_t m_suogu{0.};         // 扩缩股比例
 };
 
 /** @ingroup StockManage */

hikyuu/include/hikyuu/analysis/analysis_sys.h

@@ -13,20 +13,20 @@
 
 namespace hku {
 
-struct HKU_API AnalysisSystemWithBlockOut {
+struct HKU_API AnalysisSystemOutput {
     string market_code;  ///< 证券代码
     string name;         ///< 证券名称
     PriceList values;    ///< 统计各项指标值
 
-    AnalysisSystemWithBlockOut() = default;
-    AnalysisSystemWithBlockOut(const AnalysisSystemWithBlockOut& other) = default;
-    AnalysisSystemWithBlockOut(AnalysisSystemWithBlockOut&& rv)
+    AnalysisSystemOutput() = default;
+    AnalysisSystemOutput(const AnalysisSystemOutput& other) = default;
+    AnalysisSystemOutput(AnalysisSystemOutput&& rv)
     : market_code(std::move(rv.market_code)),
       name(std::move(rv.name)),
       values(std::move(rv.values)) {}
 
-    AnalysisSystemWithBlockOut& operator=(const AnalysisSystemWithBlockOut&) = default;
-    AnalysisSystemWithBlockOut& operator=(AnalysisSystemWithBlockOut&& rv) {
+    AnalysisSystemOutput& operator=(const AnalysisSystemOutput&) = default;
+    AnalysisSystemOutput& operator=(AnalysisSystemOutput&& rv) {
         HKU_IF_RETURN(this == &rv, *this);
         market_code = std::move(rv.market_code);
         name = std::move(rv.name);
@@ -35,12 +35,42 @@ struct HKU_API AnalysisSystemWithBlockOut {
     }
 };
 
-vector<AnalysisSystemWithBlockOut> HKU_API analysisSystemList(const SystemList& sys_list,
-                                                              const StockList& stk_list,
-                                                              const KQuery& query);
+/**
+ * 统计所有指定系统策略, 系统列表中的每一个系统都应该是独立的系统实例
+ * @note 系统实例列表和证券列表是一一对应，不是两两组合
+ * @param sys_list 系统策略实例列表
+ * @param stk_list 证券列表，须与系统策略列表一一对应
+ * @param query 查询条件
+ * @return vector<AnalysisSystemOutput>
+ */
+vector<AnalysisSystemOutput> HKU_API analysisSystemList(const SystemList& sys_list,
+                                                        const StockList& stk_list,
+                                                        const KQuery& query);
+
+/**
+ * 以指定的 stock 统计执行所有的系统策略
+ * @param sys_list 系统策略思路列表，每一个都应是单独的实例
+ * @param stk 指定证券
+ * @param query 查询条件
+ * @return vector<AnalysisSystemOutput>
+ */
+vector<AnalysisSystemOutput> HKU_API analysisSystemList(const SystemList& sys_list,
+                                                        const Stock& stk, const KQuery& query);
 
-vector<AnalysisSystemWithBlockOut> HKU_API analysisSystemList(const StockList& stk_list,
-                                                              const KQuery& query,
-                                                              const SystemPtr& pro_sys);
+/**
+ * 以指定的 stock 统计执行所有的系统策略，并按指定的统计项返回统计项最高或最低的系统实例及其统计值
+ * @param sys_list 系统策略思路列表，每一个都应是单独的实例
+ * @param stk 指定证券
+ * @param query 查询条件
+ * @param sort_key Performance 中的统计项名称，按该统计项返回
+ * @param sort_mode 0 为取统计最高值的系统，其他值为取统计最低值的系统
+ * @return std::pair<double, SYSPtr>
+ */
+std::pair<double, SYSPtr> HKU_API findOptimalSystem(const SystemList& sys_list, const Stock& stk,
+                                                    const KQuery& query, const string& sort_key,
+                                                    int sort_mode = 0);
 
+std::pair<double, SYSPtr> HKU_API findOptimalSystemMulti(const SystemList& sys_list,
+                                                         const Stock& stk, const KQuery& query,
+                                                         const string& sort_key, int sort_mode = 0);
 }  // namespace hku

hikyuu/include/hikyuu/data_driver/base_info/table/StockWeightTable.h

@@ -16,8 +16,8 @@
 namespace hku {
 
 class StockWeightTable {
-    TABLE_BIND9(StockWeightTable, stkweight, stockid, date, countAsGift, countForSell, priceForSell,
-                bonus, countOfIncreasement, totalCount, freeCount)
+    TABLE_BIND10(StockWeightTable, stkweight, stockid, date, countAsGift, countForSell,
+                 priceForSell, bonus, countOfIncreasement, totalCount, freeCount, suogu)
 
 public:
     uint64_t stockid{0};
@@ -29,11 +29,12 @@ public:
     double countOfIncreasement{0.};
     double totalCount{0.};
     double freeCount{0.};
+    double suogu{0.};
 };
 
 struct StockWeightTableView {
-    TABLE_BIND9(StockWeightTableView, stkweight, market_code, date, countAsGift, countForSell,
-                priceForSell, bonus, countOfIncreasement, totalCount, freeCount)
+    TABLE_BIND10(StockWeightTableView, stkweight, market_code, date, countAsGift, countForSell,
+                 priceForSell, bonus, countOfIncreasement, totalCount, freeCount, suogu)
     string market_code;
     uint64_t date{0};
     double countAsGift{0.};
@@ -43,6 +44,7 @@ struct StockWeightTableView {
     double countOfIncreasement{0.};
     double totalCount{0.};
     double freeCount{0.};
+    double suogu{0.0};
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/global/agent/SpotAgent.h

@@ -125,12 +125,11 @@ private:
     enum STATUS m_status = WAITING;      // 当前内部状态
     std::atomic_bool m_stop = true;      // 结束代理工作标识
 
-    int m_revTimeout = 100;            // 连接数据服务超时时长（毫秒）
-    size_t m_batch_count = 0;          // 记录本次批次接收的数据数量
-    std::thread m_receiveThread;       // 数据接收线程
-    std::unique_ptr<ThreadPool> m_tg;  // 数据处理任务线程池
-    size_t m_work_num = 1;             // 数据处理任务线程池线程数
-    vector<std::future<void>> m_process_task_list;
+    int m_revTimeout = 100;                         // 连接数据服务超时时长（毫秒）
+    std::thread m_receiveThread;                    // 数据接收线程
+    std::unique_ptr<ThreadPool> m_tg;               // 数据处理任务线程池
+    size_t m_work_num = 1;                          // 数据处理任务线程池线程数
+    std::unique_ptr<ThreadPool> m_receive_data_tg;  // 数据接收任务组
 
     bool m_print = true;   // 是否打印连接信息
     string m_server_addr;  // 服务器地址

hikyuu/include/hikyuu/indicator/crt/IC.h

@@ -18,23 +18,24 @@ namespace hku {
  * @param query 查询条件
  * @param ref_stk 参照证券，默认 sh000300 沪深300
  * @param n 时间窗口 (对应 n 日收益率)
+ * @param spearman 使用 spearman 相关系数，否则为 pearson
  * @return Indicator
  * @ingroup Indicator
  */
 Indicator HKU_API IC(const StockList& stks, const KQuery& query,
-                     const Stock& ref_stk = getStock("sh000300"), int n = 1);
+                     const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true);
 
 Indicator HKU_API IC(const Block& blk, const KQuery& query,
-                     const Stock& ref_stk = getStock("sh000300"), int n = 1);
+                     const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true);
 
 inline Indicator IC(const Indicator& ind, const StockList& stks, const KQuery& query,
-                    const Stock& ref_stk = getStock("sh000300"), int n = 1) {
-    return IC(stks, query, ref_stk, n)(ind);
+                    const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true) {
+    return IC(stks, query, ref_stk, n, spearman)(ind);
 }
 
 inline Indicator IC(const Indicator& ind, const Block& blk, const KQuery& query,
-                    const Stock& ref_stk = getStock("sh000300"), int n = 1) {
-    return IC(blk, query, ref_stk, n)(ind);
+                    const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true) {
+    return IC(blk, query, ref_stk, n, spearman)(ind);
 }
 
 }  // namespace hku

hikyuu/include/hikyuu/indicator/crt/ICIR.h

@@ -22,12 +22,14 @@ namespace hku {
  * @param ref_stk 参照证券，默认 sh000300 沪深300
  * @param n IC对应的N日收益率
  * @param rolling_n 滚动时间窗口
+ * @param spearman 使用 spearman 相关系数，否则为 pearson
  * @return Indicator
  * @ingroup Indicator
  */
 inline Indicator ICIR(const Indicator& ind, const StockList& stks, const KQuery& query,
-                      const Stock& ref_stk = getStock("sh000300"), int n = 1, int rolling_n = 120) {
-    Indicator ic = IC(ind, stks, query, ref_stk, n);
+                      const Stock& ref_stk = getStock("sh000300"), int n = 1, int rolling_n = 120,
+                      bool spearman = true) {
+    Indicator ic = IC(ind, stks, query, ref_stk, n, spearman);
     Indicator x = MA(ic, rolling_n) / STDEV(ic, rolling_n);
     x.name("ICIR");
     x.setParam<int>("n", n);
@@ -36,8 +38,9 @@ inline Indicator ICIR(const Indicator& ind, const StockList& stks, const KQuery&
 }
 
 inline Indicator ICIR(const Indicator& ind, const Block& blk, const KQuery& query,
-                      const Stock& ref_stk = getStock("sh000300"), int n = 1, int rolling_n = 120) {
-    Indicator ic = IC(ind, blk, query, ref_stk, n);
+                      const Stock& ref_stk = getStock("sh000300"), int n = 1, int rolling_n = 120,
+                      bool spearman = true) {
+    Indicator ic = IC(ind, blk, query, ref_stk, n, spearman);
     Indicator x = MA(ic, rolling_n) / STDEV(ic, rolling_n);
     x.name("ICIR");
     x.setParam<int>("n", n);

hikyuu/include/hikyuu/indicator/imp/IIc.h

@@ -14,7 +14,7 @@ namespace hku {
 class IIc : public IndicatorImp {
 public:
     IIc();
-    IIc(const StockList& stks, const KQuery& query, int n, const Stock& ref_stk);
+    IIc(const StockList& stks, const KQuery& query, int n, const Stock& ref_stk, bool spearman);
     virtual ~IIc();
 
     virtual void _checkParam(const string& name) const override;

hikyuu/include/hikyuu/serialization/StockWeight_serialization.h

@@ -26,6 +26,7 @@ void save(Archive& ar, const hku::StockWeight& record, unsigned int version) {
     hku::price_t increasement = record.increasement();
     hku::price_t totalCount = record.totalCount();
     hku::price_t freeCount = record.freeCount();
+    hku::price_t suogu = record.suogu();
     ar& BOOST_SERIALIZATION_NVP(datetime);
     ar& BOOST_SERIALIZATION_NVP(countAsGift);
     ar& BOOST_SERIALIZATION_NVP(countForSell);
@@ -34,13 +35,14 @@ void save(Archive& ar, const hku::StockWeight& record, unsigned int version) {
     ar& BOOST_SERIALIZATION_NVP(increasement);
     ar& BOOST_SERIALIZATION_NVP(totalCount);
     ar& BOOST_SERIALIZATION_NVP(freeCount);
+    ar& BOOST_SERIALIZATION_NVP(suogu);
 }
 
 template <class Archive>
 void load(Archive& ar, hku::StockWeight& record, unsigned int version) {
     hku::uint64_t datetime;
     hku::price_t countAsGift, countForSell, priceForSell, bonus;
-    hku::price_t increasement, totalCount, freeCount;
+    hku::price_t increasement, totalCount, freeCount, suogu;
     ar& BOOST_SERIALIZATION_NVP(datetime);
     ar& BOOST_SERIALIZATION_NVP(countAsGift);
     ar& BOOST_SERIALIZATION_NVP(countForSell);
@@ -49,8 +51,9 @@ void load(Archive& ar, hku::StockWeight& record, unsigned int version) {
     ar& BOOST_SERIALIZATION_NVP(increasement);
     ar& BOOST_SERIALIZATION_NVP(totalCount);
     ar& BOOST_SERIALIZATION_NVP(freeCount);
+    ar& BOOST_SERIALIZATION_NVP(suogu);
     record = hku::StockWeight(hku::Datetime(datetime), countAsGift, countForSell, priceForSell,
-                              bonus, increasement, totalCount, freeCount);
+                              bonus, increasement, totalCount, freeCount, suogu);
 }
 }  // namespace serialization
 }  // namespace boost

hikyuu/include/hikyuu/strategy/BrokerTradeManager.h

@@ -94,48 +94,48 @@ public:
      * @param stock 指定证券
      * @return true 是 | false 否
      */
-    virtual bool haveShort(const Stock& stock) const {
+    virtual bool haveShort(const Stock& stock) const override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
 
     /** 当前持有的证券种类数量 */
-    virtual size_t getStockNumber() const {
+    virtual size_t getStockNumber() const override {
         return m_position.size();
     }
 
     /** 当前空头持有的证券种类数量 */
-    virtual size_t getShortStockNumber() const {
+    virtual size_t getShortStockNumber() const override {
         HKU_WARN("The subclass does not implement this method");
         return 0;
     }
 
     /** 获取指定时刻的某证券持有数量 */
-    virtual double getHoldNumber(const Datetime& datetime, const Stock& stock) {
+    virtual double getHoldNumber(const Datetime& datetime, const Stock& stock) override {
         HKU_WARN("The subclass does not implement this method");
         return 0.0;
     }
 
     /** 获取指定时刻的空头某证券持有数量 */
-    virtual double getShortHoldNumber(const Datetime& datetime, const Stock& stock) {
+    virtual double getShortHoldNumber(const Datetime& datetime, const Stock& stock) override {
         HKU_WARN("The subclass does not implement this method");
         return 0.0;
     }
 
     /** 获取指定时刻已借入的股票数量 */
-    virtual double getDebtNumber(const Datetime& datetime, const Stock& stock) {
+    virtual double getDebtNumber(const Datetime& datetime, const Stock& stock) override {
         HKU_WARN("The subclass does not implement this method");
         return 0.0;
     }
 
     /** 获取指定时刻已借入的现金额 */
-    virtual price_t getDebtCash(const Datetime& datetime) {
+    virtual price_t getDebtCash(const Datetime& datetime) override {
         HKU_WARN("The subclass does not implement this method");
         return 0.0;
     }
 
     /** 获取全部交易记录 */
-    virtual TradeRecordList getTradeList() const {
+    virtual TradeRecordList getTradeList() const override {
         HKU_WARN("The subclass does not implement this method");
         return TradeRecordList();
     }
@@ -146,7 +146,8 @@ public:
      * @param end 结束日期
      * @return 交易记录列表
      */
-    virtual TradeRecordList getTradeList(const Datetime& start, const Datetime& end) const {
+    virtual TradeRecordList getTradeList(const Datetime& start,
+                                         const Datetime& end) const override {
         HKU_WARN("The subclass does not implement this method");
         return TradeRecordList();
     }
@@ -155,19 +156,19 @@ public:
     virtual PositionRecordList getPositionList() const override;
 
     /** 获取全部历史持仓记录，即已平仓记录 */
-    virtual PositionRecordList getHistoryPositionList() const {
+    virtual PositionRecordList getHistoryPositionList() const override {
         HKU_WARN("The subclass does not implement this method");
         return PositionRecordList();
     }
 
     /** 获取当前全部空头仓位记录 */
-    virtual PositionRecordList getShortPositionList() const {
+    virtual PositionRecordList getShortPositionList() const override {
         HKU_WARN("The subclass does not implement this method");
         return PositionRecordList();
     }
 
     /** 获取全部空头历史仓位记录 */
-    virtual PositionRecordList getShortHistoryPositionList() const {
+    virtual PositionRecordList getShortHistoryPositionList() const override {
         HKU_WARN("The subclass does not implement this method");
         return PositionRecordList();
     }
@@ -183,13 +184,13 @@ public:
      * 获取指定证券的空头持仓记录
      * @param stock 指定的证券
      */
-    virtual PositionRecord getShortPosition(const Stock& stock) const {
+    virtual PositionRecord getShortPosition(const Stock& stock) const override {
         HKU_WARN("The subclass does not implement this method");
         return PositionRecord();
     }
 
     /** 获取当前借入的股票列表 */
-    virtual BorrowRecordList getBorrowStockList() const {
+    virtual BorrowRecordList getBorrowStockList() const override {
         HKU_WARN("The subclass does not implement this method");
         return BorrowRecordList();
     }
@@ -222,7 +223,7 @@ public:
      * @return true | false
      */
     virtual bool checkinStock(const Datetime& datetime, const Stock& stock, price_t price,
-                              double number) {
+                              double number) override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -237,7 +238,7 @@ public:
      * @note 应该不会被用到
      */
     virtual bool checkoutStock(const Datetime& datetime, const Stock& stock, price_t price,
-                               double number) {
+                               double number) override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -289,7 +290,8 @@ public:
      */
     virtual TradeRecord sellShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
                                   double number, price_t stoploss = 0.0, price_t goalPrice = 0.0,
-                                  price_t planPrice = 0.0, SystemPart from = PART_INVALID) {
+                                  price_t planPrice = 0.0,
+                                  SystemPart from = PART_INVALID) override {
         HKU_WARN("The subclass does not implement this method");
         return TradeRecord();
     }
@@ -309,7 +311,7 @@ public:
     virtual TradeRecord buyShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
                                  double number = MAX_DOUBLE, price_t stoploss = 0.0,
                                  price_t goalPrice = 0.0, price_t planPrice = 0.0,
-                                 SystemPart from = PART_INVALID) {
+                                 SystemPart from = PART_INVALID) override {
         HKU_WARN("The subclass does not implement this method");
         return TradeRecord();
     }
@@ -320,7 +322,7 @@ public:
      * @param cash 借入的现金
      * @return true | false
      */
-    virtual bool borrowCash(const Datetime& datetime, price_t cash) {
+    virtual bool borrowCash(const Datetime& datetime, price_t cash) override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -331,7 +333,7 @@ public:
      * @param cash 归还现金
      * @return true | false
      */
-    virtual bool returnCash(const Datetime& datetime, price_t cash) {
+    virtual bool returnCash(const Datetime& datetime, price_t cash) override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -345,7 +347,7 @@ public:
      * @return true | false
      */
     virtual bool borrowStock(const Datetime& datetime, const Stock& stock, price_t price,
-                             double number) {
+                             double number) override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -359,7 +361,7 @@ public:
      * @return true | false
      */
     virtual bool returnStock(const Datetime& datetime, const Stock& stock, price_t price,
-                             double number) {
+                             double number) override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -387,7 +389,7 @@ public:
      * @param tr 待加入的交易记录
      * @return bool true 成功 | false 失败
      */
-    virtual bool addTradeRecord(const TradeRecord& tr) {
+    virtual bool addTradeRecord(const TradeRecord& tr) override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -398,7 +400,7 @@ public:
      * @return true 成功
      * @return false 失败
      */
-    virtual bool addPosition(const PositionRecord& pr) {
+    virtual bool addPosition(const PositionRecord& pr) override {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -410,7 +412,7 @@ public:
      * 以csv格式输出交易记录、未平仓记录、已平仓记录、资产净值曲线
      * @param path 输出文件所在目录
      */
-    virtual void tocsv(const string& path) {
+    virtual void tocsv(const string& path) override {
         HKU_WARN("The subclass does not implement this method");
     }
 

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -106,8 +106,7 @@ private:
     string m_run_daily_market;
     bool m_ignoreMarket{false};
 
-    std::function<void()> m_run_daily_at_func;
-    TimeDelta m_run_daily_at_delta;
+    std::map<TimeDelta, std::function<void()>> m_run_daily_at_funcs;
 
 private:
     void _initParam();

hikyuu/include/hikyuu/trade_manage/Performance.h

@@ -29,6 +29,9 @@ public:
     Performance& operator=(const Performance& other);
     Performance& operator=(Performance&& other);
 
+    /** 是否为合法的统计项 */
+    static bool exist(const string& key);
+
     /** 复位，清除已计算的结果 */
     void reset();
 

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -168,6 +168,7 @@ public:
         p->m_name = m_name;
         p->m_broker_last_datetime = m_broker_last_datetime;
         p->m_costfunc = m_costfunc;
+        p->m_broker_list = m_broker_list;
         return p;
     }
 
@@ -197,7 +198,7 @@ public:
      * @param ktype K线类型，必须与日期列表匹配，默认KQuery::DAY
      * @return 日资产记录列表
      */
-    FundsList getFundsList(const DatetimeList& dates, KQuery::KType ktype = KQuery::DAY) {
+    FundsList getFundsList(const DatetimeList& dates, const KQuery::KType& ktype = KQuery::DAY) {
         size_t total = dates.size();
         FundsList result(total);
         HKU_IF_RETURN(total == 0, result);
@@ -213,7 +214,7 @@ public:
      * @param ktype K线类型，必须与日期列表匹配，默认KQuery::DAY
      * @return 资产净值列表
      */
-    PriceList getFundsCurve(const DatetimeList& dates, KQuery::KType ktype = KQuery::DAY) {
+    PriceList getFundsCurve(const DatetimeList& dates, const KQuery::KType& ktype = KQuery::DAY) {
         FundsList funds_list = getFundsList(dates, ktype);
         PriceList ret(funds_list.size());
         int precision = getParam<int>("precision");
@@ -229,7 +230,7 @@ public:
      * @param ktype K线类型，必须与日期列表匹配，默认为KQuery::DAY
      * @return 收益曲线
      */
-    PriceList getProfitCurve(const DatetimeList& dates, KQuery::KType ktype = KQuery::DAY) {
+    PriceList getProfitCurve(const DatetimeList& dates, const KQuery::KType& ktype = KQuery::DAY) {
         FundsList funds_list = getFundsList(dates, ktype);
         PriceList ret(funds_list.size());
         int precision = getParam<int>("precision");
@@ -246,7 +247,7 @@ public:
      * @return 收益率曲线
      */
     PriceList getProfitCumChangeCurve(const DatetimeList& dates,
-                                      KQuery::KType ktype = KQuery::DAY) {
+                                      const KQuery::KType& ktype = KQuery::DAY) {
         FundsList funds_list = getFundsList(dates, ktype);
         PriceList ret(funds_list.size());
         for (size_t i = 0, total = funds_list.size(); i < total; i++) {
@@ -261,7 +262,8 @@ public:
      * @param ktype K线类型，必须与日期列表匹配，默认为KQuery::DAY
      * @return 价格曲线
      */
-    PriceList getBaseAssetsCurve(const DatetimeList& dates, KQuery::KType ktype = KQuery::DAY) {
+    PriceList getBaseAssetsCurve(const DatetimeList& dates,
+                                 const KQuery::KType& ktype = KQuery::DAY) {
         FundsList funds_list = getFundsList(dates, ktype);
         PriceList ret(funds_list.size());
         for (size_t i = 0, total = funds_list.size(); i < total; i++) {
@@ -769,4 +771,12 @@ inline std::ostream& operator<<(std::ostream& os, const TradeManagerPtr& ptm) {
     return os;
 }
 
-}  // namespace hku
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::TradeManagerBase> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<hku::TradeManagerPtr> : ostream_formatter {};
+#endif

hikyuu/include/hikyuu/trade_manage/TradeRecord.h

@@ -73,7 +73,7 @@ public:
     BUSINESS business;  ///< 业务类型
     price_t planPrice;  ///< 计划交易价格
     price_t realPrice;  ///< 实际交易价格
-    price_t goalPrice;  ///< 目标价位，如果为0表示未限定目标
+    price_t goalPrice;  ///< 目标价位，如果为0或Null表示未限定目标
     double number;      ///< 成交数量
     CostRecord cost;    ///< 交易成本
     price_t stoploss;   ///< 止损价

hikyuu/include/hikyuu/trade_sys/allocatefunds/AllocateFundsBase.h

@@ -112,9 +112,6 @@ private:
     void _adjust_without_running(const Datetime& date, const SystemWeightList& se_list,
                                  const std::unordered_set<SYSPtr>& running_list);
 
-    /* 检查分配的权重是否在 0 和 1 之间，如果存在错误，抛出异常，仅在 trace 时生效*/
-    void _check_weight(const SystemWeightList&);
-
 private:
     string m_name;    // 组件名称
     KQuery m_query;   // 查询条件

hikyuu/include/hikyuu/trade_sys/condition/ConditionBase.h

@@ -180,10 +180,10 @@ typedef shared_ptr<ConditionBase> CNPtr;
 
 #define CONDITION_IMP(classname)              \
 public:                                       \
-    virtual ConditionPtr _clone() {           \
+    virtual ConditionPtr _clone() override {  \
         return std::make_shared<classname>(); \
     }                                         \
-    virtual void _calculate();
+    virtual void _calculate() override;
 
 HKU_API std::ostream& operator<<(std::ostream&, const ConditionPtr&);
 HKU_API std::ostream& operator<<(std::ostream&, const ConditionBase&);

hikyuu/include/hikyuu/trade_sys/condition/build_in.h

@@ -12,5 +12,6 @@
 #include "crt/CN_Bool.h"
 #include "crt/CN_OPLine.h"
 #include "crt/CN_Logic.h"
+#include "crt/CN_Manual.h"
 
 #endif /* CONDITION_BUILD_IN_H */

hikyuu/include/hikyuu/trade_sys/condition/crt/CN_Manual.h

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