hikyuu 2.6.2__py3-none-win_amd64.whl → 2.6.5__py3-none-win_amd64.whl

hikyuu/include/hikyuu/trade_sys/multifactor/imp/ICMultiFactor.h

@@ -18,7 +18,8 @@ class ICMultiFactor : public MultiFactorBase {
 public:
     ICMultiFactor();
     ICMultiFactor(const IndicatorList& inds, const StockList& stks, const KQuery& query,
-                  const Stock& ref_stk, int ic_n, int ic_rolling_n, bool spearman);
+                  const Stock& ref_stk, int ic_n, int ic_rolling_n, bool spearman, int mode,
+                  bool save_all_factors);
     virtual ~ICMultiFactor() = default;
 
     virtual void _checkParam(const string& name) const override;

hikyuu/include/hikyuu/trade_sys/multifactor/imp/WeightMultiFactor.h

@@ -21,7 +21,7 @@ public:
     WeightMultiFactor();
     WeightMultiFactor(const vector<Indicator>& inds, const PriceList& weights,
                       const StockList& stks, const KQuery& query, const Stock& ref_stk, int ic_n,
-                      bool spearman);
+                      bool spearman, int mode, bool save_all_factors);
     virtual ~WeightMultiFactor() = default;
 
 private:

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_Optimal.h

@@ -23,4 +23,12 @@ SEPtr HKU_API SE_MaxFundsOptimal();
  */
 SEPtr HKU_API SE_PerformanceOptimal(const string& key = "帐户平均年收益率%", int mode = 0);
 
+/**
+ * 使用自定义评估函数进行寻优的选择器
+ * @param evaluate
+ * @return SEPtr
+ */
+SEPtr HKU_API
+SE_EvaluateOptimal(std::function<double(const SystemPtr&, const Datetime&)>&& evaluate);
+
 }  // namespace hku

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

@@ -43,6 +43,7 @@ public:
     // 以便继承子类只需要实现 _clone 和 该接口即可
     // 该接口实现系统绩效评估，getSelected 时将取评估结果最大的系统
     // 使用 std::function 的话，在 C++ 中无法序列化，所以使用继承
+    // 返回 Null<double> 时，将不被评估选中
     virtual double evaluate(const SYSPtr& sys, const Datetime& endDate) noexcept {
         return Null<double>();
     }

hikyuu/include/hikyuu/trade_sys/system/TradeRequest.h

@@ -28,11 +28,12 @@ public:
     Datetime datetime;
     price_t stoploss{0.0};
     price_t goal{0.0};
-    double number{0.0};  // 计划的买入/卖出数量，使用发出请求时刻的收盘价，
-                         // 用于避免实际买入时需用重新计算数量时，人工执行速度较慢
-                         // 可通过系统参数进行设置，是否使用
+    double number{0.0};             // 计划的买入/卖出数量，使用发出请求时刻的收盘价，
+                                    // 用于避免实际买入时需用重新计算数量时，人工执行速度较慢
+                                    // 可通过系统参数进行设置，是否使用
     SystemPart from{PART_INVALID};  // 记录SystemBase::Part
-    int count{0};                   // 因操作失败，连续延迟的次数
+    string remark;
+    int count{0};  // 因操作失败，连续延迟的次数
     KRecord krecord;
 
 //============================================
@@ -54,6 +55,7 @@ private:
         ar& BOOST_SERIALIZATION_NVP(number);
         string from_name(getSystemPartName(from));
         ar& bs::make_nvp<string>("from", from_name);
+        ar& BOOST_SERIALIZATION_NVP(remark);
         ar& BOOST_SERIALIZATION_NVP(count);
         ar& BOOST_SERIALIZATION_NVP(krecord);
     }
@@ -74,6 +76,7 @@ private:
         string from_name;
         ar& bs::make_nvp<string>("from", from_name);
         from = getSystemPartEnum(from_name);
+        ar& BOOST_SERIALIZATION_NVP(remark);
         ar& BOOST_SERIALIZATION_NVP(count);
         ar& BOOST_SERIALIZATION_NVP(krecord);
     }

hikyuu/include/hikyuu/trade_sys/system/imp/WalkForwardTradeManager.h

@@ -262,9 +262,10 @@ public:
      */
     virtual TradeRecord buy(const Datetime& datetime, const Stock& stock, price_t realPrice,
                             double number, price_t stoploss = 0.0, price_t goalPrice = 0.0,
-                            price_t planPrice = 0.0, SystemPart from = PART_INVALID) override {
+                            price_t planPrice = 0.0, SystemPart from = PART_INVALID,
+                            const string& remark = "") override {
         return (datetime >= m_run_start) ? m_tm->buy(datetime, stock, realPrice, number, stoploss,
-                                                     goalPrice, planPrice, from)
+                                                     goalPrice, planPrice, from, remark)
                                          : TradeRecord();
     }
 
@@ -283,9 +284,9 @@ public:
     virtual TradeRecord sell(const Datetime& datetime, const Stock& stock, price_t realPrice,
                              double number = MAX_DOUBLE, price_t stoploss = 0.0,
                              price_t goalPrice = 0.0, price_t planPrice = 0.0,
-                             SystemPart from = PART_INVALID) override {
+                             SystemPart from = PART_INVALID, const string& remark = "") override {
         return (datetime >= m_run_start) ? m_tm->sell(datetime, stock, realPrice, number, stoploss,
-                                                      goalPrice, planPrice, from)
+                                                      goalPrice, planPrice, from, remark)
                                          : TradeRecord();
     }
 
@@ -303,11 +304,12 @@ public:
      */
     virtual TradeRecord sellShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
                                   double number, price_t stoploss = 0.0, price_t goalPrice = 0.0,
-                                  price_t planPrice = 0.0,
-                                  SystemPart from = PART_INVALID) override {
-        return (datetime >= m_run_start) ? m_tm->sellShort(datetime, stock, realPrice, number,
-                                                           stoploss, goalPrice, planPrice, from)
-                                         : TradeRecord();
+                                  price_t planPrice = 0.0, SystemPart from = PART_INVALID,
+                                  const string& remark = "") override {
+        return (datetime >= m_run_start)
+                 ? m_tm->sellShort(datetime, stock, realPrice, number, stoploss, goalPrice,
+                                   planPrice, from, remark)
+                 : TradeRecord();
     }
 
     /**
@@ -325,10 +327,12 @@ public:
     virtual TradeRecord buyShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
                                  double number = MAX_DOUBLE, price_t stoploss = 0.0,
                                  price_t goalPrice = 0.0, price_t planPrice = 0.0,
-                                 SystemPart from = PART_INVALID) override {
-        return (datetime >= m_run_start) ? m_tm->buyShort(datetime, stock, realPrice, number,
-                                                          stoploss, goalPrice, planPrice, from)
-                                         : TradeRecord();
+                                 SystemPart from = PART_INVALID,
+                                 const string& remark = "") override {
+        return (datetime >= m_run_start)
+                 ? m_tm->buyShort(datetime, stock, realPrice, number, stoploss, goalPrice,
+                                  planPrice, from, remark)
+                 : TradeRecord();
     }
 
     /**

hikyuu/include/hikyuu/utilities/DllLoader.h

@@ -0,0 +1,226 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_DLL_LOADER_H_
+#define HKU_UTILS_DLL_LOADER_H_
+
+#include <string>
+#include <vector>
+#include <cstdlib>
+#include "hikyuu/utilities/config.h"
+#include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/os.h"
+#include "hikyuu/utilities/Log.h"
+#include "hikyuu/utilities/arithmetic.h"
+
+#if HKU_OS_WINDOWS
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+namespace hku {
+
+class DllLoader {
+public:
+    DllLoader() {
+        initDefaultSearchPath();
+    }
+
+    explicit DllLoader(const std::vector<std::string>& path) {
+        if (!path.empty()) {
+            m_search_paths.resize(path.size());
+            std::copy(path.begin(), path.end(), m_search_paths.begin());
+        } else {
+            HKU_WARN("DllLoader: empty search path! Use default search path!");
+            initDefaultSearchPath();
+        }
+    }
+
+    DllLoader(const DllLoader&) = delete;
+    DllLoader& operator=(const DllLoader&) = delete;
+
+    DllLoader(DllLoader&& rhs)
+    : m_handle(rhs.m_handle), m_search_paths(std::move(rhs.m_search_paths)) {
+        rhs.m_handle = nullptr;
+    }
+
+    DllLoader& operator=(DllLoader&& rhs) {
+        if (this == &rhs) {
+            m_handle = rhs.m_handle;
+            m_search_paths = std::move(rhs.m_search_paths);
+            rhs.m_handle = nullptr;
+        }
+        return *this;
+    }
+
+    virtual ~DllLoader() {
+        unload();
+    }
+
+    bool load(const std::string& dllname) noexcept {
+        std::string filename = search(dllname);
+        HKU_WARN_IF_RETURN(filename.empty(), false, "Not found dll: {}!", dllname);
+
+#if HKU_OS_WINDOWS
+        m_handle = LoadLibrary(HKU_PATH(filename).c_str());
+#else
+        m_handle = dlopen(filename.c_str(), RTLD_LAZY);
+#endif
+        HKU_WARN_IF_RETURN(!m_handle, false, "load dll({}) failed!", filename);
+        return true;
+    }
+
+    void unload() noexcept {
+        if (m_handle) {
+#if HKU_OS_WINDOWS
+            FreeLibrary(m_handle);
+#else
+            dlclose(m_handle);
+#endif
+        }
+    }
+
+    std::string search(const std::string& dllname) const noexcept {
+#if HKU_OS_WINDOWS
+        std::string dll = fmt::format("{}.dll", dllname);
+#elif HKU_OS_OSX
+        std::string dll = fmt::format("lib{}.dylib", dllname);
+#else
+        std::string dll = fmt::format("lib{}.so", dllname);
+#endif
+        for (const auto& path : m_search_paths) {
+            auto filename = fmt::format("{}/{}", path, dll);
+            if (existFile(filename)) {
+                return filename;
+            }
+        }
+
+        return std::string();
+    }
+
+    void* getSymbol(const char* symbol) noexcept {
+#if HKU_OS_WINDOWS
+        void* func = GetProcAddress(m_handle, symbol);
+#else
+        void* func = dlsym(m_handle, symbol);
+#endif
+        return func;
+    }
+
+private:
+    void initDefaultSearchPath() noexcept {
+        m_search_paths.emplace_back(".");
+
+        std::string userdir = getUserDir();
+        if (!userdir.empty()) {
+            m_search_paths.emplace_back(userdir + "/lib");
+        }
+
+#if HKU_OS_WINDOWS
+        m_search_paths.emplace_back("C:/Windows/System32");
+        m_search_paths.emplace_back("C:/Windows/SysWOW64");
+        m_search_paths.emplace_back("C:/Windows");
+        const char* path = getenv("PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+
+#elif HKU_OS_OSX
+        const char* path = getenv("DYLD_IMAGE_SUFFIX");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        path = getenv("DYLD_FRAMEWORK_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        path = getenv("DYLD_LIBRARY_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        m_search_paths.emplace_back("/Library/Frameworks");
+        m_search_paths.emplace_back("/Network/Library/Frameworks");
+        m_search_paths.emplace_back("/System/Library/Frameworks");
+        m_search_paths.emplace_back("/usr/local/lib");
+        m_search_paths.emplace_back("/usr/lib");
+        m_search_paths.emplace_back("/lib");
+
+#else
+        const char* path = getenv("LD_LIBRARY_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        m_search_paths.emplace_back("/usr/local/lib");
+        m_search_paths.emplace_back("/usr/lib");
+        m_search_paths.emplace_back("/lib");
+        if (HKU_ARCH_X64) {
+            m_search_paths.emplace_back("/usr/lib/x86_64-linux-gnu");
+        } else if (HKU_ARCH_ARM64) {
+            m_search_paths.emplace_back("/usr/lib/aarch64-linux-gnu");
+        } else if (HKU_ARCH_X86) {
+            m_search_paths.emplace_back("/usr/lib/i386-linux-gnu");
+        } else if (HKU_ARCH_ARM) {
+            m_search_paths.emplace_back("/usr/lib/arm-linux-gnueabihf");
+        }
+#endif
+    }
+
+private:
+#if HKU_OS_WINDOWS
+    HMODULE m_handle{nullptr};
+#else
+    void* m_handle{nullptr};
+#endif
+
+    std::vector<std::string> m_search_paths;
+};
+
+}  // namespace hku
+
+#endif /* HKU_UTILS_DLL_LOADER_H_ */

hikyuu/include/hikyuu/utilities/datetime/Datetime.h

@@ -62,6 +62,20 @@ public:
      */
     static Datetime fromHex(uint64_t time);
 
+    /**
+     * @brief 从时间戳（微秒）创建Datetime对象
+     * @param timestamp 微妙级别的时间戳(从1970年1月1日0时0分0秒开始)
+     * @return Datetime
+     */
+    static Datetime fromTimestamp(int64_t timestamp);
+
+    /**
+     * @brief 从时间戳（微秒）创建Datetime对象，并加上本地UTC时间偏差
+     * @param timestamp 微妙级别的时间戳(从1970年1月1日0时0分0秒开始)
+     * @return Datetime
+     */
+    static Datetime fromTimestampUTC(int64_t timestamp);
+
 public:
     /** 默认构造函数，Null<Datetime> */
     Datetime();
@@ -178,6 +192,12 @@ public:
     /** 距离最小日期过去的微秒数 */
     uint64_t ticks() const noexcept;
 
+    /** 时间戳，距离1970-01-01 00:00:00的微秒数 */
+    int64_t timestamp() const noexcept;
+
+    /** 时间戳，距离1970-01-01 00:00:00的微秒数, 并扣除本地 UTC 偏差时间 */
+    int64_t timestampUTC() const noexcept;
+
     /**
      * 转化为字符串，供打印阅读，格式：
      * <pre>

hikyuu/include/hikyuu/utilities/datetime/TimeDelta.h

@@ -316,6 +316,12 @@ inline TimeDelta Microseconds(int64_t microsecs) {
     return TimeDelta::fromTicks(microsecs);
 }
 
+/**
+ * 获取当前 UTC 时间偏移
+ * @return TimeDelta
+ */
+TimeDelta HKU_UTILS_API UTCOffset();
+
 } /* namespace hku */
 
 namespace std {

hikyuu/include/hikyuu/utilities/plugin/PluginLoader.h

@@ -71,6 +71,16 @@ public:
         return true;
     }
 
+    std::string getFileName(const std::string& pluginname) const noexcept {
+#if HKU_OS_WINDOWS
+        return fmt::format("{}/{}.dll", m_path, pluginname);
+#elif HKU_OS_LINUX
+        return fmt::format("{}/lib{}.so", m_path, pluginname);
+#elif HKU_OS_OSX
+        return fmt::format("{}/lib{}.dylib", m_path, pluginname);
+#endif
+    }
+
 private:
     void unload() noexcept {
         m_plugin.reset();
@@ -92,16 +102,6 @@ private:
         return func;
     }
 
-    std::string getFileName(const std::string& pluginname) const noexcept {
-#if HKU_OS_WINDOWS
-        return fmt::format("{}/{}.dll", m_path, pluginname);
-#elif HKU_OS_LINUX
-        return fmt::format("{}/lib{}.so", m_path, pluginname);
-#elif HKU_OS_OSX
-        return fmt::format("{}/lib{}.dylib", m_path, pluginname);
-#endif
-    }
-
 private:
 #if HKU_OS_WINDOWS
     HMODULE m_handle{nullptr};

hikyuu/include/hikyuu/utilities/thread/{MQStealThreadPool.h → GlobalMQStealThreadPool.h}

@@ -1,5 +1,5 @@
 /*
- * StealMQStealThreadPool.h
+ * StealGlobalMQStealThreadPool.h
  *
  *  Copyright (c) 2019 hikyuu.org
  *
@@ -30,25 +30,25 @@ namespace hku {
 
 /**
  * @brief 无集中队列多队列偷取任务池
- * @ingroup MQStealThreadPool
+ * @ingroup GlobalMQStealThreadPool
  */
 #ifdef _MSC_VER
-class MQStealThreadPool {
+class GlobalMQStealThreadPool {
 #else
-class HKU_UTILS_API MQStealThreadPool {
+class HKU_UTILS_API GlobalMQStealThreadPool {
 #endif
 public:
     /**
      * 默认构造函数，创建和当前系统CPU数一致的线程数
      */
-    MQStealThreadPool() : MQStealThreadPool(std::thread::hardware_concurrency()) {}
+    GlobalMQStealThreadPool() : GlobalMQStealThreadPool(std::thread::hardware_concurrency()) {}
 
     /**
      * 构造函数，创建指定数量的线程
      * @param n 指定的线程数
      * @param until_empty 任务队列为空时，自动停止运行
      */
-    explicit MQStealThreadPool(size_t n, bool until_empty = true)
+    explicit GlobalMQStealThreadPool(size_t n, bool until_empty = true)
     : m_done(false), m_worker_num(n), m_runnging_until_empty(until_empty) {
         try {
             m_interrupt_flags.resize(m_worker_num, nullptr);
@@ -58,7 +58,7 @@ public:
             }
             // 初始完毕所有线程资源后再启动线程
             for (int i = 0; i < m_worker_num; i++) {
-                m_threads.emplace_back(&MQStealThreadPool::worker_thread, this, i);
+                m_threads.emplace_back(&GlobalMQStealThreadPool::worker_thread, this, i);
             }
         } catch (...) {
             m_done = true;
@@ -69,7 +69,7 @@ public:
     /**
      * 析构函数，等待并阻塞至线程池内所有任务完成
      */
-    ~MQStealThreadPool() {
+    ~GlobalMQStealThreadPool() {
         if (!m_done) {
             join();
         }
@@ -106,7 +106,8 @@ public:
     template <typename FunctionType>
     auto submit(FunctionType f) {
         if (m_thread_need_stop.isSet() || m_done) {
-            throw std::logic_error("You can't submit a task to the stopped MQStealThreadPool!");
+            throw std::logic_error(
+              "You can't submit a task to the stopped GlobalMQStealThreadPool!");
         }
 
         typedef typename std::invoke_result<FunctionType>::type result_type;
@@ -256,13 +257,12 @@ private:
     void worker_thread(int index) {
         m_index = index;
         m_interrupt_flags[index] = &m_thread_need_stop;
-        m_local_work_queue = m_queues[m_index].get();
+        m_local_work_queue = m_queues[index].get();
         while (!m_thread_need_stop.isSet() && !m_done) {
             run_pending_task();
         }
-        m_interrupt_flags[m_index] = nullptr;
+        m_interrupt_flags[index] = nullptr;
         m_local_work_queue = nullptr;
-        // printf("%zu thread (%lld) finished!\n", m_index, std::this_thread::get_id());
     }
 
     void run_pending_task() {