hikyuu 2.0.9__cp310-none-win_amd64.whl → 2.1.1__cp310-none-win_amd64.whl

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorInvertDivValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorInvertDivValueSelector, "SE_DivValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorInvertSubValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorInvertSubValueSelector, "SE_SubValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorMulSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorMulSelector, "SE_Multi")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorMulValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorMulValueSelector, "SE_MultiValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,99 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+class HKU_API OperatorSelector : public SelectorBase {
+public:
+    OperatorSelector();
+    OperatorSelector(const string& name);
+    OperatorSelector(const string& name, const SelectorPtr& se1, const SelectorPtr& se2);
+    virtual ~OperatorSelector();
+
+    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();
+    }
+
+    virtual void _addSystem(const SYSPtr& sys) override;
+    virtual void _removeAll() override;
+
+protected:
+    virtual void bindRealToProto(const SYSPtr& real, const SYSPtr& proto) override {
+        m_real_to_proto[real] = proto;
+    }
+
+    SystemWeightList getUnionSelected(Datetime date,
+                                      const std::function<double(double, double)>&& func);
+
+    SystemWeightList getIntersectionSelected(Datetime date,
+                                             const std::function<double(double, double)>&& func);
+
+protected:
+    static void sortSystemWeightList(SystemWeightList& swlist);
+
+    void cloneRebuild(const SelectorPtr& se1, const SelectorPtr& se2);
+
+protected:
+    SelectorPtr m_se1;
+    SelectorPtr m_se2;
+    std::unordered_set<SYSPtr> m_se1_set;  // se1 的原型系统实例集合
+    std::unordered_set<SYSPtr> m_se2_set;  // se2 的原型系统实例集合
+    std::unordered_map<SYSPtr, SYSPtr> m_real_to_proto;
+
+private:
+    static std::unordered_set<System*> findIntersection(const SelectorPtr& se1,
+                                                        const SelectorPtr& se2);
+
+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_se1);
+        ar& BOOST_SERIALIZATION_NVP(m_se2);
+    }
+#endif
+};
+
+#define OPERATOR_SELECTOR_IMP(classname, name)                    \
+public:                                                           \
+    classname() : OperatorSelector(name) {}                       \
+    classname(const SelectorPtr& se1, const SelectorPtr& se2)     \
+    : OperatorSelector(name, se1, se2) {}                         \
+    virtual ~classname() {}                                       \
+                                                                  \
+    virtual SystemWeightList getSelected(Datetime date) override; \
+                                                                  \
+    virtual SelectorPtr _clone() override {                       \
+        HKU_THROW("OperatorSelector Could't support clone!");     \
+    }
+
+#if HKU_SUPPORT_SERIALIZATION
+#define OPERATOR_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(OperatorSelector); \
+    }
+#else
+#define OPERATOR_SELECTOR_SERIALIZATION
+#endif
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorSubSelector : public OperatorSelector {
+    OPERATOR_SELECTOR_IMP(OperatorSubSelector, "SE_Sub")
+    OPERATOR_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorValueSelector.h"
+
+namespace hku {
+
+class HKU_API OperatorSubValueSelector : public OperatorValueSelector {
+    OPERATOR_VALUE_SELECTOR_IMP(OperatorSubValueSelector, "SE_SubValue")
+    OPERATOR_VALUE_SELECTOR_SERIALIZATION
+};
+
+}  // namespace hku

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

@@ -0,0 +1,77 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-05-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../SelectorBase.h"
+
+namespace hku {
+
+class HKU_API OperatorValueSelector : public SelectorBase {
+public:
+    OperatorValueSelector();
+    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);
+    }
+#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/signal/SignalBase.h

@@ -191,11 +191,11 @@ private:                                                      \
 #define SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
 #endif
 
-#define SIGNAL_IMP(classname)              \
-public:                                    \
-    virtual SignalPtr _clone() override {  \
-        return SignalPtr(new classname()); \
-    }                                      \
+#define SIGNAL_IMP(classname)                 \
+public:                                       \
+    virtual SignalPtr _clone() override {     \
+        return std::make_shared<classname>(); \
+    }                                         \
     virtual void _calculate(const KData&) override;
 
 /**

hikyuu/include/hikyuu/trade_sys/slippage/SlippageBase.h

@@ -129,7 +129,7 @@ private:                                                       \
 #define SLIPPAGE_IMP(classname)                                          \
 public:                                                                  \
     virtual SlippagePtr _clone() override {                              \
-        return SlippagePtr(new classname());                             \
+        return std::make_shared<classname>();                            \
     }                                                                    \
     virtual price_t getRealBuyPrice(const Datetime&, price_t) override;  \
     virtual price_t getRealSellPrice(const Datetime&, price_t) override; \

hikyuu/include/hikyuu/trade_sys/stoploss/StoplossBase.h

@@ -146,12 +146,12 @@ private:                                                       \
 #define STOPLOSS_NO_PRIVATE_MEMBER_SERIALIZATION
 #endif
 
-#define STOPLOSS_IMP(classname, str_name)    \
-public:                                      \
-    virtual StoplossPtr _clone() override {  \
-        return StoplossPtr(new classname()); \
-    }                                        \
-    virtual void _calculate() override;      \
+#define STOPLOSS_IMP(classname, str_name)     \
+public:                                       \
+    virtual StoplossPtr _clone() override {   \
+        return std::make_shared<classname>(); \
+    }                                         \
+    virtual void _calculate() override;       \
     virtual price_t getPrice(const Datetime&, price_t) override;
 
 /**

hikyuu/include/hikyuu/trade_sys/system/System.h

@@ -25,12 +25,17 @@
 
 namespace hku {
 
+class HKU_API Portfolio;
+class HKU_API AllocateFundsBase;
+
 /**
  * 交易系统基类
  * @ingroup System
  */
 class HKU_API System {
     PARAMETER_SUPPORT_WITH_CHECK
+    friend class HKU_API Portfolio;
+    friend class HKU_API AllocateFundsBase;
 
 public:
     /** 默认构造函数 */
@@ -200,12 +205,6 @@ public:
      */
     TradeRecord runMoment(const Datetime& datetime);
 
-    // 清除已有的交易请求，供Portfolio使用
-    void clearDelayRequest();
-
-    // 当前是否存在延迟的操作请求，供Portfolio
-    bool haveDelayRequest() const;
-
     // 运行前准备工作, 失败将抛出异常
     void readyForRun();
 
@@ -213,6 +212,12 @@ public:
         return _sell(today, src_today, from);
     }
 
+    // 由各个相关组件调用，用于组件参数变化时通知 sys，以便重算
+    void partChangedNotify() {
+        m_calculated = false;
+    }
+
+private:
     // 强制以开盘价卖出，仅供 PF/AF 内部调用
     TradeRecord sellForceOnOpen(const Datetime& date, double num, Part from) {
         HKU_ASSERT(from == PART_ALLOCATEFUNDS || from == PART_PORTFOLIO);
@@ -225,10 +230,14 @@ public:
         return _sellForce(date, num, from, false);
     }
 
-    // 由各个相关组件调用，用于组件参数变化时通知 sys，以便重算
-    void partChangedNotify() {
-        m_calculated = false;
-    }
+    // 清除已有的交易请求，供Portfolio使用
+    void clearDelayBuyRequest();
+
+    // 当前是否存在延迟的操作请求，供Portfolio
+    bool haveDelaySellRequest() const;
+
+    // 处理延迟买入请求，仅供 PF 调用
+    TradeRecord pfProcessDelaySellRequest(const Datetime& date);
 
 private:
     bool _environmentIsValid(const Datetime& datetime);
@@ -338,8 +347,8 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_pg);
         ar& BOOST_SERIALIZATION_NVP(m_sp);
 
-        // m_kdata中包含了stock和query的信息，不用保存m_stock
         ar& BOOST_SERIALIZATION_NVP(m_kdata);
+        ar& BOOST_SERIALIZATION_NVP(m_stock);
 
         ar& BOOST_SERIALIZATION_NVP(m_calculated);
         ar& BOOST_SERIALIZATION_NVP(m_pre_ev_valid);
@@ -372,9 +381,8 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_pg);
         ar& BOOST_SERIALIZATION_NVP(m_sp);
 
-        // m_kdata中包含了stock和query的信息，不用保存m_stock
         ar& BOOST_SERIALIZATION_NVP(m_kdata);
-        m_stock = m_kdata.getStock();
+        ar& BOOST_SERIALIZATION_NVP(m_stock);
 
         ar& BOOST_SERIALIZATION_NVP(m_calculated);
         ar& BOOST_SERIALIZATION_NVP(m_pre_ev_valid);

hikyuu/include/hikyuu/utilities/FilterNode.h

@@ -0,0 +1,267 @@
+/*
+ *  Copyright (c) 2023 hikyuu.org
+ *
+ *  Created on: 2023-01-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <memory>
+#include <functional>
+#include <forward_list>
+#include <unordered_map>
+#include "thread/ThreadPool.h"
+#include "any_to_string.h"
+#include "Log.h"
+
+namespace hku {
+
+/**
+ * @brief 过滤节点
+ */
+class FilterNode {
+public:
+    FilterNode() = default;
+    FilterNode(const FilterNode&) = default;
+    virtual ~FilterNode() = default;
+
+    /**
+     * @brief 构造函数
+     * @param exclusive 是否排他。为 true 时，只执行第一个遇到的满足过滤条件的子节点
+     */
+    explicit FilterNode(bool exclusive) : m_exclusive(exclusive) {}
+
+    FilterNode(FilterNode&& rv)
+    : m_value(std::move(rv.m_value)),
+      m_children(std::move(rv.m_children)),
+      m_exclusive(rv.m_exclusive) {}
+
+    FilterNode& operator=(const FilterNode& rv) {
+        if (this == &rv)
+            return *this;
+        m_value = rv.m_value;
+        m_children = rv.m_children;
+        m_exclusive = rv.m_exclusive;
+        return *this;
+    }
+
+    FilterNode& operator=(FilterNode&& rv) {
+        if (this == &rv)
+            return *this;
+        m_value = std::move(rv.m_value);
+        m_children = std::move(rv.m_children);
+        m_exclusive = rv.m_exclusive;
+        return *this;
+    }
+
+    using ptr_t = std::shared_ptr<FilterNode>;
+
+    ptr_t addChild(const ptr_t& child) {
+        HKU_CHECK(child, "Invalid input child! child is null!");
+        m_children.push_front(child);
+        return child;
+    }
+
+    bool exclusive() const {
+        return m_exclusive;
+    }
+
+    void exclusive(bool exclusive) {
+        m_exclusive = exclusive;
+    }
+
+    using const_iterator = std::forward_list<ptr_t>::const_iterator;
+    using iterator = std::forward_list<ptr_t>::iterator;
+    const_iterator cbegin() const {
+        return m_children.cbegin();
+    }
+
+    const_iterator cend() const {
+        return m_children.cend();
+    }
+
+    iterator begin() {
+        return m_children.begin();
+    }
+
+    iterator end() {
+        return m_children.end();
+    }
+
+    bool run(const any_t& data) noexcept {
+        if (_filter(data)) {
+            _process(data);
+            for (auto& node : m_children) {
+                if (node->run(data) && m_exclusive) {
+                    return true;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    virtual bool filter(const any_t& data) {
+        return true;
+    }
+
+    virtual void process(const any_t& data) {}
+
+    template <typename ValueT>
+    ValueT value() const {
+        return any_cast<ValueT>(m_value);
+    }
+
+    template <typename ValueT>
+    void value(const ValueT& value) {
+        m_value = value;
+    }
+
+    bool has_value() const {
+#if !HKU_OS_IOS && CPP_STANDARD >= CPP_STANDARD_17
+        return m_value.has_value();
+#else
+        return !m_value.empty();
+#endif
+    }
+
+private:
+    bool _filter(const any_t& data) noexcept {
+        try {
+            return filter(data);
+        } catch (const std::exception& e) {
+            HKU_WARN("Node filter exist error! {}", e.what());
+        } catch (...) {
+            HKU_WARN("Node filter exist unknown error!");
+        }
+        return false;
+    }
+
+    void _process(const any_t& data) noexcept {
+        try {
+            process(data);
+        } catch (const std::exception& e) {
+            HKU_WARN("Node process exist error! {}", e.what());
+        } catch (...) {
+            HKU_WARN("Node process exist unknown error!");
+        }
+    }
+
+protected:
+    any_t m_value;
+
+private:
+    std::forward_list<ptr_t> m_children;
+    bool m_exclusive = false;
+};
+
+template <>
+inline const any_t& FilterNode::value() const {
+    return m_value;
+}
+
+typedef std::shared_ptr<FilterNode> FilterNodePtr;
+
+/**
+ * @brief 绑定过滤节点，通过 std::function 绑定自定义的 filter 和 process 处理函数
+ */
+class BindFilterNode : public FilterNode {
+public:
+    BindFilterNode() = default;
+    virtual ~BindFilterNode() = default;
+
+    using filter_func = std::function<bool(FilterNode*, const any_t&)>;
+    using process_func = std::function<void(FilterNode*, const any_t&)>;
+
+    explicit BindFilterNode(const process_func& process) : FilterNode(false), m_process(process) {}
+    explicit BindFilterNode(process_func&& process)
+    : FilterNode(false), m_process(std::move(process)) {}
+
+    BindFilterNode(const filter_func& filter, const process_func& process, bool exclusive = false)
+    : FilterNode(exclusive), m_filter(filter), m_process(process) {}
+
+    BindFilterNode(filter_func&& filter, process_func&& process, bool exclusive = false)
+    : FilterNode(exclusive), m_filter(std::move(filter)), m_process(std::move(process)) {}
+
+    virtual bool filter(const any_t& data) {
+        return m_filter ? m_filter(this, data) : true;
+    }
+
+    virtual void process(const any_t& data) {
+        if (m_process) {
+            m_process(this, data);
+        }
+    }
+
+private:
+    filter_func m_filter;
+    process_func m_process;
+};
+
+/**
+ * @brief 异步串行事件处理器
+ * @tparam EventT
+ */
+template <class EventT>
+class AsyncSerialEventProcessor {
+public:
+    /**
+     * @brief 构造函数
+     * @param quit_wait 退出时等待所有任务完成
+     */
+    explicit AsyncSerialEventProcessor(bool quit_wait = true) : m_quit_wait(quit_wait) {
+        m_tg = std::unique_ptr<ThreadPool>(new ThreadPool(1));
+    }
+
+    /** 析构函数 */
+    virtual ~AsyncSerialEventProcessor() {
+        if (m_quit_wait) {
+            m_tg->join();
+        } else {
+            m_tg->stop();
+        }
+    }
+
+    /**
+     * @brief 添加事件处理节点
+     *
+     * @param event 事件
+     * @param action 对应的处理节点
+     * @return 返回加入的节点
+     */
+    FilterNodePtr addAction(const EventT& event, const FilterNodePtr& action) {
+        HKU_CHECK(action, "Input action is null!");
+        std::lock_guard<std::mutex> lock(m_mutex);
+        auto iter = m_trees.find(event);
+        if (iter != m_trees.end()) {
+            iter->second->addChild(action);
+        } else {
+            m_trees[event] = action;
+        }
+        return action;
+    }
+
+    /**
+     * @brief 分派事件消息
+     *
+     * @param event 事件
+     * @param data 事件附加信息
+     */
+    void dispatch(const EventT& event, const any_t& data) {
+        m_tg->submit([=] {
+            auto iter = m_trees.find(event);
+            HKU_WARN_IF_RETURN(iter == m_trees.end(), void(),
+                              "There is no matching handling method for the event({})!", event);
+            iter->second->run(data);
+        });
+    }
+
+private:
+    mutable std::mutex m_mutex;
+    std::unordered_map<EventT, FilterNodePtr> m_trees;
+    std::unique_ptr<ThreadPool> m_tg;
+    bool m_quit_wait = true;
+};
+
+}  // namespace hku