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

hikyuu/include/hikyuu/trade_sys/portfolio/imp/WithoutAFPortfolio.h

@@ -0,0 +1,57 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_PORTFOLIO_WITHOUTAF_H_
+#define TRADE_SYS_PORTFOLIO_WITHOUTAF_H_
+
+#include "hikyuu/trade_sys/portfolio/Portfolio.h"
+
+namespace hku {
+
+/*
+ * 无资金分配算法的资产组合
+ * @ingroup WithoutAFPortfolio
+ */
+class HKU_API WithoutAFPortfolio : public Portfolio {
+    PORTFOLIO_IMP(WithoutAFPortfolio)
+
+public:
+    WithoutAFPortfolio();
+    WithoutAFPortfolio(const TradeManagerPtr& tm, const SelectorPtr& se);
+    virtual ~WithoutAFPortfolio();
+
+private:
+    void initParam();
+    void _runMomentWithoutAFNotForceSell(const Datetime& date, const Datetime& nextCycle,
+                                         bool adjust);
+    void _runMomentWithoutAFForceSell(const Datetime& date, const Datetime& nextCycle, bool adjust);
+
+private:
+    SystemList m_force_sell_sys_list;  // 强制卖出的系统列表
+    list<SYSPtr> m_running_sys_list;   // 当前运行中的系统列表，需要依次执行
+    SystemList m_selected_list;        // 本轮周期内选中的系统列表
+
+    // 记录指派给SE的系统到内部实际系统映射
+    unordered_map<SYSPtr, SYSPtr> m_se_sys_to_pf_sys_dict;
+
+//============================================
+// 序列化支持
+//============================================
+#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(Portfolio);
+    }
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_PORTFOLIO_WITHOUTAF_H_ */

hikyuu/include/hikyuu/trade_sys/selector/imp/MultiFactorSelector.h

@@ -30,6 +30,13 @@ public:
         m_inds = inds;
     }
 
+private:
+    ScoreRecordList filterOnlyShouldBuy(Datetime date, const ScoreRecordList& scores, size_t topn);
+    ScoreRecordList filterTopN(Datetime date, const ScoreRecordList& raw_scores, size_t topn,
+                               bool only_should_buy);
+    ScoreRecordList filterTopNReverse(Datetime date, const ScoreRecordList& raw_scores, size_t topn,
+                                      bool only_should_buy, bool ignore_null);
+
 private:
     IndicatorList m_inds;
     MFPtr m_mf;

hikyuu/include/hikyuu/trade_sys/signal/SignalBase.h

@@ -44,6 +44,22 @@ public:
      */
     bool shouldSell(const Datetime& datetime) const;
 
+    /**
+     * 获取指定时刻的买入信号数值，返回值小于等于0时，表示无买入信号
+     * @param datetime
+     * @return double
+     */
+    double getBuyValue(const Datetime& datetime) const;
+
+    /**
+     * 获取指定时刻的买出信号数值，返回值大于等于0时，表示无卖出信号
+     * @param datetime
+     * @return double
+     */
+    double getSellValue(const Datetime& datetime) const;
+
+    double getValue(const Datetime& datetime) const;
+
     /**
      * 下一时刻是否可以买入，相当于最后时刻是否指示买入
      */
@@ -60,17 +76,21 @@ public:
     /** 获取所有卖出指示日期列表 */
     DatetimeList getSellSignal() const;
 
+    void _addSignal(const Datetime& datetime, double value);
+
     /**
      * 加入买入信号，在_calculate中调用
      * @param datetime 发生买入信号的日期
+     * @param value 信号值，默认为1.0, 必须大于0，否则抛出异常
      */
-    void _addBuySignal(const Datetime& datetime);
+    void _addBuySignal(const Datetime& datetime, double value = 1.0);
 
     /**
      * 加入卖出信号，在_calculate中调用
      * @param datetime
+     * @param value 信号值，默认为-1.0，必须小于0，否则抛出异常
      */
-    void _addSellSignal(const Datetime& datetime);
+    void _addSellSignal(const Datetime& datetime, double value = -1.0);
 
     /**
      * 指定交易对象，指K线数据
@@ -87,6 +107,9 @@ public:
     void startCycle(const Datetime& start, const Datetime& end);
     const Datetime& getCycleStart() const;
     const Datetime& getCycleEnd() const;
+    bool ignoreCycle() const {
+        return m_ignore_cycle;
+    }
 
     /** 复位操作 */
     void reset();
@@ -116,17 +139,20 @@ private:
 protected:
     string m_name;
     KData m_kdata;
+    bool m_calculated{false};  // 仅针对 setTO 时的计算
+
     /* 多头持仓 */
     bool m_hold_long;
     /* 空头持仓 */
     bool m_hold_short;
 
-    // 用 set 保存，以便获取是能保持顺序
-    std::set<Datetime> m_buySig;
-    std::set<Datetime> m_sellSig;
+    // 用 map 保存，以便获取是能保持顺序
+    std::map<Datetime, double> m_buySig;
+    std::map<Datetime, double> m_sellSig;
 
     Datetime m_cycle_start;
     Datetime m_cycle_end;
+    bool m_ignore_cycle{false};  // 特殊用途，用于 OperatorSignal
 
 //============================================
 // 序列化支持
@@ -142,8 +168,10 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_hold_short);
         ar& BOOST_SERIALIZATION_NVP(m_buySig);
         ar& BOOST_SERIALIZATION_NVP(m_sellSig);
+        ar& BOOST_SERIALIZATION_NVP(m_ignore_cycle);
         // m_kdata都是系统运行时临时设置，不需要序列化
         // ar & BOOST_SERIALIZATION_NVP(m_kdata);
+        // ar & BOOST_SERIALIZATION_NVP(m_calculated);
     }
 
     template <class Archive>
@@ -154,8 +182,10 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_hold_short);
         ar& BOOST_SERIALIZATION_NVP(m_buySig);
         ar& BOOST_SERIALIZATION_NVP(m_sellSig);
+        ar& BOOST_SERIALIZATION_NVP(m_ignore_cycle);
         // m_kdata都是系统运行时临时设置，不需要序列化
         // ar & BOOST_SERIALIZATION_NVP(m_kdata);
+        // ar & BOOST_SERIALIZATION_NVP(m_calculated);
     }
 
     BOOST_SERIALIZATION_SPLIT_MEMBER()
@@ -236,6 +266,22 @@ inline const Datetime& SignalBase::getCycleEnd() const {
     return m_cycle_end;
 }
 
+inline double SignalBase::getValue(const Datetime& datetime) const {
+    return getBuyValue(datetime) + getSellValue(datetime);
+}
+
+inline void SignalBase::_addBuySignal(const Datetime& datetime, double value) {
+    HKU_IF_RETURN(std::isnan(value), void());
+    HKU_CHECK(value > 0.0, "buy value muse be > 0", value);
+    _addSignal(datetime, value);
+}
+
+inline void SignalBase::_addSellSignal(const Datetime& datetime, double value) {
+    HKU_IF_RETURN(std::isnan(value), void());
+    HKU_CHECK(value < 0.0, "sell value muse be > 0", value);
+    _addSignal(datetime, value);
+}
+
 } /* namespace hku */
 
 #if FMT_VERSION >= 90000

hikyuu/include/hikyuu/trade_sys/signal/build_in.h

@@ -17,6 +17,8 @@
 #include "crt/SG_Single.h"
 #include "crt/SG_Bool.h"
 #include "crt/SG_Band.h"
+#include "crt/SG_Logic.h"
 #include "crt/SG_Manual.h"
+#include "crt/SG_OneSide.h"
 
 #endif /* SIGNAL_BUILD_IN_H_ */

hikyuu/include/hikyuu/trade_sys/signal/crt/SG_Bool.h

@@ -18,10 +18,11 @@ namespace hku {
  * 布尔信号指示器
  * @param buy 买入指示（结果Indicator中相应位置>0则代表买入）
  * @param sell 卖出指示（结果Indicator中相应位置>0则代表卖出）
+ * @param alternate 买入与卖出信号是否交替出现，默认为true
  * @return 信号指示器
  * @ingroup Signal
  */
-SignalPtr HKU_API SG_Bool(const Indicator& buy, const Indicator& sell);
+SignalPtr HKU_API SG_Bool(const Indicator& buy, const Indicator& sell, bool alternate = true);
 
 } /* namespace hku */
 

hikyuu/include/hikyuu/trade_sys/signal/crt/SG_Logic.h

@@ -0,0 +1,37 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SignalBase.h"
+
+namespace hku {
+
+HKU_API SignalPtr operator+(const SignalPtr& sg1, const SignalPtr& sg2);
+HKU_API SignalPtr operator-(const SignalPtr& sg1, const SignalPtr& sg2);
+HKU_API SignalPtr operator*(const SignalPtr& sg1, const SignalPtr& sg2);
+HKU_API SignalPtr operator/(const SignalPtr& sg1, const SignalPtr& sg2);
+
+HKU_API SignalPtr operator+(const SignalPtr& sg, double value);
+HKU_API SignalPtr operator-(const SignalPtr& sg, double value);
+HKU_API SignalPtr operator*(const SignalPtr& sg, double value);
+HKU_API SignalPtr operator/(const SignalPtr& sg, double value);
+
+HKU_API SignalPtr operator+(double value, const SignalPtr& sg);
+HKU_API SignalPtr operator-(double value, const SignalPtr& sg);
+HKU_API SignalPtr operator*(double value, const SignalPtr& sg);
+HKU_API SignalPtr operator/(double value, const SignalPtr& sg);
+
+inline SignalPtr operator&(const SignalPtr& sg1, const SignalPtr& sg2) {
+    return sg1 * sg2;
+}
+
+inline SignalPtr operator|(const SignalPtr& sg1, const SignalPtr& sg2) {
+    return sg1 + sg2;
+}
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/signal/crt/SG_OneSide.h

@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_SIGNAL_CRT_SG_ONESIDE_H_
+#define TRADE_SYS_SIGNAL_CRT_SG_ONESIDE_H_
+
+#include "../../../indicator/Indicator.h"
+#include "../SignalBase.h"
+
+namespace hku {
+
+/**
+ * 根据输入指标构建单边信号（单纯的只包含买入或卖出信号），如果指标值大于0，则加入信号
+ * @param ind 指示指标
+ * @param is_buy 加入的是买入信号还是卖出信号
+ * @return 信号指示器
+ * @ingroup Signal
+ */
+SignalPtr HKU_API SG_OneSide(const Indicator& ind, bool is_buy);
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_SIGNAL_CRT_SG_ONESIDE_H_ */

hikyuu/include/hikyuu/trade_sys/signal/imp/OneSideSignal.h

@@ -0,0 +1,46 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_SIGNAL_IMP_ONESIDESIGNAL_H_
+#define TRADE_SYS_SIGNAL_IMP_ONESIDESIGNAL_H_
+
+#include "../../../indicator/Indicator.h"
+#include "../SignalBase.h"
+
+namespace hku {
+
+// 根据输入指标构建单边信号（单纯的只包含买入或卖出信号），如果指标值大于0，则加入信号
+class OneSideSignal : public SignalBase {
+public:
+    OneSideSignal();
+    OneSideSignal(const Indicator& ind, bool is_buy);
+    virtual ~OneSideSignal();
+
+    virtual SignalPtr _clone() override;
+    virtual void _calculate(const KData& kdata) override;
+    virtual void _checkParam(const string& name) const override;
+
+private:
+    Indicator m_ind;
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SignalBase);
+        ar& BOOST_SERIALIZATION_NVP(m_ind);
+    }
+#endif
+};
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_SIGNAL_IMP_ONESIDESIGNAL_H_ */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/AddSignal.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSignal.h"
+
+namespace hku {
+
+class AddSignal : public OperatorSignal {
+    OPERATOR_SIGNAL_IMP(AddSignal, "SG_Add")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/AddValueSignal.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSignal.h"
+
+namespace hku {
+
+class AddValueSignal : public OperatorValueSignal {
+    OPERATOR_SIGNAL_IMP(AddValueSignal, "SG_AddValue")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/DivSignal.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSignal.h"
+
+namespace hku {
+
+class DivSignal : public OperatorSignal {
+    OPERATOR_SIGNAL_IMP(DivSignal, "SG_Div")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/DivValueSignal.h

@@ -0,0 +1,22 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSignal.h"
+
+namespace hku {
+
+class DivValueSignal : public OperatorValueSignal {
+    OPERATOR_SIGNAL_IMP(DivValueSignal, "SG_DivValue")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    DivValueSignal(double value, const SignalPtr& sg);
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/MulSignal.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSignal.h"
+
+namespace hku {
+
+class MulSignal : public OperatorSignal {
+    OPERATOR_SIGNAL_IMP(MulSignal, "SG_Mul")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/MulValueSignal.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSignal.h"
+
+namespace hku {
+
+class MulValueSignal : public OperatorValueSignal {
+    OPERATOR_SIGNAL_IMP(MulValueSignal, "SG_MulValue")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/OperatorSignal.h

@@ -0,0 +1,68 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/signal/SignalBase.h"
+
+namespace hku {
+
+class OperatorSignal : public SignalBase {
+public:
+    OperatorSignal();
+    explicit OperatorSignal(const string& name);
+    OperatorSignal(const string& name, const SignalPtr& sg1, const SignalPtr& sg2);
+    virtual ~OperatorSignal();
+
+    virtual void _reset() override;
+    virtual SignalPtr _clone() override;
+    virtual void _calculate(const KData& kdata) override {}
+
+protected:
+    void sub_sg_calculate(SignalPtr& sg, const KData& kdata);
+
+protected:
+    SignalPtr m_sg1;
+    SignalPtr m_sg2;
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SignalBase);
+        ar& BOOST_SERIALIZATION_NVP(m_sg1);
+        ar& BOOST_SERIALIZATION_NVP(m_sg2);
+    }
+#endif
+};
+
+#define OPERATOR_SIGNAL_IMP(classname, name)                                                  \
+public:                                                                                       \
+    classname() : OperatorSignal(name) {}                                                     \
+    classname(const SignalPtr& sg1, const SignalPtr& sg2) : OperatorSignal(name, sg1, sg2) {} \
+    virtual ~classname() {}                                                                   \
+    virtual SignalPtr _clone() override {                                                     \
+        return make_shared<classname>(m_sg1, m_sg2);                                          \
+    }                                                                                         \
+    virtual void _calculate(const KData&) override;
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION          \
+private:                                                         \
+    friend class boost::serialization::access;                   \
+    template <class Archive>                                     \
+    void serialize(Archive& ar, const unsigned int version) {    \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(OperatorSignal); \
+    }
+#else
+#define OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/OperatorValueSignal.h

@@ -0,0 +1,67 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/signal/SignalBase.h"
+
+namespace hku {
+
+class OperatorValueSignal : public SignalBase {
+public:
+    OperatorValueSignal();
+    explicit OperatorValueSignal(const string& name);
+    OperatorValueSignal(const string& name, const SignalPtr& sg, double value, int mode = 0);
+    virtual ~OperatorValueSignal();
+
+    virtual void _reset() override;
+    virtual SignalPtr _clone() override;
+    virtual void _calculate(const KData& kdata) override {}
+
+protected:
+    double m_value{0.0};
+    SignalPtr m_sg;
+    int m_mode{0};  // 仅对-、/有效，0：(sg, value), 1: (value, sg)
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SignalBase);
+        ar& BOOST_SERIALIZATION_NVP(m_sg);
+        ar& BOOST_SERIALIZATION_NVP(m_value);
+        ar& BOOST_SERIALIZATION_NVP(m_mode);
+    }
+#endif
+};
+
+#define OPERATOR_SIGNAL_IMP(classname, name)                                               \
+public:                                                                                    \
+    classname() : OperatorValueSignal(name) {}                                             \
+    classname(const SignalPtr& sg, double value) : OperatorValueSignal(name, sg, value) {} \
+    virtual ~classname() {}                                                                \
+    virtual SignalPtr _clone() override {                                                  \
+        return make_shared<classname>(m_sg, m_value);                                      \
+    }                                                                                      \
+    virtual void _calculate(const KData&) override;
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION               \
+private:                                                              \
+    friend class boost::serialization::access;                        \
+    template <class Archive>                                          \
+    void serialize(Archive& ar, const unsigned int version) {         \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(OperatorValueSignal); \
+    }
+#else
+#define OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/SubSignal.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSignal.h"
+
+namespace hku {
+
+class SubSignal : public OperatorSignal {
+    OPERATOR_SIGNAL_IMP(SubSignal, "SG_Sub")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/SubValueSignal.h

@@ -0,0 +1,22 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSignal.h"
+
+namespace hku {
+
+class SubValueSignal : public OperatorValueSignal {
+    OPERATOR_SIGNAL_IMP(SubValueSignal, "SG_AddValue")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    SubValueSignal(double value, const SignalPtr& sg);
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/stoploss/crt/ST_Indicator.h

@@ -14,7 +14,7 @@
 
 namespace hku {
 
-StoplossPtr HKU_API ST_Indicator(const Indicator& op, const string& kpart = "CLOSE");
+StoplossPtr HKU_API ST_Indicator(const Indicator& ind);
 
 } /* namespace hku */
 

hikyuu/include/hikyuu/trade_sys/stoploss/imp/IndicatorStoploss.h

@@ -17,17 +17,16 @@ namespace hku {
 class IndicatorStoploss : public StoplossBase {
 public:
     IndicatorStoploss();  // 仅用于序列化默认构造函数
-    IndicatorStoploss(const Indicator& op, const string& kdata_part);
+    explicit IndicatorStoploss(const Indicator& ind);
     virtual ~IndicatorStoploss();
 
-    virtual void _checkParam(const string& name) const override;
     virtual price_t getPrice(const Datetime& datetime, price_t price) override;
     virtual void _reset() override;
     virtual StoplossPtr _clone() override;
     virtual void _calculate() override;
 
 private:
-    Indicator m_op;
+    Indicator m_ind;
     map<Datetime, price_t> m_result;
 
 //========================================
@@ -39,7 +38,7 @@ private:
     template <class Archive>
     void serialize(Archive& ar, const unsigned int version) {
         ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(StoplossBase);
-        ar& BOOST_SERIALIZATION_NVP(m_op);
+        ar& BOOST_SERIALIZATION_NVP(m_ind);
         // m_result 每次系统运行时都要重新计算，不保存
         // ar & BOOST_SERIALIZATION_NVP(m_result);
     }