hikyuu 2.3.0__py3-none-win_amd64.whl → 2.5.0__py3-none-win_amd64.whl

hikyuu/include/hikyuu/indicator/imp/IIsNa.h

@@ -0,0 +1,26 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-01-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_IISNA_H_
+#define INDICATOR_IMP_IISNA_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class IIsNa : public IndicatorImp {
+    INDICATOR_IMP(IIsNa)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IIsNa();
+    virtual ~IIsNa();
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_IISNA_H_ */

hikyuu/include/hikyuu/indicator/imp/IJumpDown.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/* 边缘跳变，从大于0.0，跳变到 <= 0.0 */
+class IJumpDown : public IndicatorImp {
+    INDICATOR_IMP(IJumpDown)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IJumpDown();
+    virtual ~IJumpDown();
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/IJumpUp.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/* 边缘跳变，从小于等于0.0，跳变到 > 0.0 */
+class IJumpUp : public IndicatorImp {
+    INDICATOR_IMP(IJumpUp)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IJumpUp();
+    virtual ~IJumpUp();
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/ILastValue.h

@@ -0,0 +1,26 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-04
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_ILASTVALUE_H_
+#define INDICATOR_IMP_ILASTVALUE_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class ILastValue : public IndicatorImp {
+    INDICATOR_IMP(ILastValue)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    ILastValue();
+    virtual ~ILastValue();
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_ILASTVALUE_H_ */

hikyuu/include/hikyuu/indicator/imp/IReplace.h

@@ -0,0 +1,26 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-01-12
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 替换指定数值，通常用于替换 Nan 值
+ */
+class IReplace : public IndicatorImp {
+    INDICATOR_IMP(IReplace)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IReplace();
+    virtual ~IReplace();
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/ISpearman.h

@@ -7,35 +7,20 @@
 
 #pragma once
 
-#include "../Indicator.h"
+#include "../Indicator2InImp.h"
 
 namespace hku {
 
-class ISpearman : public IndicatorImp {
+class ISpearman : public Indicator2InImp {
+    INDICATOR2IN_IMP(ISpearman)
+    INDICATOR2IN_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
 public:
     ISpearman();
-    ISpearman(const Indicator& ref_ind, int n);
+    ISpearman(const Indicator& ref_ind, int n, bool fill_null);
     virtual ~ISpearman();
 
     virtual void _checkParam(const string& name) const override;
-    virtual void _calculate(const Indicator& data) override;
-    virtual IndicatorImpPtr _clone() override;
-
-private:
-    Indicator m_ref_ind;
-
-//============================================
-// 序列化支持
-//============================================
-#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(IndicatorImp);
-        ar& BOOST_SERIALIZATION_NVP(m_ref_ind);
-    }
-#endif
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/indicator/imp/IWinner.h

@@ -0,0 +1,26 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-01-25
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_IWINNER_H_
+#define INDICATOR_IMP_IWINNER_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class IWinner : public IndicatorImp {
+    INDICATOR_IMP(IWinner)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IWinner();
+    virtual ~IWinner();
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_IWINNER_H_ */

hikyuu/include/hikyuu/indicator_talib/imp/TaMavp.h

@@ -8,34 +8,20 @@
 #pragma once
 
 #include "hikyuu/indicator/Indicator.h"
+#include "hikyuu/indicator/Indicator2InImp.h"
 
 namespace hku {
 
-class TaMavp : public IndicatorImp {
+class TaMavp : public Indicator2InImp {
+    INDICATOR2IN_IMP(TaMavp)
+    INDICATOR2IN_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
 public:
     TaMavp();
-    TaMavp(const Indicator& ref_ind, int min_n, int max_n, int matype);
+    TaMavp(const Indicator& ref_ind, int min_n, int max_n, int matype, bool fill_null);
     virtual ~TaMavp();
 
     virtual void _checkParam(const string& name) const override;
-    virtual void _calculate(const Indicator& data) override;
-    virtual IndicatorImpPtr _clone() override;
-
-private:
-    Indicator m_ref_ind;
-
-//============================================
-// 序列化支持
-//============================================
-#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(IndicatorImp);
-        ar& BOOST_SERIALIZATION_NVP(m_ref_ind);
-    }
-#endif
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/indicator_talib/imp/ta_defines.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "hikyuu/indicator/Indicator.h"
+#include "hikyuu/indicator/Indicator2InImp.h"
 
 #define TA_IN1_OUT_DEF(func)                          \
     class Cls_##func : public IndicatorImp {          \
@@ -30,79 +31,27 @@
         virtual void _checkParam(const string& name) const override; \
     };
 
-#if HKU_SUPPORT_SERIALIZATION
-#define TA_IN2_OUT_DEF(func)                                       \
-    class Cls_##func : public IndicatorImp {                       \
-    public:                                                        \
-        Cls_##func();                                              \
-        Cls_##func(const Indicator& ref_ind);                      \
-        virtual ~Cls_##func();                                     \
-        virtual void _calculate(const Indicator& data) override;   \
-        virtual IndicatorImpPtr _clone() override;                 \
-                                                                   \
-    private:                                                       \
-        Indicator m_ref_ind;                                       \
-                                                                   \
-    private:                                                       \
-        friend class boost::serialization::access;                 \
-        template <class Archive>                                   \
-        void serialize(Archive& ar, const unsigned int version) {  \
-            ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(IndicatorImp); \
-            ar& BOOST_SERIALIZATION_NVP(m_ref_ind);                \
-        }                                                          \
+#define TA_IN2_OUT_DEF(func)                                  \
+    class Cls_##func : public Indicator2InImp {               \
+        INDICATOR2IN_IMP(Cls_##func)                          \
+        INDICATOR2IN_IMP_NO_PRIVATE_MEMBER_SERIALIZATION      \
+    public:                                                   \
+        Cls_##func();                                         \
+        Cls_##func(const Indicator& ref_ind, bool fill_null); \
+        virtual ~Cls_##func();                                \
     };
 
 #define TA_IN2_OUT_N_DEF(func)                                       \
-    class Cls_##func : public IndicatorImp {                         \
+    class Cls_##func : public Indicator2InImp {                      \
+        INDICATOR2IN_IMP(Cls_##func)                                 \
+        INDICATOR2IN_IMP_NO_PRIVATE_MEMBER_SERIALIZATION             \
     public:                                                          \
         Cls_##func();                                                \
-        explicit Cls_##func(int n);                                  \
-        Cls_##func(const Indicator& ref_ind, int n);                 \
+        explicit Cls_##func(int n, bool fill_null);                  \
+        Cls_##func(const Indicator& ref_ind, int n, bool fill_null); \
         virtual ~Cls_##func();                                       \
         virtual void _checkParam(const string& name) const override; \
-        virtual void _calculate(const Indicator& data) override;     \
-        virtual IndicatorImpPtr _clone() override;                   \
-                                                                     \
-    private:                                                         \
-        Indicator m_ref_ind;                                         \
-                                                                     \
-    private:                                                         \
-        friend class boost::serialization::access;                   \
-        template <class Archive>                                     \
-        void serialize(Archive& ar, const unsigned int version) {    \
-            ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(IndicatorImp);   \
-            ar& BOOST_SERIALIZATION_NVP(m_ref_ind);                  \
-        }                                                            \
-    };
-#else
-#define TA_IN2_OUT_DEF(func)                                     \
-    class Cls_##func : public IndicatorImp {                     \
-    public:                                                      \
-        Cls_##func();                                            \
-        Cls_##func(const Indicator& ref_ind);                    \
-        virtual ~Cls_##func();                                   \
-        virtual void _calculate(const Indicator& data) override; \
-        virtual IndicatorImpPtr _clone() override;               \
-                                                                 \
-    private:                                                     \
-        Indicator m_ref_ind;                                     \
-    };
-
-#define TA_IN2_OUT_N_DEF(func)                                       \
-    class Cls_##func : public IndicatorImp {                         \
-    public:                                                          \
-        Cls_##func();                                                \
-        explicit Cls_##func(int n);                                  \
-        Cls_##func(const Indicator& ref_ind, int n);                 \
-        virtual ~Cls_##func();                                       \
-        virtual void _checkParam(const string& name) const override; \
-        virtual void _calculate(const Indicator& data) override;     \
-        virtual IndicatorImpPtr _clone() override;                   \
-                                                                     \
-    private:                                                         \
-        Indicator m_ref_ind;                                         \
     };
-#endif
 
 #define TA_K_OUT_DEF(func)                            \
     class Cls_##func : public IndicatorImp {          \

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

@@ -447,80 +447,63 @@
         return Indicator(p);                                                               \
     }
 
-#define TA_IN2_OUT1_IMP(func, func_lookback)                                                \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                    \
-    Cls_##func::Cls_##func(const Indicator &ref_ind)                                        \
-    : IndicatorImp(#func, 1), m_ref_ind(ref_ind) {}                                         \
-    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);                                                    \
-        }                                                                                   \
-                                                                                            \
-        int lookback = func_lookback();                                                     \
-        if (lookback < 0) {                                                                 \
-            m_discard = total;                                                              \
-            return;                                                                         \
-        }                                                                                   \
-                                                                                            \
-        size_t in_discard = std::max(ind.discard(), ref.discard());                         \
-        m_discard = lookback + in_discard;                                                  \
-        if (m_discard >= total) {                                                           \
-            m_discard = total;                                                              \
-            return;                                                                         \
-        }                                                                                   \
-                                                                                            \
-        const auto *src0 = ind.data();                                                      \
-        const auto *src1 = ref.data();                                                      \
-        auto *dst = this->data();                                                           \
-        int outBegIdx;                                                                      \
-        int outNbElement;                                                                   \
-        func(m_discard, total - 1, src0, src1, &outBegIdx, &outNbElement, dst + m_discard); \
-        HKU_ASSERT((outBegIdx == m_discard) && (outBegIdx + outNbElement) <= total);        \
-    }                                                                                       \
-                                                                                            \
-    Indicator HKU_API func() {                                                              \
-        return Indicator(make_shared<Cls_##func>());                                        \
-    }                                                                                       \
-                                                                                            \
-    Indicator HKU_API func(const Indicator &ind1, const Indicator &ind2) {                  \
-        auto p = make_shared<Cls_##func>(ind2);                                             \
-        Indicator result(p);                                                                \
-        return result(ind1);                                                                \
+#define TA_IN2_OUT1_IMP(func, func_lookback)                                                      \
+    Cls_##func::Cls_##func() : Indicator2InImp(#func, 1) {}                                       \
+    Cls_##func::Cls_##func(const Indicator &ref_ind, bool fill_null)                              \
+    : Indicator2InImp(#func, ref_ind, fill_null, 1) {}                                            \
+    Cls_##func::~Cls_##func() {}                                                                  \
+                                                                                                  \
+    void Cls_##func::_calculate(const Indicator &ind) {                                           \
+        size_t total = ind.size();                                                                \
+        HKU_IF_RETURN(total == 0, void());                                                        \
+                                                                                                  \
+        Indicator ref = prepare(ind);                                                             \
+        int lookback = func_lookback();                                                           \
+        if (lookback < 0) {                                                                       \
+            m_discard = total;                                                                    \
+            return;                                                                               \
+        }                                                                                         \
+                                                                                                  \
+        size_t in_discard = std::max(ind.discard(), ref.discard());                               \
+        m_discard = lookback + in_discard;                                                        \
+        if (m_discard >= total) {                                                                 \
+            m_discard = total;                                                                    \
+            return;                                                                               \
+        }                                                                                         \
+                                                                                                  \
+        const auto *src0 = ind.data();                                                            \
+        const auto *src1 = ref.data();                                                            \
+        auto *dst = this->data();                                                                 \
+        int outBegIdx;                                                                            \
+        int outNbElement;                                                                         \
+        func(m_discard, total - 1, src0, src1, &outBegIdx, &outNbElement, dst + m_discard);       \
+        HKU_ASSERT((outBegIdx == m_discard) && (outBegIdx + outNbElement) <= total);              \
+    }                                                                                             \
+                                                                                                  \
+    Indicator HKU_API func(bool fill_null = true) {                                               \
+        auto p = make_shared<Cls_##func>();                                                       \
+        p->setParam<bool>("fill_null", fill_null);                                                \
+        return Indicator(p);                                                                      \
+    }                                                                                             \
+                                                                                                  \
+    Indicator HKU_API func(const Indicator &ind1, const Indicator &ind2, bool fill_null = true) { \
+        auto p = make_shared<Cls_##func>(ind2, fill_null);                                        \
+        Indicator result(p);                                                                      \
+        return result(ind1);                                                                      \
     }
 
 #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);                                                            \
     }                                                                                          \
                                                                                                \
-    Cls_##func::Cls_##func(int n) : 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)                                    \
-    : IndicatorImp(#func, 1), m_ref_ind(ref_ind) {                                             \
+    Cls_##func::Cls_##func(const Indicator &ref_ind, int n, bool fill_null)                    \
+    : Indicator2InImp(#func, ref_ind, fill_null, 1) {                                          \
         setParam<int>("n", n);                                                                 \
     }                                                                                          \
                                                                                                \
@@ -533,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);                                                       \
-        }                                                                                      \
+        Indicator ref = prepare(ind);                                                          \
                                                                                                \
         int n = getParam<int>("n");                                                            \
         int lookback = func_lookback(n);                                                       \
@@ -582,12 +545,13 @@
         HKU_ASSERT((outBegIdx == m_discard) && (outBegIdx + outNbElement) <= total);           \
     }                                                                                          \
                                                                                                \
-    Indicator HKU_API func(int n) {                                                            \
-        return Indicator(make_shared<Cls_##func>(n));                                          \
+    Indicator HKU_API func(int n, bool fill_null = true) {                                     \
+        return Indicator(make_shared<Cls_##func>(n, fill_null));                               \
     }                                                                                          \
                                                                                                \
-    Indicator HKU_API func(const Indicator &ind1, const Indicator &ind2, int n) {              \
-        auto p = make_shared<Cls_##func>(ind2, n);                                             \
+    Indicator HKU_API func(const Indicator &ind1, const Indicator &ind2, int n,                \
+                           bool fill_null = true) {                                            \
+        auto p = make_shared<Cls_##func>(ind2, n, fill_null);                                  \
         HKU_WARN_IF(ind2.size() == 0, "The lenght of ind2 is zero!");                          \
         Indicator result(p);                                                                   \
         return result(ind1);                                                                   \

hikyuu/include/hikyuu/indicator_talib/ta_crt.h

@@ -35,13 +35,14 @@
         return func(IndParam(n))(data);                                \
     }
 
-#define TA_IN2_OUT_CRT(func)                                              \
-    Indicator HKU_API func(const Indicator& ind1, const Indicator& ind2); \
-    Indicator HKU_API func();
+#define TA_IN2_OUT_CRT(func)                                                                     \
+    Indicator HKU_API func(const Indicator& ind1, const Indicator& ind2, bool fill_null = true); \
+    Indicator HKU_API func(bool fill_null = true);
 
-#define TA_IN2_OUT_N_CRT(func, period)                                                    \
-    Indicator HKU_API func(const Indicator& ind1, const Indicator& ind2, int n = period); \
-    Indicator HKU_API func(int n = period);
+#define TA_IN2_OUT_N_CRT(func, period)                                                   \
+    Indicator HKU_API func(const Indicator& ind1, const Indicator& ind2, int n = period, \
+                           bool fill_null = true);                                       \
+    Indicator HKU_API func(int n = period, bool fill_null = true);
 
 #define TA_K_OUT_CRT(func)    \
     Indicator HKU_API func(); \
@@ -209,10 +210,11 @@ inline Indicator TA_MAMA(const Indicator& ind, double fast_limit = 5.000000e-1,
     return TA_MAMA(fast_limit, slow_limit)(ind);
 }
 
-Indicator HKU_API TA_MAVP(const Indicator& ref_ind, int min_n = 2, int max_n = 30, int matype = 0);
+Indicator HKU_API TA_MAVP(const Indicator& ref_ind, int min_n = 2, int max_n = 30, int matype = 0,
+                          bool fill_null = true);
 inline Indicator TA_MAVP(const Indicator& ind1, const Indicator& ind2, int min_n = 2,
-                         int max_n = 30, int matype = 0) {
-    return TA_MAVP(ind2, min_n, max_n, matype)(ind1);
+                         int max_n = 30, int matype = 0, bool fill_null = true) {
+    return TA_MAVP(ind2, min_n, max_n, matype, fill_null)(ind1);
 }
 
 TA_IN1_OUT_N_CRT(TA_MAX, 30)

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_ */