hikyuu 2.6.8__py3-none-manylinux2014_x86_64.whl

hikyuu/include/hikyuu/trade_sys/selector/imp/logic/OperatorValueSelector.h

@@ -0,0 +1,94 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/selector/SelectorBase.h"
+
+namespace hku {
+
+class HKU_API OperatorValueSelector : public SelectorBase {
+public:
+    OperatorValueSelector();
+    explicit OperatorValueSelector(const string& name);
+    OperatorValueSelector(const string& name, const SelectorPtr& se, double value);
+    virtual ~OperatorValueSelector();
+
+    virtual void _reset() override;
+    virtual SelectorPtr _clone() override;
+    virtual bool isMatchAF(const AFPtr& af) override;
+    virtual void _calculate() override;
+    virtual SystemWeightList _getSelected(Datetime date) override {
+        return SystemWeightList();
+    }
+
+protected:
+    SelectorPtr m_se;
+    double m_value{0.0};
+
+private:
+    //============================================
+    // 序列化支持
+    //============================================
+#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(SelectorBase);
+    //     ar& BOOST_SERIALIZATION_NVP(m_se);
+    //     ar& BOOST_SERIALIZATION_NVP(m_value);
+    // }
+    template <class Archive>
+    void save(Archive& ar, const unsigned int version) const {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SelectorBase);
+        ar& BOOST_SERIALIZATION_NVP(m_se);
+        ar& BOOST_SERIALIZATION_NVP(m_value);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SelectorBase);
+        ar& BOOST_SERIALIZATION_NVP(m_se);
+        ar& BOOST_SERIALIZATION_NVP(m_value);
+        if (m_se) {
+            m_pro_sys_list = m_se->getProtoSystemList();
+        }
+    }
+
+#endif
+};
+
+#define OPERATOR_VALUE_SELECTOR_IMP(classname, name)                                           \
+public:                                                                                        \
+    classname() : OperatorValueSelector(name) {}                                               \
+    classname(const SelectorPtr& se, double value) : OperatorValueSelector(name, se, value) {} \
+    virtual ~classname() {}                                                                    \
+                                                                                               \
+    virtual SystemWeightList _getSelected(Datetime date) override;                             \
+                                                                                               \
+    virtual SelectorPtr _clone() override {                                                    \
+        auto p = std::make_shared<classname>();                                                \
+        if (m_se) {                                                                            \
+            p->m_se = m_se->clone();                                                           \
+        }                                                                                      \
+        p->m_value = m_value;                                                                  \
+        return p;                                                                              \
+    }
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPERATOR_VALUE_SELECTOR_SERIALIZATION                           \
+private:                                                                \
+    friend class boost::serialization::access;                          \
+    template <class Archive>                                            \
+    void serialize(Archive& ar, const unsigned int version) {           \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(OperatorValueSelector); \
+    }
+#else
+#define OPERATOR_VALUE_SELECTOR_SERIALIZATION
+#endif
+
+}  // namespace hku

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

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/MaxFundsOptimalSelector.h

@@ -0,0 +1,27 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-22
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_TRADE_SYS_MAX_FUNDS_OPTIMAL_SELECTOR_H_
+#define HKU_TRADE_SYS_MAX_FUNDS_OPTIMAL_SELECTOR_H_
+
+#include "OptimalSelectorBase.h"
+
+namespace hku {
+
+class MaxFundsOptimalSelector : public OptimalSelectorBase {
+    OPTIMAL_SELECTOR_IMP(MaxFundsOptimalSelector)
+    OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    MaxFundsOptimalSelector();
+    virtual ~MaxFundsOptimalSelector();
+};
+
+}  // namespace hku
+
+#endif /* HKU_TRADE_SYS_MAX_FUNDS_OPTIMAL_SELECTOR_H_ */

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/OptimalEvaluateSelector.h

@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-22
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OptimalSelectorBase.h"
+
+namespace hku {
+
+class OptimalEvaluateSelector : public OptimalSelectorBase {
+    OPTIMAL_SELECTOR_IMP(OptimalEvaluateSelector)
+    OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    OptimalEvaluateSelector();
+    OptimalEvaluateSelector(std::function<double(const SystemPtr&, const Datetime&)>&& evaluate);
+
+    virtual ~OptimalEvaluateSelector();
+
+private:
+    std::function<double(const SystemPtr&, const Datetime&)> m_evaluate;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/OptimalSelectorBase.h

@@ -0,0 +1,87 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+#include "hikyuu/trade_sys/selector/SelectorBase.h"
+
+namespace hku {
+
+//
+// start ------ run_start --end
+// | train_len | test_len
+//
+struct RunRanges {
+    Datetime start;
+    Datetime run_start;
+    Datetime end;
+
+    RunRanges(const Datetime& start_, const Datetime& run_start_, const Datetime end_)
+    : start(start_), run_start(run_start_), end(end_) {}
+};
+
+class HKU_API OptimalSelectorBase : public SelectorBase {
+    CLASS_LOGGER_IMP(SE_Optimal)
+    SELECTOR_IMP(OptimalSelectorBase)
+    SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    OptimalSelectorBase();
+    explicit OptimalSelectorBase(const string& name);
+    virtual ~OptimalSelectorBase() = default;
+
+    virtual void _checkParam(const string& name) const override;
+    virtual void calculate(const SystemList& pf_realSysList, const KQuery& query) override;
+
+    virtual void _reset() override;
+
+    virtual string str() const override;
+
+    // 以便继承子类只需要实现 _clone 和 该接口即可
+    // 该接口实现系统绩效评估，getSelected 时将取评估结果最大的系统
+    // 使用 std::function 的话，在 C++ 中无法序列化，所以使用继承
+    // 返回 Null<double> 时，将不被评估选中
+    virtual double evaluate(const SYSPtr& sys, const Datetime& endDate) noexcept {
+        return Null<double>();
+    }
+
+    const vector<RunRanges>& getRunRanges() const {
+        return m_run_ranges;
+    }
+
+private:
+    void _initParams();
+    void _calculate_single(const vector<std::pair<size_t, size_t>>& train_ranges,
+                           const DatetimeList& dates, size_t test_len, bool trace);
+
+    void _calculate_parallel(const vector<std::pair<size_t, size_t>>& train_ranges,
+                             const DatetimeList& dates, size_t test_len, bool trace);
+
+protected:
+    unordered_map<Datetime, std::shared_ptr<SystemWeightList>> m_sys_dict;
+    vector<RunRanges> m_run_ranges;
+};
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPTIMAL_SELECTOR_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(SelectorBase); \
+    }
+#else
+#define OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+#define OPTIMAL_SELECTOR_IMP(classname)       \
+public:                                       \
+    virtual SelectorPtr _clone() override {   \
+        return std::make_shared<classname>(); \
+    }                                         \
+    virtual double evaluate(const SYSPtr&, const Datetime& endDate) noexcept override;
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/PerformanceOptimalSelector.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OptimalSelectorBase.h"
+
+namespace hku {
+
+class PerformanceOptimalSelector : public OptimalSelectorBase {
+    CLASS_LOGGER_IMP(SE_Optimal)
+    OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    PerformanceOptimalSelector();
+    virtual ~PerformanceOptimalSelector() = default;
+
+    virtual void _checkParam(const string& name) const override;
+    virtual void calculate(const SystemList& pf_realSysList, const KQuery& query) override;
+
+    virtual SystemWeightList _getSelected(Datetime date) override;
+    virtual SelectorPtr _clone() override;
+    virtual void _reset() override;
+
+private:
+    void _calculate_single(const vector<std::pair<size_t, size_t>>& train_ranges,
+                           const DatetimeList& dates, const string& key, int mode, size_t test_len,
+                           bool trace);
+
+    void _calculate_parallel(const vector<std::pair<size_t, size_t>>& train_ranges,
+                             const DatetimeList& dates, const string& key, int mode,
+                             size_t test_len, bool trace);
+
+private:
+    unordered_map<Datetime, SYSPtr> m_sys_dict;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/__init__.py

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,294 @@
+/*
+ * SignalBase.h
+ *
+ *  Created on: 2013-3-3
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef SIGNALBASE_H_
+#define SIGNALBASE_H_
+
+#include <set>
+#include "../../KData.h"
+#include "../../utilities/Parameter.h"
+#include "../../trade_manage/TradeManager.h"
+#include "../../serialization/Datetime_serialization.h"
+
+namespace hku {
+
+/**
+ * 信号指示器基类
+ * @ingroup Signal
+ */
+class HKU_API SignalBase : public enable_shared_from_this<SignalBase> {
+    PARAMETER_SUPPORT_WITH_CHECK
+
+public:
+    SignalBase();
+    explicit SignalBase(const string& name);
+    SignalBase(const SignalBase&) = default;
+    virtual ~SignalBase();
+
+    /**
+     * 指定时刻是否可以买入
+     * @param datetime 指定时刻
+     * @return true 可以买入 | false 不可买入
+     */
+    bool shouldBuy(const Datetime& datetime) const;
+
+    /**
+     * 指定时刻是否可以卖出
+     * @param datetime 指定时刻
+     * @return true 可以卖出 | false 不可卖出
+     */
+    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;
+
+    /**
+     * 下一时刻是否可以买入，相当于最后时刻是否指示买入
+     */
+    bool nextTimeShouldBuy() const;
+
+    /**
+     * 下一时刻是否可以卖出，相当于最后时刻是否指示卖出
+     */
+    bool nextTimeShouldSell() const;
+
+    /** 获取所有买入指示日期列表 */
+    DatetimeList getBuySignal() const;
+
+    /** 获取所有卖出指示日期列表 */
+    DatetimeList getSellSignal() const;
+
+    void _addSignal(const Datetime& datetime, double value);
+
+    /**
+     * 加入买入信号，在_calculate中调用
+     * @param datetime 发生买入信号的日期
+     * @param value 信号值，默认为1.0, 必须大于0，否则抛出异常
+     */
+    void _addBuySignal(const Datetime& datetime, double value = 1.0);
+
+    /**
+     * 加入卖出信号，在_calculate中调用
+     * @param datetime
+     * @param value 信号值，默认为-1.0，必须小于0，否则抛出异常
+     */
+    void _addSellSignal(const Datetime& datetime, double value = -1.0);
+
+    /**
+     * 指定交易对象，指K线数据
+     * @param kdata 指定的交易对象
+     */
+    void setTO(const KData& kdata);
+
+    /**
+     * 获取交易对象
+     * @return 交易对象(KData)
+     */
+    const KData& getTO() const;
+
+    void startCycle(const Datetime& start, const Datetime& end);
+    const Datetime& getCycleStart() const;
+    const Datetime& getCycleEnd() const;
+
+    /** 复位操作 */
+    void reset();
+
+    typedef shared_ptr<SignalBase> SignalPtr;
+    /** 克隆操作 */
+    SignalPtr clone();
+
+    /** 获取名称 */
+    const string& name() const;
+
+    /** 设置名称 */
+    void name(const string& name);
+
+    /** 子类复位接口 */
+    virtual void _reset() {}
+
+    /** 子类克隆接口 */
+    virtual SignalPtr _clone() = 0;
+
+    /** 子类计算接口，在setTO中调用 */
+    virtual void _calculate(const KData&) = 0;
+
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
+private:
+    void initParam();
+
+protected:
+    string m_name;
+    KData m_kdata;
+    bool m_calculated{false};  // 仅针对 setTO 时的计算
+
+    /* 多头持仓 */
+    bool m_hold_long;
+    /* 空头持仓 */
+    bool m_hold_short;
+
+    // 用 map 保存，以便获取时能保持顺序
+    std::map<Datetime, double> m_buySig;
+    std::map<Datetime, double> m_sellSig;
+
+    Datetime m_cycle_start;
+    Datetime m_cycle_end;
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void save(Archive& ar, const unsigned int version) const {
+        ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
+        ar& BOOST_SERIALIZATION_NVP(m_hold_long);
+        ar& BOOST_SERIALIZATION_NVP(m_hold_short);
+        ar& BOOST_SERIALIZATION_NVP(m_buySig);
+        ar& BOOST_SERIALIZATION_NVP(m_sellSig);
+        // m_kdata都是系统运行时临时设置，不需要序列化
+        // ar & BOOST_SERIALIZATION_NVP(m_kdata);
+        // ar & BOOST_SERIALIZATION_NVP(m_calculated);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
+        ar& BOOST_SERIALIZATION_NVP(m_hold_long);
+        ar& BOOST_SERIALIZATION_NVP(m_hold_short);
+        ar& BOOST_SERIALIZATION_NVP(m_buySig);
+        ar& BOOST_SERIALIZATION_NVP(m_sellSig);
+        // m_kdata都是系统运行时临时设置，不需要序列化
+        // ar & BOOST_SERIALIZATION_NVP(m_kdata);
+        // ar & BOOST_SERIALIZATION_NVP(m_calculated);
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+#if HKU_SUPPORT_SERIALIZATION
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(SignalBase)
+#endif
+
+#if HKU_SUPPORT_SERIALIZATION
+/**
+ * 对于没有私有变量的继承子类，可直接使用该宏定义序列化
+ * @code
+ * class Drived: public SignalBase {
+ *     SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+ *
+ * public:
+ *     Drived();
+ *     ...
+ * };
+ * @endcode
+ * @ingroup Signal
+ */
+#define 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(SignalBase);  \
+    }
+#else
+#define SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+#define SIGNAL_IMP(classname)                 \
+public:                                       \
+    virtual SignalPtr _clone() override {     \
+        return std::make_shared<classname>(); \
+    }                                         \
+    virtual void _calculate(const KData&) override;
+
+/**
+ * 客户程序都应使用该指针类型，操作信号指示器
+ * @ingroup Signal
+ */
+typedef shared_ptr<SignalBase> SignalPtr;
+typedef shared_ptr<SignalBase> SGPtr;
+
+HKU_API std::ostream& operator<<(std::ostream&, const SignalBase&);
+HKU_API std::ostream& operator<<(std::ostream&, const SignalPtr&);
+
+inline const KData& SignalBase::getTO() const {
+    return m_kdata;
+}
+
+inline const string& SignalBase::name() const {
+    return m_name;
+}
+
+inline void SignalBase::name(const string& name) {
+    m_name = name;
+}
+
+inline bool SignalBase::shouldBuy(const Datetime& datetime) const {
+    return m_buySig.count(datetime) ? true : false;
+}
+
+inline bool SignalBase::shouldSell(const Datetime& datetime) const {
+    return m_sellSig.count(datetime) ? true : false;
+}
+
+inline const Datetime& SignalBase::getCycleStart() const {
+    return m_cycle_start;
+}
+
+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
+template <>
+struct fmt::formatter<hku::SignalBase> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<hku::SignalPtr> : ostream_formatter {};
+#endif
+
+#endif /* SIGNALBASE_H_ */

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,24 @@
+/*
+ * build_in.h
+ *
+ *  Created on: 2013-4-19
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef SIGNAL_BUILD_IN_H_
+#define SIGNAL_BUILD_IN_H_
+
+#include "crt/SG_AllwaysBuy.h"
+#include "crt/SG_Cross.h"
+#include "crt/SG_CrossGold.h"
+#include "crt/SG_Cycle.h"
+#include "crt/SG_Flex.h"
+#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_AllwaysBuy.h

@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-03-30
+ *      Author: fasiondog
+ */
+
+#pragma once
+#include "../SignalBase.h"
+
+namespace hku {
+
+/**
+ * 一个总是发出买入信号的系统，主要用于 PF 中 MultiFactor 选股匹配
+ * @return SignalPtr
+ * @ingroup Signal
+ */
+SignalPtr HKU_API SG_AllwaysBuy();
+
+}  // namespace hku

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

@@ -0,0 +1,37 @@
+/*
+ * SG_Band.h
+ *
+ *   Created on: 2023年09月23日
+ *       Author: yangrq1018
+ */
+#pragma once
+#ifndef TRADE_SYS_SIGNAL_CRT_SG_BAND_H_
+#define TRADE_SYS_SIGNAL_CRT_SG_BAND_H_
+
+#include "../../../indicator/Indicator.h"
+#include "../SignalBase.h"
+
+namespace hku {
+
+/**
+ * 指标区间指示器, 当指标超过上轨时，买入；当指标低于下轨时，卖出。
+ * @note 适用于 RSI 类，有绝对值区间的指标
+ * @param ind 指标
+ * @param lower 下轨
+ * @param upper 上轨
+ * @return SignalPtr
+ */
+SignalPtr HKU_API SG_Band(const Indicator& ind, price_t lower, price_t upper);
+
+/**
+ * 指标区间指示器, 当指标超过上轨指标时，买入；当指标低于下轨指标时，卖出。
+ * @param ind 指标
+ * @param lower 下轨指标
+ * @param upper 上轨指标
+ * @return SignalPtr
+ */
+SignalPtr HKU_API SG_Band(const Indicator& ind, const Indicator& lower, const Indicator& upper);
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_SIGNAL_CRT_SG_BOOL_H_ */

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

@@ -0,0 +1,29 @@
+/*
+ * SG_Bool.h
+ *
+ *  Created on: 2017年7月2日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRADE_SYS_SIGNAL_CRT_SG_BOOL_H_
+#define TRADE_SYS_SIGNAL_CRT_SG_BOOL_H_
+
+#include "../../../indicator/Indicator.h"
+#include "../SignalBase.h"
+
+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, bool alternate = true);
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_SIGNAL_CRT_SG_BOOL_H_ */