hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

hikyuu/include/hikyuu/StockWeight.h

@@ -0,0 +1,148 @@
+/*
+ * StockWeight.h
+ *
+ *  Created on: 2011-12-9
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef STOCKWEIGHT_H_
+#define STOCKWEIGHT_H_
+
+#include "DataType.h"
+
+namespace hku {
+
+/**
+ * 权息数据结构
+ * @ingroup StockManage
+ */
+class HKU_API StockWeight {
+public:
+    /** 默认构造函数，返回Null<StockWeight>() */
+    StockWeight() = default;
+
+    explicit StockWeight(const Datetime& datetime);
+
+    StockWeight(const Datetime& datetime, price_t countAsGift, price_t countForSell,
+                price_t priceForSell, price_t bonus, price_t increasement, price_t totalCount,
+                price_t freeCount, price_t suogu);
+
+    /** 权息日期 */
+    Datetime datetime() const {
+        return m_datetime;
+    }
+
+    /** 每10股送X股 */
+    price_t countAsGift() const {
+        return m_countAsGift;
+    }
+
+    /** 每10股配X股 */
+    price_t countForSell() const {
+        return m_countForSell;
+    }
+
+    /** 配股价 */
+    price_t priceForSell() const {
+        return m_priceForSell;
+    }
+
+    /** 每10股红利 */
+    price_t bonus() const {
+        return m_bonus;
+    }
+
+    /** 每10股转增X股 */
+    price_t increasement() const {
+        return m_increasement;
+    }
+
+    /** 总股本（万股） */
+    price_t totalCount() const {
+        return m_totalCount;
+    }
+
+    /** 流通股（万股） */
+    price_t freeCount() const {
+        return m_freeCount;
+    }
+
+    /** 扩缩股比例 */
+    price_t suogu() const {
+        return m_suogu;
+    }
+
+private:
+    Datetime m_datetime;         // 权息日期
+    price_t m_countAsGift{0.};   // 每10股送X股
+    price_t m_countForSell{0.};  // 每10股配X股
+    price_t m_priceForSell{0.};  // 配股价
+    price_t m_bonus{0.};         // 每10股红利
+    price_t m_increasement{0.};  // 每10股转增X股
+    price_t m_totalCount{0.};    // 总股本（万股）
+    price_t m_freeCount{0.};     // 流通股（万股）
+    price_t m_suogu{0.};         // 扩缩股比例
+};
+
+/** @ingroup StockManage */
+typedef vector<StockWeight> StockWeightList;
+
+/**
+ * 输出权息信息，如：Weight(datetime, countAsGift, countForSell,
+ * priceForSell, bonus, increasement, totalCount, freeCount)
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream&, const StockWeight&);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// 关系比较函数
+//
+///////////////////////////////////////////////////////////////////////////////
+bool operator==(const StockWeight&, const StockWeight&);
+bool operator!=(const StockWeight&, const StockWeight&);
+bool operator>(const StockWeight&, const StockWeight&);
+bool operator<(const StockWeight&, const StockWeight&);
+bool operator>=(const StockWeight&, const StockWeight&);
+bool operator<=(const StockWeight&, const StockWeight&);
+
+/* 相等比较, 仅根据日期判断 */
+inline bool operator==(const StockWeight& m1, const StockWeight& m2) {
+    return m1.datetime() == m2.datetime();
+}
+
+/* 不等比较， 仅根据日期判断 */
+inline bool operator!=(const StockWeight& m1, const StockWeight& m2) {
+    return m1.datetime() != m2.datetime();
+}
+
+/* 大于比较, 仅根据日期判断 */
+inline bool operator>(const StockWeight& m1, const StockWeight& m2) {
+    return m1.datetime() > m2.datetime();
+}
+
+/* 小于比较， 仅根据日期判断 */
+inline bool operator<(const StockWeight& m1, const StockWeight& m2) {
+    return m1.datetime() < m2.datetime();
+}
+
+/* 大于等于比较, 仅根据日期判断 */
+inline bool operator>=(const StockWeight& m1, const StockWeight& m2) {
+    return m1.datetime() >= m2.datetime();
+}
+
+/* 小于等于比较， 仅根据日期判断 */
+inline bool operator<=(const StockWeight& m1, const StockWeight& m2) {
+    return m1.datetime() <= m2.datetime();
+}
+
+/** @} */
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::StockWeight> : ostream_formatter {};
+#endif
+
+#endif /* STOCKWEIGHT_H_ */

hikyuu/include/hikyuu/StrategyContext.h

@@ -0,0 +1,116 @@
+/*
+ *  Copyright(C) 2021 hikyuu.org
+ *
+ *  Create on: 2021-02-10
+ *     Author: fasiondog
+ */
+
+#pragma once
+
+#include "DataType.h"
+#include "KQuery.h"
+
+namespace hku {
+
+/**
+ * 策略上下文，定义策略执行时包含的证券/K线级别信息
+ * @ingroup Strategy
+ *
+ */
+class HKU_API StrategyContext {
+public:
+    StrategyContext() = default;
+    virtual ~StrategyContext() = default;
+
+    /**
+     * 构造函数
+     * @param stockCodeList 指定的证券代码列表，如：如：{"sz000001", "sz000002"}
+     */
+    explicit StrategyContext(const vector<string>& stockCodeList);
+
+    /**
+     * 构造函数
+     * @note 证券列表中如果包含 ("ALL") 则表示全部证券;
+     *       1. 指定K线类型列表同时影响着K线数据的优先加载顺序，靠前的将优先加载。
+     *       2. 未指定 ktypelist 或 preloadNum 时，将使用全局配置文件参数
+     * @param stockCodeList 指定的证券代码列表，如：{"sh000001", "sz000001"}
+     * @param ktypeList 指定的 K线数据列表，如：{"day", "min"}
+     * @param preloadNum 指定的预加载数量，如：{{"min_max", 100}, {"day_max", 200}}
+     */
+    StrategyContext(const vector<string>& stockCodeList, const vector<KQuery::KType>& ktypeList,
+                    const unordered_map<string, int>& preloadNum = {});
+
+    // 自定义移动构造与赋值会引起 python 中无法正常退出
+    // StrategyContext(const StrategyContext&) = default;
+    // StrategyContext(StrategyContext&& rv) = delete;
+    // StrategyContext& operator=(const StrategyContext&) = default;
+    // StrategyContext& operator=(StrategyContext&&) = delete;
+
+    /**
+     * 是否为加载全部证券，只要 stockCodeList 包含 "ALL"(不区分大小写) ，即认为加载全部
+     * @return true
+     * @return false
+     */
+    bool isAll() const noexcept;
+
+    bool empty() const noexcept {
+        return m_stockCodeList.empty();
+    }
+
+    Datetime startDatetime() const noexcept {
+        return m_startDatetime;
+    }
+
+    void setStockCodeList(const vector<string>& stockList) {
+        _removeDuplicateCode(stockList);
+    }
+
+    const vector<string>& getStockCodeList() const noexcept {
+        return m_stockCodeList;
+    }
+
+    void setKTypeList(const vector<KQuery::KType>& ktypeList) {
+        _checkAndRemoveDuplicateKType(ktypeList);
+    }
+
+    const vector<KQuery::KType>& getKTypeList() const noexcept {
+        return m_ktypeList;
+    }
+
+    void setPreloadNum(const unordered_map<string, int>& preloadNum);
+
+    const unordered_map<string, int>& getPreloadNum() const noexcept {
+        return m_preloadNum;
+    }
+
+    /**
+     * 隐含的默认必须被加载的证券列表
+     * @note 影响交易日历判断、和某些常被作为默认比较基准的证券，通常被作为某些函数的默认值
+     */
+    const vector<string>& getMustLoadStockCodeList() const noexcept {
+        return m_mustLoad;
+    }
+
+    /**
+     * 返回所有需要加载的证券列表（含指定的证券列表和默认包含必须加载的证券列表）
+     * @return vector<string>
+     */
+    vector<string> getAllNeedLoadStockCodeList() const noexcept;
+
+    string str() const;
+
+private:
+    void _removeDuplicateCode(const vector<string>& stockCodeList);
+    void _checkAndRemoveDuplicateKType(const vector<KQuery::KType>& ktypeList);
+
+private:
+    Datetime m_startDatetime{19901219};
+    vector<string> m_mustLoad{"sh000001", "sh000300"};  // 默认必须加载的 stock
+    vector<string> m_stockCodeList;
+    vector<KQuery::KType> m_ktypeList;
+    unordered_map<string, int> m_preloadNum;
+};
+
+HKU_API std::ostream& operator<<(std::ostream& os, const StrategyContext& context);
+
+}  // namespace hku

hikyuu/include/hikyuu/TimeLineRecord.h

@@ -0,0 +1,71 @@
+/*
+ * TimeLineRecord.h
+ *
+ *  Created on: 2019-1-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TIMELINERECORD_H_
+#define TIMELINERECORD_H_
+
+#include "DataType.h"
+
+namespace hku {
+
+/**
+ * 分时线记录
+ * @ingroup StockManage
+ */
+class HKU_API TimeLineRecord {
+public:
+    Datetime datetime;
+    price_t price;
+    price_t vol;
+
+    TimeLineRecord();
+    TimeLineRecord(const Datetime& datetime, price_t price, price_t vol);
+
+    bool isValid() const;
+};
+
+/**
+ * 分时线
+ * @ingroup StockManage
+ */
+typedef vector<TimeLineRecord> TimeLineList;
+
+/**
+ * 输出TimeLineRecord信息，如：TimeSharingRecord(datetime, price, vol)
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream&, const TimeLineRecord&);
+
+/**
+ * 输出TimeLine信息
+ * @details
+ * <pre>
+ * TimeLine{
+ *   size : 738501
+ *   start: YYYY-MM-DD hh:mm:ss
+ *   last : YYYY-MM-DD hh:mm:ss
+ *  }
+ * </pre>
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream& os, const TimeLineList&);
+
+/**
+ * 比较两个TimeLineRecord是否相等，一般仅测试时使用
+ * @ingroup StockManage
+ */
+bool HKU_API operator==(const TimeLineRecord& d1, const TimeLineRecord& d2);
+
+} /* namespace hku */
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::TimeLineRecord> : ostream_formatter {};
+#endif
+
+#endif /* TIMELINERECORD_H_ */

hikyuu/include/hikyuu/TransRecord.h

@@ -0,0 +1,73 @@
+/*
+ * TransRecord.h
+ *
+ *  Created on: 2019年2月10日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef TRANSRECORD_H_
+#define TRANSRECORD_H_
+
+#include "DataType.h"
+
+namespace hku {
+
+/**
+ * 分笔成交记录
+ * @ingroup StockManage
+ */
+class HKU_API TransRecord {
+public:
+    Datetime datetime;  // 时间
+    price_t price;      // 成交均价
+    price_t vol;        // 成交量
+    int32_t direct;     // 买卖盘性质：1--sell 0--buy 2--集合竞价 其他未知
+
+    TransRecord();
+    TransRecord(const Datetime& datetime, price_t price, price_t vol, int32_t direct);
+
+    bool isValid() const;
+};
+
+/**
+ * 分时线
+ * @ingroup StockManage
+ */
+typedef vector<TransRecord> TransList;
+typedef vector<TransRecord> TransRecordList;
+
+/**
+ * 输出 TransRecord 信息，如：TimeSharingRecord(datetime, price, vol)
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream&, const TransRecord&);
+
+/**
+ * 输出 TransList 信息
+ * @details
+ * <pre>
+ * TimeLine{
+ *   size : 738501
+ *   start: YYYY-MM-DD hh:mm:ss
+ *   last : YYYY-MM-DD hh:mm:ss
+ *  }
+ * </pre>
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream& os, const TransList&);
+
+/**
+ * 比较两个 TransRecord 是否相等，一般仅测试时使用
+ * @ingroup StockManage
+ */
+bool HKU_API operator==(const TransRecord& d1, const TransRecord& d2);
+
+} /* namespace hku */
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::TransRecord> : ostream_formatter {};
+#endif
+
+#endif /* TRANSRECORD_H_ */

hikyuu/include/hikyuu/ZhBond10.h

@@ -0,0 +1,36 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-03-01
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "DataType.h"
+
+namespace hku {
+
+/**
+ * 10年期中国国债数据结构
+ * @ingroup StockManage
+ */
+struct HKU_API ZhBond10 {
+    Datetime date;  ///< 日期
+    price_t value;  ///< 收益率
+};
+
+typedef vector<ZhBond10> ZhBond10List;
+
+/**
+ * 输出 ZhBond10 ZhBond10(date, value)
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream&, const ZhBond10&);
+
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::ZhBond10> : ostream_formatter {};
+#endif

hikyuu/include/hikyuu/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/analysis/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/analysis/analysis_sys.h

@@ -0,0 +1,76 @@
+/*
+ *  Copyright (c) 2023 hikyuu.org
+ *
+ *  Created on: 2023-12-25
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/system/System.h"
+#include "hikyuu/trade_manage/Performance.h"
+#include "hikyuu/utilities/thread/thread.h"
+
+namespace hku {
+
+struct HKU_API AnalysisSystemOutput {
+    string market_code;  ///< 证券代码
+    string name;         ///< 证券名称
+    PriceList values;    ///< 统计各项指标值
+
+    AnalysisSystemOutput() = default;
+    AnalysisSystemOutput(const AnalysisSystemOutput& other) = default;
+    AnalysisSystemOutput(AnalysisSystemOutput&& rv)
+    : market_code(std::move(rv.market_code)),
+      name(std::move(rv.name)),
+      values(std::move(rv.values)) {}
+
+    AnalysisSystemOutput& operator=(const AnalysisSystemOutput&) = default;
+    AnalysisSystemOutput& operator=(AnalysisSystemOutput&& rv) {
+        HKU_IF_RETURN(this == &rv, *this);
+        market_code = std::move(rv.market_code);
+        name = std::move(rv.name);
+        values = std::move(rv.values);
+        return *this;
+    }
+};
+
+/**
+ * 统计所有指定系统策略, 系统列表中的每一个系统都应该是独立的系统实例
+ * @note 系统实例列表和证券列表是一一对应，不是两两组合
+ * @param sys_list 系统策略实例列表
+ * @param stk_list 证券列表，须与系统策略列表一一对应
+ * @param query 查询条件
+ * @return vector<AnalysisSystemOutput>
+ */
+vector<AnalysisSystemOutput> HKU_API analysisSystemList(const SystemList& sys_list,
+                                                        const StockList& stk_list,
+                                                        const KQuery& query);
+
+/**
+ * 以指定的 stock 统计执行所有的系统策略
+ * @param sys_list 系统策略思路列表，每一个都应是单独的实例
+ * @param stk 指定证券
+ * @param query 查询条件
+ * @return vector<AnalysisSystemOutput>
+ */
+vector<AnalysisSystemOutput> HKU_API analysisSystemList(const SystemList& sys_list,
+                                                        const Stock& stk, const KQuery& query);
+
+/**
+ * 以指定的 stock 统计执行所有的系统策略，并按指定的统计项返回统计项最高或最低的系统实例及其统计值
+ * @param sys_list 系统策略思路列表，每一个都应是单独的实例
+ * @param stk 指定证券
+ * @param query 查询条件
+ * @param sort_key Performance 中的统计项名称，按该统计项返回
+ * @param sort_mode 0 为取统计最高值的系统，其他值为取统计最低值的系统
+ * @return std::pair<double, SYSPtr>
+ */
+std::pair<double, SYSPtr> HKU_API findOptimalSystem(const SystemList& sys_list, const Stock& stk,
+                                                    const KQuery& query, const string& sort_key,
+                                                    int sort_mode = 0);
+
+std::pair<double, SYSPtr> HKU_API findOptimalSystemMulti(const SystemList& sys_list,
+                                                         const Stock& stk, const KQuery& query,
+                                                         const string& sort_key, int sort_mode = 0);
+}  // namespace hku

hikyuu/include/hikyuu/analysis/combinate.h

@@ -0,0 +1,115 @@
+/*
+ *  Copyright (c) 2023 hikyuu.org
+ *
+ *  Created on: 2023-09-26
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/indicator/Indicator.h"
+#include "hikyuu/trade_sys/system/System.h"
+#include "hikyuu/trade_manage/Performance.h"
+#include "hikyuu/utilities/Log.h"
+
+namespace hku {
+
+/**
+ * 获取指定序列索引的组合，返回由序列下标索引组成的组合集合
+ * @note 组合的总数是 2**n - 1 个，所以inputs的长度需要控制
+ * @exception 输入序列的最大长度仅支持15，超过时将抛出异常 HKUException
+ * @param inputs 任意类型的序列
+ * @return
+ */
+template <class T>
+std::vector<std::vector<size_t>> combinateIndex(const std::vector<T>& inputs) {
+    size_t total = inputs.size();
+    HKU_CHECK(total <= 15, "The length of inputs exceeds the maximum limit!");
+
+    std::vector<std::vector<size_t>> result;
+    std::vector<size_t> current;
+    for (size_t i = 0; i < total; i++) {
+        for (size_t j = 0, len = result.size(); j < len; j++) {
+            current.resize(result[j].size());
+            std::copy(result[j].cbegin(), result[j].cend(), current.begin());
+            current.push_back(i);
+            result.push_back(std::move(current));
+        }
+        current.clear();
+        current.push_back(i);
+        result.push_back(std::move(current));
+    }
+
+    return result;
+}
+
+/**
+ * @brief 对输入的指标序列进行组合
+ * @details
+ * 如输入为 [ind1, ind2], 输出为 [EXIST(ind1,n), EXIST(ind2,n),
+ * EXIST(ind1,n)&EXIST(ind2,n)]
+ * @param inputs 待组合的指标列表
+ * @param n 指标在 n 周期内存在
+ * @return std::vector<Indicator>
+ */
+std::vector<Indicator> HKU_API combinateIndicator(const std::vector<Indicator>& inputs, int n);
+
+/**
+ * @brief 对指定的证券及买入、卖出信号指标进行组合测试
+ * @param stk 指定证券
+ * @param query 指定范围条件
+ * @param tm 指定交易管理实例
+ * @param sys 指定交易策略实例
+ * @param buy_inds 买入信号指标列表
+ * @param sell_inds 卖出信号指标列表
+ * @param n 组合时间范围参数
+ * @return std::map<std::string, Performance>
+ */
+std::map<std::string, Performance> HKU_API combinateIndicatorAnalysis(
+  const Stock& stk, const KQuery& query, TradeManagerPtr tm, SystemPtr sys,
+  const std::vector<Indicator>& buy_inds, const std::vector<Indicator>& sell_inds, int n);
+
+/**
+ * @brief combinateIndicatorAnalysisWithBlock 输出结果定义
+ */
+struct HKU_API CombinateAnalysisOutput {
+    string combinateName;  ///< 买入、卖出指标组合名称
+    string market_code;    ///< 证券代码
+    string name;           ///< 证券名称
+    PriceList values;      ///< 统计各项指标值
+
+    CombinateAnalysisOutput() = default;
+    CombinateAnalysisOutput(const CombinateAnalysisOutput&) = default;
+    CombinateAnalysisOutput(CombinateAnalysisOutput&& rv)
+    : combinateName(std::move(rv.combinateName)),
+      market_code(std::move(rv.market_code)),
+      name(std::move(rv.name)),
+      values(std::move(rv.values)) {}
+
+    CombinateAnalysisOutput& operator=(const CombinateAnalysisOutput&) = default;
+    CombinateAnalysisOutput& operator=(CombinateAnalysisOutput&& rv) {
+        HKU_IF_RETURN(this == &rv, *this);
+        combinateName = std::move(rv.combinateName);
+        market_code = std::move(rv.market_code);
+        name = std::move(rv.name);
+        values = std::move(rv.values);
+        return *this;
+    }
+};
+
+/**
+ * @brief 对指定的证券列表，进行买入、卖出信号指标组合测试
+ * @param blk 指定板块
+ * @param query 指定范围条件
+ * @param tm 指定交易实例
+ * @param sys 指定系统策略实例
+ * @param buy_inds 买入指标列表
+ * @param sell_inds 卖出指标列表
+ * @param n 组合时间范围参数
+ * @return vector<CombinateAnalysisOutput>
+ */
+vector<CombinateAnalysisOutput> HKU_API combinateIndicatorAnalysisWithBlock(
+  const Block& blk, const KQuery& query, TradeManagerPtr tm, SystemPtr sys,
+  const std::vector<Indicator>& buy_inds, const std::vector<Indicator>& sell_inds, int n);
+
+}  // namespace hku

hikyuu/include/hikyuu/config.h

@@ -0,0 +1,51 @@
+#pragma once
+#ifndef HIKYUU_CONFIG_H_
+#define HIKYUU_CONFIG_H_
+
+// clang-format off
+
+// Debug 模式
+#define HKU_DEBUG_MODE 0
+
+// support serialization
+#define HKU_SUPPORT_SERIALIZATION  1
+
+#if HKU_SUPPORT_SERIALIZATION
+#define HKU_SUPPORT_TEXT_ARCHIVE   0
+#define HKU_SUPPORT_XML_ARCHIVE    1  //must 1 for python
+#define HKU_SUPPORT_BINARY_ARCHIVE 1  //must 1 for python
+#endif /* HKU_SUPPORT_SERIALIZATION*/
+
+// 检查下标越界
+#define CHECK_ACCESS_BOUND 1
+
+// 启用MSVC内存泄漏检查
+#define ENABLE_MSVC_LEAK_DETECT 0
+
+// 启用内存泄漏检测，用于 linux 系统
+#define HKU_ENABLE_LEAK_DETECT 0
+
+// 启用发送用户使用信息
+#define HKU_ENABLE_SEND_FEEDBACK 1
+
+// 启用 hdf5 K线数据引擎
+#define HKU_ENABLE_HDF5_KDATA 1
+
+// 启用 MySQL K线数据引擎
+#define HKU_ENABLE_MYSQL_KDATA 1
+
+// 启用 SQLite K线数据引擎
+#define HKU_ENABLE_SQLITE_KDATA 1
+
+// 启用通达信本地 K线数据引擎
+#define HKU_ENABLE_TDX_KDATA 1
+
+// 使用低精度版本，Indicator 使用 float 类型进行计算
+#define HKU_USE_LOW_PRECISION 0
+
+// 使用 TA-Lib
+#define HKU_ENABLE_TA_LIB 1
+
+// clang-format on
+
+#endif /* HIKYUU_CONFIG_H_ */