hikyuu 2.7.0__py3-none-manylinux2014_aarch64.whl → 2.7.5__py3-none-manylinux2014_aarch64.whl

hikyuu/include/hikyuu/indicator/IndicatorImp.h

@@ -9,6 +9,7 @@
 #ifndef INDICATORIMP_H_
 #define INDICATORIMP_H_
 
+#include <mimalloc.h>
 #include "../config.h"
 #include "../KData.h"
 #include "../utilities/Parameter.h"
@@ -30,7 +31,7 @@ class HKU_API IndicatorImp : public enable_shared_from_this<IndicatorImp> {
     friend HKU_API std::ostream& operator<<(std::ostream& os, const IndicatorImp& imp);
 
 public:
-    enum OPType {
+    enum OPType : uint8_t {
         LEAF,   ///< 叶子节点
         OP,     /// OP(OP1,OP2) OP1->calcalue(OP2->calculate(ind))
         ADD,    ///< 加
@@ -56,6 +57,7 @@ public:
 #else
     typedef double value_t;
 #endif
+    typedef vector<value_t, mi_stl_allocator<value_t>> buffer_t;
 
 public:
     /** 默认构造函数   */
@@ -68,13 +70,15 @@ public:
     typedef shared_ptr<IndicatorImp> IndicatorImpPtr;
     IndicatorImpPtr operator()(const Indicator& ind);
 
-    size_t getResultNumber() const;
+    size_t getResultNumber() const noexcept;
+    OPType getOPType() const noexcept;
 
-    size_t discard() const;
+    size_t discard() const noexcept;
 
-    void setDiscard(size_t discard);
+    void setDiscard(size_t discard) noexcept;
+    void updateDiscard(bool force = false) noexcept;
 
-    size_t size() const;
+    size_t size() const noexcept;
 
     value_t get(size_t pos, size_t num = 0) const;
 
@@ -112,8 +116,8 @@ public:
     /** 数据中是否包含 nan 值 */
     bool existNan(size_t result_idx = 0) const;
 
-    const string& name() const;
-    void name(const string& name);
+    const string& name() const noexcept;
+    void name(const string& name) noexcept;
 
     /** 返回形如：Name(param1=val,param2=val,...) */
     string long_name() const;
@@ -121,7 +125,7 @@ public:
     virtual string formula() const;
     virtual string str() const;
 
-    bool isLeaf() const;
+    bool isLeaf() const noexcept;
 
     Indicator calculate();
 
@@ -129,7 +133,7 @@ public:
 
     void setContext(const KData&);
 
-    KData getContext() const;
+    const KData& getContext() const;
 
     void add(OPType, IndicatorImpPtr left, IndicatorImpPtr right);
 
@@ -137,6 +141,12 @@ public:
 
     IndicatorImpPtr clone();
 
+    bool isPythonObject() const noexcept;
+
+    /** 仅用于两个结果集数量相同、长度相同的指标交换数据，不交换其他参数。失败抛出异常 */
+    void swap(IndicatorImp* other);
+    void swap(IndicatorImp* other, size_t other_result_idx, size_t self_result_idx);
+
     bool haveIndParam(const string& name) const;
     void setIndParam(const string& name, const Indicator& ind);
     void setIndParam(const string& name, const IndParam& ind);
@@ -151,28 +161,46 @@ public:
     // ===================
     virtual void _calculate(const Indicator&);
 
+    // ====== start 动态周期计算相关接口 ======
+    /** 动态周期计算，子类可重载该函数，默认不支持动态周期计算 */
     virtual void _dyn_run_one_step(const Indicator& ind, size_t curPos, size_t step) {}
 
-    /** 是否支持指标动态参数 */
-    virtual bool supportIndParam() const {
-        return false;
+    /** 是否必须串行计算 */
+    bool isSerial() const noexcept {
+        return m_is_serial;
     }
+    // ====== end 动态周期计算相关接口 ======
 
-    /** 是否必须串行计算 */
-    virtual bool isSerial() const {
-        return false;
+    // ====== start 增量计算相关接口 =======
+    /** 是否支持增量计算 */
+    virtual bool supportIncrementCalculate() const;
+
+    virtual size_t min_increment_start() const {
+        return 0;
     }
 
+    virtual void _increment_calculate(const Indicator& ind, size_t start_pos) {}
+    // ====== end 增量计算相关接口 =======
+
     virtual IndicatorImpPtr _clone() {
         return make_shared<IndicatorImp>();
     }
 
-    virtual bool isNeedContext() const {
-        return false;
+    bool isNeedContext() const noexcept {
+        return m_need_context;
     }
 
     virtual void _dyn_calculate(const Indicator&);
 
+public:
+    static void enableIncrementCalculate(bool flag) {
+        ms_enable_increment_calculate = flag;
+    }
+
+    static bool enableIncrementCalculate() {
+        return ms_enable_increment_calculate;
+    }
+
 public:
     // ===================
     //  内部特殊用途公共接口
@@ -184,21 +212,21 @@ public:
     /** 判断指标公式中是否包含指定名称的指标（特殊用途） */
     bool contains(const string& name) const;
 
-    value_t* data(size_t result_idx = 0);
-    value_t const* data(size_t result_idx = 0) const;
+    value_t* data(size_t result_idx = 0) noexcept;
+    value_t const* data(size_t result_idx = 0) const noexcept;
 
     void getAllSubNodes(vector<IndicatorImpPtr>& nodes) const;
 
-    IndicatorImpPtr getRightNode() const;
-    IndicatorImpPtr getLeftNode() const;
-    IndicatorImpPtr getThreeNode() const;
+    IndicatorImpPtr getRightNode() const noexcept;
+    IndicatorImpPtr getLeftNode() const noexcept;
+    IndicatorImpPtr getThreeNode() const noexcept;
     void printTree(bool show_long_name = false) const;
     void printAllSubTrees(bool show_long_name = false) const;
     void printLeaves(bool show_long_name = false) const;
 
     /* 特殊指标需自己实现 selfAlike 函数的, needSelfAlikeCompare 应返回 true */
-    virtual bool needSelfAlikeCompare() const noexcept {
-        return false;
+    bool needSelfAlikeCompare() const noexcept {
+        return m_need_self_alike_compare;
     }
 
     // 特殊指标需自己实现 selfAlike 函数，返回true表示两个指标等效
@@ -213,8 +241,11 @@ public:
     virtual void getSeparateKTypeLeafSubNodes(vector<IndicatorImpPtr>& nodes) const {}
 
 private:
-    void initContext();
     bool needCalculate();
+    bool can_inner_calculate();
+    bool can_increment_calculate();
+    bool increment_execute_leaf_or_op(const Indicator& ind);
+    size_t increment_execute();
     void execute_add();
     void execute_sub();
     void execute_mul();
@@ -230,6 +261,7 @@ private:
     void execute_or();
     void execute_weave();
     void execute_if();
+    size_t increment_execute_if();
 
     static void inner_repeatALikeNodes(vector<IndicatorImpPtr>& sub_nodes);
     void repeatALikeNodes();
@@ -252,19 +284,24 @@ private:
 protected:
     static size_t _get_step_start(size_t pos, size_t step, size_t discard);
 
-    // 用于动态参数时，更新 discard
-    void _update_discard();
-
-    virtual bool isPythonObject() const;
+    void onlySetContext(const KData&);
 
 protected:
     string m_name;
-    size_t m_discard;
-    size_t m_result_num;
-    vector<value_t>* m_pBuffer[MAX_RESULT_NUM];
-
-    bool m_need_calculate;
-    OPType m_optype;
+    size_t m_discard{0};
+    size_t m_result_num{0};
+    KData m_context;
+    KData m_old_context;
+
+    buffer_t* m_pBuffer[MAX_RESULT_NUM];
+
+    bool m_need_context{false};
+    bool m_is_python_object{false};
+    bool m_need_self_alike_compare{false};
+    bool m_is_serial{false};
+    bool m_need_calculate{true};
+    bool m_param_changed{true};
+    OPType m_optype{LEAF};
     IndicatorImpPtr m_left;
     IndicatorImpPtr m_right;
     IndicatorImpPtr m_three;
@@ -273,11 +310,11 @@ protected:
     IndicatorImp* m_parent{nullptr};  // can't use shared_from_this in python, so not weak_ptr
 
 public:
-    static void initDynEngine();
-    static void releaseDynEngine();
+    static void initEngine();
+    static void releaseEngine();
 
 protected:
-    static ThreadPool* ms_tg;
+    static bool ms_enable_increment_calculate;
 
 #if HKU_SUPPORT_SERIALIZATION
 private:
@@ -289,7 +326,14 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_params);
         ar& BOOST_SERIALIZATION_NVP(m_discard);
         ar& BOOST_SERIALIZATION_NVP(m_result_num);
+        ar& BOOST_SERIALIZATION_NVP(m_context);
+        ar& BOOST_SERIALIZATION_NVP(m_old_context);
+        ar& BOOST_SERIALIZATION_NVP(m_need_context);
+        ar& BOOST_SERIALIZATION_NVP(m_is_python_object);
+        ar& BOOST_SERIALIZATION_NVP(m_need_self_alike_compare);
+        ar& BOOST_SERIALIZATION_NVP(m_is_serial);
         ar& BOOST_SERIALIZATION_NVP(m_need_calculate);
+        ar& BOOST_SERIALIZATION_NVP(m_param_changed);
         ar& BOOST_SERIALIZATION_NVP(m_optype);
         ar& BOOST_SERIALIZATION_NVP(m_left);
         ar& BOOST_SERIALIZATION_NVP(m_right);
@@ -308,7 +352,7 @@ private:
         for (size_t i = 0; i < act_result_num; ++i) {
             size_t count = size();
             ar& bs::make_nvp<size_t>(format("count_{}", i).c_str(), count);
-            vector<value_t>& values = *m_pBuffer[i];
+            buffer_t& values = *m_pBuffer[i];
             for (size_t j = 0; j < count; j++) {
                 if (std::isnan(values[j])) {
                     ar& boost::serialization::make_nvp<string>("item", nan);
@@ -329,7 +373,14 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_params);
         ar& BOOST_SERIALIZATION_NVP(m_discard);
         ar& BOOST_SERIALIZATION_NVP(m_result_num);
+        ar& BOOST_SERIALIZATION_NVP(m_context);
+        ar& BOOST_SERIALIZATION_NVP(m_old_context);
+        ar& BOOST_SERIALIZATION_NVP(m_need_context);
+        ar& BOOST_SERIALIZATION_NVP(m_is_python_object);
+        ar& BOOST_SERIALIZATION_NVP(m_need_self_alike_compare);
+        ar& BOOST_SERIALIZATION_NVP(m_is_serial);
         ar& BOOST_SERIALIZATION_NVP(m_need_calculate);
+        ar& BOOST_SERIALIZATION_NVP(m_param_changed);
         ar& BOOST_SERIALIZATION_NVP(m_optype);
         ar& BOOST_SERIALIZATION_NVP(m_left);
         ar& BOOST_SERIALIZATION_NVP(m_right);
@@ -338,11 +389,11 @@ private:
 
         size_t act_result_num = 0;
         ar& BOOST_SERIALIZATION_NVP(act_result_num);
+        _readyBuffer(0, act_result_num);
         for (size_t i = 0; i < act_result_num; ++i) {
-            m_pBuffer[i] = new vector<value_t>();
             size_t count = 0;
             ar& bs::make_nvp<size_t>(format("count_{}", i).c_str(), count);
-            vector<value_t>& values = *m_pBuffer[i];
+            buffer_t& values = *m_pBuffer[i];
             values.resize(count);
             for (size_t j = 0; j < count; j++) {
                 std::string vstr;
@@ -364,10 +415,6 @@ private:
 #endif
 };
 
-#if HKU_SUPPORT_SERIALIZATION
-BOOST_SERIALIZATION_ASSUME_ABSTRACT(IndicatorImp)
-#endif
-
 #if HKU_SUPPORT_SERIALIZATION
 #define INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION          \
 private:                                                       \
@@ -387,21 +434,15 @@ public:                                                      \
         return make_shared<classname>();                     \
     }
 
-#define INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(classname)                                          \
-public:                                                                                        \
-    virtual void _calculate(const Indicator& ind) override;                                    \
-    virtual void _dyn_run_one_step(const Indicator& ind, size_t curPos, size_t step) override; \
-    virtual bool supportIndParam() const override {                                            \
-        return true;                                                                           \
-    }                                                                                          \
-    virtual IndicatorImpPtr _clone() override {                                                \
-        return make_shared<classname>();                                                       \
-    }
+#define INDICATOR_IMP_SUPPORT_DYNAMIC_CYCLE \
+public:                                     \
+    virtual void _dyn_run_one_step(const Indicator& ind, size_t curPos, size_t step) override;
 
-#define INDICATOR_NEED_CONTEXT                    \
-public:                                           \
-    virtual bool isNeedContext() const override { \
-        return true;                              \
+#define INDICATOR_IMP_SUPPORT_INCREMENT                                                 \
+public:                                                                                 \
+    virtual void _increment_calculate(const Indicator& ind, size_t start_pos) override; \
+    virtual bool supportIncrementCalculate() const override {                           \
+        return true;                                                                    \
     }
 
 /** 获取 OPType 名称字符串 */
@@ -412,38 +453,49 @@ typedef shared_ptr<IndicatorImp> IndicatorImpPtr;
 HKU_API std::ostream& operator<<(std::ostream&, const IndicatorImp&);
 HKU_API std::ostream& operator<<(std::ostream&, const IndicatorImpPtr&);
 
-inline size_t IndicatorImp::getResultNumber() const {
+inline IndicatorImp::OPType IndicatorImp::getOPType() const noexcept {
+    return m_optype;
+}
+
+inline size_t IndicatorImp::getResultNumber() const noexcept {
     return m_result_num;
 }
 
-inline size_t IndicatorImp::discard() const {
+inline size_t IndicatorImp::discard() const noexcept {
     return m_discard;
 }
 
-inline size_t IndicatorImp::size() const {
+inline size_t IndicatorImp::size() const noexcept {
     return m_pBuffer[0] ? m_pBuffer[0]->size() : 0;
 }
 
-inline const string& IndicatorImp::name() const {
+inline const string& IndicatorImp::name() const noexcept {
     return m_name;
 }
 
-inline void IndicatorImp::name(const string& name) {
+inline void IndicatorImp::name(const string& name) noexcept {
     m_name = name;
 }
 
-inline bool IndicatorImp::isLeaf() const {
+inline bool IndicatorImp::isLeaf() const noexcept {
     return m_optype == LEAF ? true : false;
 }
 
-inline KData IndicatorImp::getContext() const {
-    return getParam<KData>("kdata");
+inline const KData& IndicatorImp::getContext() const {
+    return m_context;
 }
 
 inline void IndicatorImp::setContext(const Stock& stock, const KQuery& query) {
     setContext(stock.getKData(query));
 }
 
+inline void IndicatorImp::onlySetContext(const KData& k) {
+    if (m_context != k) {
+        m_old_context = m_context;
+        m_context = k;
+    }
+}
+
 inline const IndicatorImp::ind_param_map_t& IndicatorImp::getIndParams() const {
     return m_ind_params;
 }
@@ -452,11 +504,11 @@ inline bool IndicatorImp::haveIndParam(const string& name) const {
     return m_ind_params.find(name) != m_ind_params.end();
 }
 
-inline IndicatorImp::value_t* IndicatorImp::data(size_t result_idx) {
+inline IndicatorImp::value_t* IndicatorImp::data(size_t result_idx) noexcept {
     return m_pBuffer[result_idx] ? m_pBuffer[result_idx]->data() : nullptr;
 }
 
-inline IndicatorImp::value_t const* IndicatorImp::data(size_t result_idx) const {
+inline IndicatorImp::value_t const* IndicatorImp::data(size_t result_idx) const noexcept {
     return m_pBuffer[result_idx] ? m_pBuffer[result_idx]->data() : nullptr;
 }
 
@@ -464,22 +516,43 @@ inline size_t IndicatorImp::_get_step_start(size_t pos, size_t step, size_t disc
     return step == 0 || pos < discard + step ? discard : pos + 1 - step;
 }
 
-inline bool IndicatorImp::isPythonObject() const {
-    return false;
+inline bool IndicatorImp::isPythonObject() const noexcept {
+    return m_is_python_object;
 }
 
-inline IndicatorImpPtr IndicatorImp::getRightNode() const {
+inline IndicatorImpPtr IndicatorImp::getRightNode() const noexcept {
     return m_right;
 }
 
-inline IndicatorImpPtr IndicatorImp::getLeftNode() const {
+inline IndicatorImpPtr IndicatorImp::getLeftNode() const noexcept {
     return m_left;
 }
 
-inline IndicatorImpPtr IndicatorImp::getThreeNode() const {
+inline IndicatorImpPtr IndicatorImp::getThreeNode() const noexcept {
     return m_three;
 }
 
+inline std::ostream& operator<<(std::ostream& os, const IndicatorImp::buffer_t& p) {
+    if (p.empty()) {
+        os << "[]";
+        return os;
+    }
+
+    size_t len = p.size();
+    const size_t print = 3;
+    os << "[";
+    for (size_t i = 0; i < len; i++) {
+        if ((i < print) || (i + print >= len)) {
+            os << p[i];
+            if (i + 1 != len)
+                os << ", ";
+        } else if (i == 3)
+            os << "..., ";
+    }
+    os << "]";
+    return os;
+}
+
 } /* namespace hku */
 
 #if FMT_VERSION >= 90000

hikyuu/include/hikyuu/indicator/crt/CONTEXT.h

@@ -24,10 +24,20 @@ Indicator HKU_API CONTEXT(const Indicator& ind, bool fill_null = false, bool use
 Indicator HKU_API CONTEXT(bool fill_null = false, bool use_self_ktype = false,
                           bool use_self_recover_type = false);
 
+/**
+ * @brief 通过指定股票，设置指标独立上下文指标
+ * @param ind 输入指标公式，如果自身携带上下文，将被忽略
+ * @param stk 指定股票
+ * @param fill_null 是否填充空值，默认为 false
+ * @return Indicator
+ */
+Indicator HKU_API CONTEXT(const Indicator& ind, const Stock& stk, bool fill_null = false);
+
 /**
  * 获取指标上下文
  * @note Indicator::getContext()方法获取的是当前的上下文，但对于 CONTEXT
- * 独立上下文指标无法获取其指定的独立上下文，需用此方法获取
+ * 独立上下文指标无法获取其指定的独立上下文，需用此方法获取。
+ * 该指标一旦作为公式，参与计算，其上下文可能发生变化，但其stock保持不变，仅query范围发生改变
  * @param ind
  * @return KData
  */

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

@@ -18,32 +18,37 @@ namespace hku {
         天的收益”（比如过去 5 天的收益），并称之为 “当前 IC”。(否则当前值都会是缺失NA)
         如需严格“t 时刻因子值→t+1 时刻收益“计算，请设置 strict=True (注意此模式下, 后n位为 NA)
  * @param stks 证券组合
- * @param query 查询条件
- * @param ref_stk 参照证券，默认 sh000300 沪深300
  * @param n 时间窗口 (对应 n 日收益率)
  * @param spearman 使用 spearman 相关系数，否则为 pearson
  * @param strict 严格模式， 遵循IC定义“t 时刻因子值→t+1 时刻收益”
  * @return Indicator
  * @ingroup Indicator
  */
-Indicator HKU_API IC(const StockList& stks, const KQuery& query,
-                     const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true,
-                     bool strict = false);
+Indicator HKU_API IC(const StockList& stks, int n = 1, bool spearman = true, bool strict = false);
 
-Indicator HKU_API IC(const Block& blk, const KQuery& query,
-                     const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true,
-                     bool strict = false);
+Indicator HKU_API IC(const Block& blk, int n = 1, bool spearman = true, bool strict = false);
 
-inline Indicator IC(const Indicator& ind, const StockList& stks, const KQuery& query,
-                    const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true,
+inline Indicator IC(const Indicator& ind, const StockList& stks, int n = 1, bool spearman = true,
                     bool strict = false) {
-    return IC(stks, query, ref_stk, n, spearman, strict)(ind);
+    return IC(stks, n, spearman, strict)(ind);
 }
 
-inline Indicator IC(const Indicator& ind, const Block& blk, const KQuery& query,
-                    const Stock& ref_stk = getStock("sh000300"), int n = 1, bool spearman = true,
+inline Indicator IC(const Indicator& ind, const Block& blk, int n = 1, bool spearman = true,
                     bool strict = false) {
-    return IC(blk, query, ref_stk, n, spearman, strict)(ind);
+    return IC(blk, n, spearman, strict)(ind);
 }
 
+/**
+ * @brief 计算指定的因子列表相对于指定的收益列表的
+ * IC，其中，inds和returns均为已经计算好并按日期对齐后的结果。inds不需要按n右移。
+ * @note 仅为数值计算，返回结果无对齐日期
+ * @param inds 因子列表，inds不需要按n右移。
+ * @param returns 收益列表
+ * @param n 时间窗口 (对应 n 日收益率)
+ * @param use_spearman 使用 spearman 相关系数，否则为 pearson
+ * @param strict 严格模式， 遵循IC定义“t 时刻因子值→t+1 时刻收益”
+ */
+Indicator HKU_API IC(IndicatorList inds, IndicatorList returns, int n = 1, bool use_spearman = true,
+                     bool strict = false);
+
 }  // namespace hku

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

@@ -22,7 +22,6 @@ namespace hku {
  * @param ind 因子公式
  * @param stks 证券组合
  * @param query 查询条件
- * @param ref_stk 参照证券，默认 sh000300 沪深300
  * @param n IC对应的N日收益率
  * @param rolling_n 滚动时间窗口
  * @param spearman 使用 spearman 相关系数，否则为 pearson
@@ -30,10 +29,9 @@ namespace hku {
  * @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,
+inline Indicator ICIR(const Indicator& ind, const StockList& stks, int n = 1, int rolling_n = 120,
                       bool spearman = true, bool strict = false) {
-    Indicator ic = IC(ind, stks, query, ref_stk, n, spearman, strict);
+    Indicator ic = IC(ind, stks, n, spearman, strict);
     Indicator x = MA(ic, rolling_n) / STDEV(ic, rolling_n);
     x.name("ICIR");
     x.setParam<int>("n", n);
@@ -41,10 +39,9 @@ inline Indicator ICIR(const Indicator& ind, const StockList& stks, const KQuery&
     return x;
 }
 
-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,
+inline Indicator ICIR(const Indicator& ind, const Block& blk, int n = 1, int rolling_n = 120,
                       bool spearman = true, bool strict = false) {
-    Indicator ic = IC(ind, blk, query, ref_stk, n, spearman, strict);
+    Indicator ic = IC(ind, blk, n, spearman, strict);
     Indicator x = MA(ic, rolling_n) / STDEV(ic, rolling_n);
     x.name("ICIR");
     x.setParam<int>("n", n);

hikyuu/include/hikyuu/indicator/imp/IAbs.h

@@ -15,6 +15,7 @@ namespace hku {
 
 class IAbs : public IndicatorImp {
     INDICATOR_IMP(IAbs)
+    INDICATOR_IMP_SUPPORT_INCREMENT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:

hikyuu/include/hikyuu/indicator/imp/IAcos.h

@@ -17,6 +17,7 @@ namespace hku {
 
 class IAcos : public IndicatorImp {
     INDICATOR_IMP(IAcos)
+    INDICATOR_IMP_SUPPORT_INCREMENT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:

hikyuu/include/hikyuu/indicator/imp/IAd.h

@@ -17,12 +17,10 @@ namespace hku {
 
 class IAd : public IndicatorImp {
     INDICATOR_IMP(IAd)
-    INDICATOR_NEED_CONTEXT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:
     IAd();
-    explicit IAd(const KData&);
     virtual ~IAd();
 };
 

hikyuu/include/hikyuu/indicator/imp/IAdvance.h

@@ -23,6 +23,9 @@ public:
     IAdvance();
     virtual ~IAdvance();
     virtual void _checkParam(const string& name) const override;
+
+    virtual bool supportIncrementCalculate() const override;
+    virtual void _increment_calculate(const Indicator& ind, size_t start_pos) override;
 };
 
 } /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/IAma.h

@@ -21,6 +21,7 @@ namespace hku {
  */
 class IAma : public IndicatorImp {
     INDICATOR_IMP(IAma)
+    INDICATOR_IMP_SUPPORT_INCREMENT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:
@@ -30,6 +31,8 @@ public:
     virtual void _checkParam(const string& name) const override;
     virtual void _dyn_calculate(const Indicator&) override;
 
+    virtual size_t min_increment_start() const override;
+
 private:
     void _dyn_one_circle(const Indicator& ind, size_t curPos, int n, int fast_n, int slow_n);
 };

hikyuu/include/hikyuu/indicator/imp/IAsin.h

@@ -17,6 +17,7 @@ namespace hku {
 
 class IAsin : public IndicatorImp {
     INDICATOR_IMP(IAsin)
+    INDICATOR_IMP_SUPPORT_INCREMENT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:

hikyuu/include/hikyuu/indicator/imp/IAtan.h

@@ -17,6 +17,7 @@ namespace hku {
 
 class IAtan : public IndicatorImp {
     INDICATOR_IMP(IAtan)
+    INDICATOR_IMP_SUPPORT_INCREMENT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:

hikyuu/include/hikyuu/indicator/imp/IAtr.h

@@ -15,16 +15,15 @@ namespace hku {
 
 class IAtr : public IndicatorImp {
     INDICATOR_IMP(IAtr)
-    INDICATOR_NEED_CONTEXT
+    INDICATOR_IMP_SUPPORT_INCREMENT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:
     IAtr();
-    explicit IAtr(const KData&, int n);
     virtual ~IAtr();
     virtual void _checkParam(const string& name) const override;
 };
 
 } /* namespace hku */
 
-#endif /* INDICATOR_IMP_ATR_H_ */
+#endif /* INDICATOR_IMP_ATR_H_ */

hikyuu/include/hikyuu/indicator/imp/IBackset.h

@@ -16,7 +16,8 @@
 namespace hku {
 
 class IBackset : public IndicatorImp {
-    INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(IBackset)
+    INDICATOR_IMP(IBackset)
+    INDICATOR_IMP_SUPPORT_DYNAMIC_CYCLE
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:
@@ -24,9 +25,6 @@ public:
     virtual ~IBackset();
 
     virtual void _checkParam(const string& name) const override;
-    virtual bool isSerial() const override {
-        return true;
-    }
 };
 
 } /* namespace hku */