hikyuu 2.3.1__py3-none-win_amd64.whl → 2.5.1__py3-none-win_amd64.whl

hikyuu/include/hikyuu/indicator_talib/imp/ta_imp.h

@@ -448,40 +448,16 @@
     }
 
 #define TA_IN2_OUT1_IMP(func, func_lookback)                                                      \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                           \
-        setParam<bool>("fill_null", true);                                                        \
-    }                                                                                             \
+    Cls_##func::Cls_##func() : Indicator2InImp(#func, 1) {}                                       \
     Cls_##func::Cls_##func(const Indicator &ref_ind, bool fill_null)                              \
-    : IndicatorImp(#func, 1), m_ref_ind(ref_ind) {                                                \
-        setParam<bool>("fill_null", fill_null);                                                   \
-    }                                                                                             \
+    : Indicator2InImp(#func, ref_ind, fill_null, 1) {}                                            \
     Cls_##func::~Cls_##func() {}                                                                  \
-    IndicatorImpPtr Cls_##func::_clone() {                                                        \
-        auto p = make_shared<Cls_##func>();                                                       \
-        p->m_ref_ind = m_ref_ind.clone();                                                         \
-        return p;                                                                                 \
-    }                                                                                             \
                                                                                                   \
     void Cls_##func::_calculate(const Indicator &ind) {                                           \
         size_t total = ind.size();                                                                \
         HKU_IF_RETURN(total == 0, void());                                                        \
                                                                                                   \
-        _readyBuffer(total, 1);                                                                   \
-                                                                                                  \
-        auto k = getContext();                                                                    \
-        m_ref_ind.setContext(k);                                                                  \
-        Indicator ref = m_ref_ind;                                                                \
-        auto dates = ref.getDatetimeList();                                                       \
-        if (dates.empty()) {                                                                      \
-            if (ref.size() > ind.size()) {                                                        \
-                ref = SLICE(ref, ref.size() - ind.size(), ref.size());                            \
-            } else if (ref.size() < ind.size()) {                                                 \
-                ref = CVAL(ind, 0.) + ref;                                                        \
-            }                                                                                     \
-        } else if (m_ref_ind.size() != ind.size()) {                                              \
-            ref = ALIGN(m_ref_ind, ind, getParam<bool>("fill_null"));                             \
-        }                                                                                         \
-                                                                                                  \
+        Indicator ref = prepare(ind);                                                             \
         int lookback = func_lookback();                                                           \
         if (lookback < 0) {                                                                       \
             m_discard = total;                                                                    \
@@ -517,20 +493,18 @@
     }
 
 #define TA_IN2_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)                 \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                        \
+    Cls_##func::Cls_##func() : Indicator2InImp(#func, 1) {                                     \
         setParam<int>("n", period);                                                            \
-        setParam<bool>("fill_null", true);                                                     \
     }                                                                                          \
                                                                                                \
-    Cls_##func::Cls_##func(int n, bool fill_null) : IndicatorImp(#func, 1) {                   \
+    Cls_##func::Cls_##func(int n, bool fill_null) : Indicator2InImp(#func, 1) {                \
         setParam<int>("n", n);                                                                 \
         setParam<bool>("fill_null", fill_null);                                                \
     }                                                                                          \
                                                                                                \
     Cls_##func::Cls_##func(const Indicator &ref_ind, int n, bool fill_null)                    \
-    : IndicatorImp(#func, 1), m_ref_ind(ref_ind) {                                             \
+    : Indicator2InImp(#func, ref_ind, fill_null, 1) {                                          \
         setParam<int>("n", n);                                                                 \
-        setParam<bool>("fill_null", fill_null);                                                \
     }                                                                                          \
                                                                                                \
     Cls_##func::~Cls_##func() {}                                                               \
@@ -542,31 +516,11 @@
         }                                                                                      \
     }                                                                                          \
                                                                                                \
-    IndicatorImpPtr Cls_##func::_clone() {                                                     \
-        auto p = make_shared<Cls_##func>();                                                    \
-        p->m_ref_ind = m_ref_ind.clone();                                                      \
-        return p;                                                                              \
-    }                                                                                          \
-                                                                                               \
     void Cls_##func::_calculate(const Indicator &ind) {                                        \
         size_t total = ind.size();                                                             \
         HKU_IF_RETURN(total == 0, void());                                                     \
                                                                                                \
-        _readyBuffer(total, 1);                                                                \
-                                                                                               \
-        auto k = getContext();                                                                 \
-        m_ref_ind.setContext(k);                                                               \
-        Indicator ref = m_ref_ind;                                                             \
-        auto dates = ref.getDatetimeList();                                                    \
-        if (dates.empty()) {                                                                   \
-            if (ref.size() > ind.size()) {                                                     \
-                ref = SLICE(ref, ref.size() - ind.size(), ref.size());                         \
-            } else if (ref.size() < ind.size()) {                                              \
-                ref = CVAL(ind, 0.) + ref;                                                     \
-            }                                                                                  \
-        } else if (m_ref_ind.size() != ind.size()) {                                           \
-            ref = ALIGN(m_ref_ind, ind, getParam<bool>("fill_null"));                          \
-        }                                                                                      \
+        Indicator ref = prepare(ind);                                                          \
                                                                                                \
         int n = getParam<int>("n");                                                            \
         int lookback = func_lookback(n);                                                       \

hikyuu/include/hikyuu/strategy/RunPortfolioInStrategy.h

@@ -15,8 +15,8 @@ namespace hku {
 class HKU_API RunPortfolioInStrategy {
 public:
     RunPortfolioInStrategy() = default;
-    RunPortfolioInStrategy(const PFPtr& pf, const KQuery& query, int adjust_cycle,
-                           const OrderBrokerPtr& broker, const TradeCostPtr& costfunc);
+    RunPortfolioInStrategy(const PFPtr& pf, const KQuery& query, const OrderBrokerPtr& broker,
+                           const TradeCostPtr& costfunc);
     virtual ~RunPortfolioInStrategy() = default;
 
     void run();
@@ -25,10 +25,9 @@ private:
     PFPtr m_pf;
     OrderBrokerPtr m_broker;
     KQuery m_query;
-    int m_adjust_cycle = 1;
 };
 
-StrategyPtr HKU_API crtPFStrategy(const PFPtr& pf, const KQuery& query, int adjust_cycle,
+StrategyPtr HKU_API crtPFStrategy(const PFPtr& pf, const KQuery& query,
                                   const OrderBrokerPtr& broker, const TradeCostPtr& costfunc,
                                   const string& name = "PFStrategy",
                                   const std::vector<OrderBrokerPtr>& other_brokers = {},

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -133,8 +133,8 @@ private:
 
     /** 向线程池提交任务 */
     template <typename FunctionType>
-    event_handle<typename std::result_of<FunctionType()>::type> event(FunctionType f) {
-        typedef typename std::result_of<FunctionType()>::type result_type;
+    auto event(FunctionType f) {
+        typedef typename std::invoke_result<FunctionType>::type result_type;
         std::packaged_task<result_type()> task(f);
         event_handle<result_type> res(task.get_future());
         m_event_queue.push(std::move(task));
@@ -169,13 +169,12 @@ void HKU_API runInStrategy(const SYSPtr& sys, const Stock& stk, const KQuery& qu
  * @note 目前仅支持 buy_delay| sell_delay 均为 false 的系统，即 close 时执行交易
  * @param pf 资产组合
  * @param query 查询条件
- * @param adjust_cycle 调仓周期
  * @param broker 订单代理（专用与和账户资产同步的订单代理）
  * @param costfunc 成本函数
  * @param other_brokers 其他的订单代理
  */
-void HKU_API runInStrategy(const PFPtr& pf, const KQuery& query, int adjust_cycle,
-                           const OrderBrokerPtr& broker, const TradeCostPtr& costfunc,
+void HKU_API runInStrategy(const PFPtr& pf, const KQuery& query, const OrderBrokerPtr& broker,
+                           const TradeCostPtr& costfunc,
                            const std::vector<OrderBrokerPtr>& other_brokers = {});
 
 /**

hikyuu/include/hikyuu/trade_manage/TradeRecord.h

@@ -78,7 +78,7 @@ public:
     CostRecord cost;    ///< 交易成本
     price_t stoploss;   ///< 止损价
     price_t cash;       ///< 现金余额
-    SystemPart from;  ///< 辅助记录交易系统部件，区别是哪个部件发出的指示，Null<int>()表示无效
+    SystemPart from;    ///< 辅助记录交易系统部件，区别是哪个部件发出的指示，Null<int>()表示无效
 
 #if HKU_SUPPORT_SERIALIZATION
 private:
@@ -141,6 +141,10 @@ HKU_API std::ostream& operator<<(std::ostream&, const TradeRecord&);
 
 bool HKU_API operator==(const TradeRecord& d1, const TradeRecord& d2);
 
+inline bool operator!=(const TradeRecord& d1, const TradeRecord& d2) {
+    return !(d1 == d2);
+}
+
 } /* namespace hku */
 
 #if FMT_VERSION >= 90000

hikyuu/include/hikyuu/trade_sys/allocatefunds/build_in.h

@@ -11,6 +11,7 @@
 
 #include "crt/AF_EqualWeight.h"
 #include "crt/AF_FixedWeight.h"
+#include "crt/AF_FixedWeightList.h"
 #include "crt/AF_MultiFactor.h"
 
 #endif /* TRADE_SYS_ALLOCATEFUNDS_BUILD_IN_H_ */

hikyuu/include/hikyuu/trade_sys/allocatefunds/crt/AF_FixedWeightList.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2018年2月8日
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../AllocateFundsBase.h"
+
+namespace hku {
+
+/**
+ * @brief 固定比例资产分配
+ * @param weights 指定的资产比例列表
+ * @return AFPtr
+ * @ingroup AllocateFunds
+ */
+AFPtr HKU_API AF_FixedWeightList(const vector<double>& weights);
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/allocatefunds/imp/FixedWeightListAllocateFunds.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-07
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../AllocateFundsBase.h"
+
+namespace hku {
+
+class FixedWeightListAllocateFunds : public AllocateFundsBase {
+    ALLOCATEFUNDS_IMP(FixedWeightListAllocateFunds)
+    ALLOCATEFUNDS_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    FixedWeightListAllocateFunds();
+    explicit FixedWeightListAllocateFunds(const PriceList& weights);
+    virtual ~FixedWeightListAllocateFunds();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/moneymanager/MoneyManagerBase.h

@@ -71,11 +71,17 @@ public:
     /** 克隆操作 */
     MoneyManagerPtr clone();
 
-    /** 接收实际交易变化情况，一般存在多次增减仓的情况才需要重载 */
-    virtual void buyNotify(const TradeRecord&);
+    /** 接收实际交易变化情况 */
+    void buyNotify(const TradeRecord& tr);
 
-    /** 接收实际交易变化情况，一般存在多次增减仓的情况才需要重载 */
-    virtual void sellNotify(const TradeRecord&);
+    /** 子类接收实际交易变化情况接口，一般存在多次增减仓的情况才需要重载 */
+    virtual void _buyNotify(const TradeRecord&) {}
+
+    /** 接收实际交易变化情况 */
+    void sellNotify(const TradeRecord& tr);
+
+    /** 子类接收实际交易变化情况接口，一般存在多次增减仓的情况才需要重载 */
+    virtual void _sellNotify(const TradeRecord&) {}
 
     /**
      * 获取指定交易对象可卖出的数量
@@ -122,6 +128,12 @@ public:
     double getBuyNumber(const Datetime& datetime, const Stock& stock, price_t price, price_t risk,
                         SystemPart from);
 
+    /** 当前买入交易次数, 连续买入计数，一旦接收卖出将恢复置0 */
+    size_t currentBuyCount(const Stock&) const;
+
+    /** 当前卖出交易次数，连续卖出计数，一旦接收买入将恢复置0 */
+    size_t currentSellCount(const Stock&) const;
+
     virtual double _getBuyNumber(const Datetime& datetime, const Stock& stock, price_t price,
                                  price_t risk, SystemPart from) = 0;
 
@@ -144,6 +156,7 @@ protected:
     string m_name;
     KQuery m_query;
     TradeManagerPtr m_tm;
+    unordered_map<Stock, std::pair<size_t, size_t>> m_buy_sell_counts;
 
 //============================================
 // 序列化支持

hikyuu/include/hikyuu/trade_sys/moneymanager/build_in.h

@@ -13,7 +13,9 @@
 #include "crt/MM_FixedPercent.h"
 #include "crt/MM_FixedRisk.h"
 #include "crt/MM_FixedCapital.h"
+#include "crt/MM_FixedCapitalFunds.h"
 #include "crt/MM_FixedCount.h"
+#include "crt/MM_FixedCountTps.h"
 #include "crt/MM_FixedUnits.h"
 #include "crt/MM_WilliamsFixedRisk.h"
 

hikyuu/include/hikyuu/trade_sys/moneymanager/crt/MM_FixedCapital.h

@@ -13,6 +13,12 @@
 
 namespace hku {
 
+/**
+ * 固定资金管理策略
+ * 公式: 买入数量 = 当前现金 / capital
+ * @param capital
+ * @return MoneyManagerPtr
+ */
 MoneyManagerPtr HKU_API MM_FixedCapital(double capital = 10000.00);
 
 } /* namespace hku */

hikyuu/include/hikyuu/trade_sys/moneymanager/crt/MM_FixedCapitalFunds.h

@@ -0,0 +1,26 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-19
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_MONEYMANAGER_CRT_MM_FIXEDCAPITALFUNDS_H_
+#define TRADE_SYS_MONEYMANAGER_CRT_MM_FIXEDCAPITALFUNDS_H_
+
+#include "../MoneyManagerBase.h"
+
+namespace hku {
+
+/**
+ * 固定资本管理策略
+ * 公式: 买入数量 = 当前总资产 / capital
+ * @param capital
+ * @return MoneyManagerPtr
+ */
+MoneyManagerPtr HKU_API MM_FixedCapitalFunds(double capital = 10000.00);
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_MONEYMANAGER_CRT_MM_FIXEDCAPITALFUNDS_H_ */

hikyuu/include/hikyuu/trade_sys/moneymanager/crt/MM_FixedCountTps.h

@@ -0,0 +1,27 @@
+/*
+ * MM_FixedCapital.h
+ *
+ *  Created on: 2016年5月3日
+ *      Author: Administrator
+ */
+
+#pragma once
+#ifndef TRADE_SYS_MONEYMANAGER_CRT_MM_FIXEDCOUNT_TPS_H_
+#define TRADE_SYS_MONEYMANAGER_CRT_MM_FIXEDCOUNT_TPS_H_
+
+#include "../MoneyManagerBase.h"
+
+namespace hku {
+
+/**
+ * @brief 连续买入/卖出固定数量资金管理策略。
+ * @param buy_counts 依次买入数量
+ * @param sell_counts 依次卖出数量
+ * @return MoneyManagerPtr
+ */
+MoneyManagerPtr HKU_API MM_FixedCountTps(const vector<double>& buy_counts,
+                                         const vector<double>& sell_counts);
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_MONEYMANAGER_CRT_MM_FIXEDCOUNT_TPS_H_ */

hikyuu/include/hikyuu/trade_sys/moneymanager/crt/MM_FixedRisk.h

@@ -13,6 +13,12 @@
 
 namespace hku {
 
+/**
+ * 固定风险资金管理策略对每笔交易限定一个预先确定的或者固定的资金风险，如每笔交易固定风险1000元。
+ * 公式：交易数量 = 固定风险 / 交易风险。
+ * @param risk
+ * @return MoneyManagerPtr
+ */
 MoneyManagerPtr HKU_API MM_FixedRisk(double risk = 1000.00);
 
 } /* namespace hku */

hikyuu/include/hikyuu/trade_sys/moneymanager/crt/MM_FixedUnits.h

@@ -13,6 +13,12 @@
 
 namespace hku {
 
+/**
+ * 固定单位资金管理策略
+ * 公式: 买入数量 = 当前现金 / n / 当前风险risk
+ * @param n
+ * @return MoneyManagerPtr
+ */
 MoneyManagerPtr HKU_API MM_FixedUnits(int n = 33);
 
 }  // namespace hku

hikyuu/include/hikyuu/trade_sys/moneymanager/crt/MM_WilliamsFixedRisk.h

@@ -13,6 +13,13 @@
 
 namespace hku {
 
+/**
+ * @brief 威廉斯固定风险资金管理策略
+ * 买入数量 =（账户余额 × 风险百分比p）÷ 最大损失(max_loss)
+ * @param p 风险百分比
+ * @param max_loss 最大损失
+ * @return MoneyManagerPtr
+ */
 MoneyManagerPtr HKU_API MM_WilliamsFixedRisk(double p = 0.1, price_t max_loss = 1000.0);
 
 }  // namespace hku

hikyuu/include/hikyuu/trade_sys/moneymanager/imp/FixedCapitalFundsMM.h

@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-19
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_
+#define TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_
+
+#include "../MoneyManagerBase.h"
+
+namespace hku {
+
+class FixedCapitalFundsMM : public MoneyManagerBase {
+    MONEY_MANAGER_IMP(FixedCapitalFundsMM)
+    MONEY_MANAGER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    FixedCapitalFundsMM();
+    virtual ~FixedCapitalFundsMM();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_ */

hikyuu/include/hikyuu/trade_sys/moneymanager/imp/FixedCountTpsMM.h

@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-20
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_
+#define TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_
+
+#include "../MoneyManagerBase.h"
+
+namespace hku {
+
+class FixedCountTpsMM : public MoneyManagerBase {
+public:
+    FixedCountTpsMM();
+    FixedCountTpsMM(const vector<double>& buy_counts, const vector<double>& sell_counts);
+    virtual ~FixedCountTpsMM();
+
+    virtual MoneyManagerPtr _clone() override;
+    virtual double _getBuyNumber(const Datetime& datetime, const Stock& stock, price_t price,
+                                 price_t risk, SystemPart from) override;
+    virtual double _getSellNumber(const Datetime& datetime, const Stock& stock, price_t price,
+                                  price_t risk, SystemPart from) override;
+
+private:
+    vector<double> m_buy_counts;
+    vector<double> m_sell_counts;
+
+#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(MoneyManagerBase);
+    }
+#endif
+};
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_MONEYMANAGER_IMP_FIXEDCAPITAL_FUNDS_MM_H_ */

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

@@ -33,11 +33,13 @@ public:
 
     /**
      * @brief 构造函数
+     * @param name 组合名称
      * @param tm 账户
      * @param se 选择器
      * @param af 资产分配算法
      */
-    Portfolio(const TradeManagerPtr& tm, const SelectorPtr& se, const AFPtr& af);
+    Portfolio(const string& name, const TradeManagerPtr& tm, const SelectorPtr& se,
+              const AFPtr& af);
 
     /** 析构函数 */
     virtual ~Portfolio();
@@ -50,28 +52,10 @@ public:
 
     /**
      * @brief 运行资产组合
-     * @details
-     * <pre>
-     * 调仓模式 adjust_mode 说明：
-     *  - "query" 模式，跟随输入参数 query 中的 ktype，此时 adjust_cycle 为以 query 中的 ktype
-     *    决定周期间隔；
-     *  - "day" 模式，adjust_cycle 为调仓间隔天数
-     *  - "week" | "month" | "quarter" | "year" 模式时，adjust_cycle
-     *    为对应的每周第N日、每月第n日、每季度第n日、每年第n日，在 delay_to_trading_day 为 false 时
-     *    如果当日不是交易日将会被跳过调仓；当 delay_to_trading_day 为 true时，如果当日不是交易日
-     *    将会顺延至当前周期内的第一个交易日，如指定每月第1日调仓，但当月1日不是交易日，则将顺延至当月
-     *    的第一个交易日
-     * </pre>
-     * @note
-     * 由于各个组件可能存在参数变化的情况，无法自动感知判断是否需要重新计算，此时需要手工指定强制计算
      * @param query 查询条件, 其 KType 必须为 KQuery::DAY
-     * @param adjust_cycle 调仓周期（受 adjust_mode 影响）, 默认为1
      * @param force 是否强制重计算
-     * @param adjust_mode 调仓模式 "query" | "day" | "week" | "month" | "year"
-     * @param delay_to_trading_day true 时，如果当日不是交易日将会被顺延至当前周期内的第一个交易日
      */
-    void run(const KQuery& query, int adjust_cycle = 1, bool force = false,
-             const string& adjust_mode = "query", bool delay_to_trading_day = true);
+    void run(const KQuery& query, bool force = false);
 
     /** 修改查询条件 */
     void setQuery(const KQuery& query);
@@ -97,33 +81,43 @@ public:
     /** 设置资产分配算法 */
     void setAF(const AFPtr& af);
 
+    const SystemList& getRealSystemList() const;
+
     /** 复位操作 */
     void reset();
 
+    /** 克隆操作 */
     typedef shared_ptr<Portfolio> PortfolioPtr;
+    PortfolioPtr clone() const;
 
-    /** 克隆操作 */
-    PortfolioPtr clone();
+    /** 运行前准备 */
+    void readyForRun();
 
-    /** 获取所有原型系统列表，与 SE 同 */
-    const SystemList& getSystemList() const;
+    void runMoment(const Datetime& date, const Datetime& nextCycle, bool adjust);
 
-    /** 获取所有实际运行的系统列表，与 SE 同 */
-    const SystemList& getRealSystemList() const;
+    /** 用于打印输出 */
+    virtual string str() const;
 
-private:
-    void initParam();
+    virtual void _reset() {}
+    virtual PortfolioPtr _clone() const {
+        return std::make_shared<Portfolio>();
+    }
 
-    /** 运行前准备 */
-    void _readyForRun();
+    virtual void _readyForRun() {}
+    virtual void _runMoment(const Datetime& date, const Datetime& nextCycle, bool adjust) {}
 
-    void _runMoment(const Datetime& date, const Datetime& nextCycle, bool adjust);
+private:
+    void initParam();
 
     void _runOnMode(const DatetimeList& datelist, int adjust_cycle, const string& mode);
 
     void _runOnModeDelayToTradingDay(const DatetimeList& datelist, int adjust_cycle,
                                      const string& mode);
 
+protected:
+    // 跟踪打印当前TM持仓情况
+    void traceMomentTM(const Datetime& date);
+
 protected:
     string m_name;
     TMPtr m_tm;
@@ -138,10 +132,6 @@ protected:
 
     // 用于中间计算的临时数据
     std::unordered_set<SYSPtr> m_running_sys_set;
-    SystemList m_dlist_sys_list;  // 因证券退市，无法执行买入的系统（资产全部损失）
-    SystemWeightList m_delay_adjust_sys_list;  // 延迟调仓卖出的系统列表
-    SystemWeightList m_tmp_selected_list;
-    SystemWeightList m_tmp_will_remove_sys;
 
 //============================================
 // 序列化支持
@@ -158,7 +148,6 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_se);
         ar& BOOST_SERIALIZATION_NVP(m_af);
         ar& BOOST_SERIALIZATION_NVP(m_query);
-        ar& BOOST_SERIALIZATION_NVP(m_need_calculate);
     }
 
     template <class Archive>
@@ -170,13 +159,25 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_se);
         ar& BOOST_SERIALIZATION_NVP(m_af);
         ar& BOOST_SERIALIZATION_NVP(m_query);
-        ar& BOOST_SERIALIZATION_NVP(m_need_calculate);
     }
 
     BOOST_SERIALIZATION_SPLIT_MEMBER()
 #endif /* HKU_SUPPORT_SERIALIZATION */
 };
 
+#if HKU_SUPPORT_SERIALIZATION
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(Portfolio)
+#endif
+
+#define PORTFOLIO_IMP(classname)                   \
+public:                                            \
+    virtual PortfolioPtr _clone() const override { \
+        return std::make_shared<classname>();      \
+    }                                              \
+    virtual void _reset() override;                \
+    virtual void _readyForRun() override;          \
+    virtual void _runMoment(const Datetime& date, const Datetime& nextCycle, bool adjust) override;
+
 /**
  * 客户程序都应使用该指针类型
  * @ingroup Selector

hikyuu/include/hikyuu/trade_sys/portfolio/build_in.h

@@ -10,5 +10,6 @@
 #define TRADE_SYS_PORTFOLIO_BUILD_IN_H_
 
 #include "crt/PF_Simple.h"
+#include "crt/PF_WithoutAF.h"
 
 #endif /* TRADE_SYS_PORTFOLIO_BUILD_IN_H_ */

hikyuu/include/hikyuu/trade_sys/portfolio/crt/PF_Simple.h

@@ -15,8 +15,32 @@
 
 namespace hku {
 
+/**
+ * @brief 创建资产组合
+ * @details
+ * <pre>
+ * 调仓模式 adjust_mode 说明：
+ *  - "query" 模式，跟随输入参数 query 中的 ktype，此时 adjust_cycle 为以 query 中的 ktype
+ *    决定周期间隔；
+ *  - "day" 模式，adjust_cycle 为调仓间隔天数
+ *  - "week" | "month" | "quarter" | "year" 模式时，adjust_cycle
+ *    为对应的每周第N日、每月第n日、每季度第n日、每年第n日，在 delay_to_trading_day 为 false 时
+ *    如果当日不是交易日将会被跳过调仓；当 delay_to_trading_day 为 true时，如果当日不是交易日
+ *    将会顺延至当前周期内的第一个交易日，如指定每月第1日调仓，但当月1日不是交易日，则将顺延至当月
+ *    的第一个交易日
+ * </pre>
+ * @param tm 交易账户
+ * @param se 系统选择器
+ * @param af 资金分配算法
+ * @param adjust_cycle 调仓周期（受 adjust_mode 影响）, 默认为1
+ * @param adjust_mode 调仓模式 "query" | "day" | "week" | "month" | "year"
+ * @param delay_to_trading_day true 时，如果调仓日不是交易日将会被顺延至当前周期内的第一个交易日
+ * @return 组合实例
+ */
 PortfolioPtr HKU_API PF_Simple(const TMPtr& tm = TradeManagerPtr(), const SEPtr& se = SE_Fixed(),
-                               const AFPtr& af = AF_EqualWeight());
+                               const AFPtr& af = AF_EqualWeight(), int adjust_cycle = 1,
+                               const string& adjust_mode = "query",
+                               bool delay_to_trading_day = true);
 
 } /* namespace hku */