hikyuu 2.3.1__py3-none-macosx_11_1_arm64.whl

hikyuu/include/hikyuu/KData.h

@@ -0,0 +1,271 @@
+/*
+ * KData.h
+ *
+ *  Created on: 2012-9-25
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef KDATA_H_
+#define KDATA_H_
+
+#include "KDataImp.h"
+
+namespace hku {
+
+class HKU_API Indicator;
+
+/**
+ * K线数据
+ * @ingroup StockManage
+ */
+class HKU_API KData {
+public:
+    KData();
+    KData(const KData&);
+    KData(const Stock& stock, const KQuery& query);
+    virtual ~KData() {}
+
+    KData& operator=(const KData&);
+
+    // 移动语义对 KData 没有实际用处，而且会导致 KData 可能存在空 imp 的情况
+    // 主要是 boost::any_cast 需要，予以保留，但使用时不要到 KData 执行 std::move
+    KData(KData&&);
+    KData& operator=(KData&&);
+
+    size_t size() const;
+    bool empty() const;
+
+    bool operator==(const KData&) const;
+    bool operator!=(const KData&) const;
+
+    DatetimeList getDatetimeList() const;
+
+    /** 获取指定位置的KRecord，未作越界检查 */
+    const KRecord& getKRecord(size_t pos) const;
+
+    /** 按日期查询KRecord */
+    const KRecord& getKRecord(Datetime datetime) const;
+
+    /** 同getKRecord @see getKRecord */
+    const KRecord& operator[](size_t pos) const {
+        return getKRecord(pos);
+    }
+
+    /** 同getKRecord @see getKRecord */
+    const KRecord& operator[](Datetime datetime) const {
+        return getKRecord(datetime);
+    }
+
+    /**
+     * 通过当前 KData 获取一个保持数据类型、复权类型不变的新的 KData
+     * @note 新的 KData 并不一定是原 KData 的子集
+     * @param start 起始日期
+     * @param end 结束日期
+     */
+    KData getKData(const Datetime& start, const Datetime& end) const;
+
+    /** 按日期查询对应的索引位置，注：是 KData 中的位置，不是在 Stock 中原始K记录的位置 */
+    size_t getPos(const Datetime& datetime) const;
+
+    /** 按日期获取在原始 K 线记录中的位置 */
+    size_t getPosInStock(Datetime datetime) const;
+
+    /** 获取关联的KQuery */
+    const KQuery& getQuery() const;
+
+    /** 获取关联的Stock，如果没有关联返回Null<Stock> */
+    const Stock& getStock() const;
+
+    /** 获取在原始K线记录中对应的起始位置，如果为空返回0 */
+    size_t startPos() const;
+
+    /** 获取在原始K线记录中对应的最后一条记录的位置，如果为空返回0,其他等于endPos - 1 */
+    size_t lastPos() const;
+
+    /** 获取在原始K线记录中对应范围的下一条记录的位置，如果为空返回0,其他等于lastPos + 1 */
+    size_t endPos() const;
+
+    /** 输出数据到指定的文件中 */
+    void tocsv(const string& filename);
+
+    string toString() const;
+
+    /** 开盘价 */
+    Indicator open() const;
+
+    /** 最高价 */
+    Indicator high() const;
+
+    /** 收盘价 */
+    Indicator close() const;
+
+    /** 最低价 */
+    Indicator low() const;
+
+    /** 成交量 */
+    Indicator vol() const;
+
+    /** 成交金额 */
+    Indicator amo() const;
+
+public:
+    typedef KRecordList::iterator iterator;
+    typedef KRecordList::const_iterator const_iterator;
+    iterator begin();
+    iterator end();
+    const_iterator cbegin() const;
+    const_iterator cend() const;
+    const KRecord* data() const;
+
+private:
+    static KRecord ms_null_krecord;
+
+private:
+    KDataImpPtr m_imp;
+};
+
+/**
+ * 输出KData信息
+ * @details
+ * <pre>
+ * KData{
+ *   size : 738501
+ *   stock: Stock(SH, 000001, 上证指数, 指数, 1, 1990-Dec-19 00:00:00, +infinity),
+ *   query: KQuery(0, 99999999999, INDEX, MIN, NO_RECOVER)
+ *  }
+ * </pre>
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream& os, const KData& kdata);
+
+/**
+ * 根据股票标识按指定的查询条件查询的 K 线数据
+ * @param market_code 股票标识
+ * @param query 查询条件
+ * @ingroup StockManage
+ */
+KData HKU_API getKData(const string& market_code, const KQuery& query);
+
+/**
+ * 根据股票标识直接按日期查询获取相应的 K 线数据
+ * @param market_code 股票标识
+ * @param start 起始日期
+ * @param end 结束日期
+ * @param ktype K线类型
+ * @param recoverType 复权类型
+ * @ingroup StockManage
+ */
+KData HKU_API getKData(const string& market_code, const Datetime& start = Datetime::min(),
+                       const Datetime& end = Null<Datetime>(),
+                       const KQuery::KType& ktype = KQuery::DAY,
+                       KQuery::RecoverType recoverType = KQuery::NO_RECOVER);
+
+/**
+ * 根据股票标识直接按索引位置查询获取相应的 K 线数据
+ * @param market_code 股票标识
+ * @param start 起始索引
+ * @param end 结束索引
+ * @param ktype K线类型
+ * @param recoverType 复权类型
+ * @ingroup StockManage
+ */
+KData HKU_API getKData(const string& market_code, int64_t start = 0, int64_t end = Null<int64_t>(),
+                       const KQuery::KType& ktype = KQuery::DAY,
+                       KQuery::RecoverType recoverType = KQuery::NO_RECOVER);
+
+inline KData::KData(const KData& x) : m_imp(x.m_imp) {}
+
+inline KData::KData(KData&& x) : m_imp(std::move(x.m_imp)) {}
+
+inline KData& KData::operator=(const KData& x) {
+    if (this == &x)
+        return *this;
+    m_imp = x.m_imp;
+    return *this;
+}
+
+inline KData& KData::operator=(KData&& x) {
+    if (this == &x)
+        return *this;
+    m_imp = std::move(x.m_imp);
+    return *this;
+}
+
+inline DatetimeList KData::getDatetimeList() const {
+    return m_imp->getDatetimeList();
+}
+
+inline const KRecord& KData::getKRecord(size_t pos) const {
+    return m_imp->getKRecord(pos);  // 不会抛出异常
+}
+
+inline const KRecord& KData::getKRecord(Datetime datetime) const {
+    size_t pos = getPos(datetime);
+    return pos != Null<size_t>() ? getKRecord(pos) : ms_null_krecord;
+}
+
+inline size_t KData::getPos(const Datetime& datetime) const {
+    return m_imp->getPos(datetime);
+}
+
+inline size_t KData::size() const {
+    return m_imp->size();
+}
+
+inline bool KData::empty() const {
+    return m_imp->empty();
+}
+
+inline const KQuery& KData::getQuery() const {
+    return m_imp->getQuery();
+}
+
+inline const Stock& KData::getStock() const {
+    return m_imp->getStock();
+}
+
+inline size_t KData::startPos() const {
+    return m_imp->startPos();
+}
+
+inline size_t KData::endPos() const {
+    return m_imp->endPos();
+}
+
+inline size_t KData::lastPos() const {
+    return m_imp->lastPos();
+}
+
+inline bool KData::operator!=(const KData& other) const {
+    return !(*this == other);
+}
+
+inline KData::iterator KData::begin() {
+    return m_imp->begin();
+}
+
+inline KData::iterator KData::end() {
+    return m_imp->end();
+}
+
+inline KData::const_iterator KData::cbegin() const {
+    return m_imp->cbegin();
+}
+
+inline KData::const_iterator KData::cend() const {
+    return m_imp->cend();
+}
+
+inline const KRecord* KData::data() const {
+    return m_imp->data();
+}
+
+} /* namespace hku */
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::KData> : ostream_formatter {};
+#endif
+
+#endif /* KDATA_H_ */

hikyuu/include/hikyuu/KDataImp.h

@@ -0,0 +1,94 @@
+/*
+ * KDataImp.h
+ *
+ *  Created on: 2013-2-4
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef KDATAIMP_H_
+#define KDATAIMP_H_
+
+#include "Stock.h"
+
+namespace hku {
+
+class HKU_API KDataImp {
+public:
+    KDataImp();
+    KDataImp(const Stock& stock, const KQuery& query);
+    virtual ~KDataImp();
+
+    const KQuery& getQuery() const {
+        return m_query;
+    }
+
+    const Stock& getStock() const {
+        return m_stock;
+    }
+
+    const KRecord& getKRecord(size_t pos) const {
+        return m_buffer[pos];
+    }
+
+    bool empty() const {
+        return m_buffer.empty();
+    }
+
+    size_t size() {
+        return m_buffer.size();
+    }
+
+    size_t startPos();
+    size_t endPos();
+    size_t lastPos();
+
+    size_t getPos(const Datetime& datetime);
+
+    const KRecord* data() const {
+        return m_buffer.data();
+    }
+
+    DatetimeList getDatetimeList() const;
+
+public:
+    typedef KRecordList::iterator iterator;
+    typedef KRecordList::const_iterator const_iterator;
+
+    iterator begin() {
+        return m_buffer.begin();
+    }
+
+    iterator end() {
+        return m_buffer.end();
+    }
+
+    const_iterator cbegin() const {
+        return m_buffer.cbegin();
+    }
+
+    const_iterator cend() const {
+        return m_buffer.cend();
+    }
+
+private:
+    void _getPosInStock();
+    void _recoverForward();
+    void _recoverBackward();
+    void _recoverEqualForward();
+    void _recoverEqualBackward();
+    void _recoverForUpDay();
+
+private:
+    KRecordList m_buffer;
+    KQuery m_query;
+    Stock m_stock;
+    size_t m_start;
+    size_t m_end;
+    bool m_have_pos_in_stock;
+};
+
+typedef shared_ptr<KDataImp> KDataImpPtr;
+
+} /* namespace hku */
+#endif /* KDATAIMP_H_ */

hikyuu/include/hikyuu/KQuery.h

@@ -0,0 +1,275 @@
+/*
+ * KQuery.h
+ *
+ *  Created on: 2009-11-23
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef KQUERY_H_
+#define KQUERY_H_
+
+#include "KRecord.h"
+
+namespace hku {
+
+/**
+ * 按索引方式查询K线数据条件
+ * @ingroup StockManage
+ */
+class HKU_API KQuery {
+public:
+    /// 查询方式：索引或日期
+    enum QueryType {
+        INDEX = 0,  ///< 按索引方式查询
+        DATE = 1,   ///< 按日期方式查询
+        INVALID = 2
+    };
+
+    /// 查询K线类型：日线/周线等
+    /*enum KType {
+        //notes: 如添加新类型，请注意按大小顺序添加，否则可能出错
+        MIN      = 0,  ///<1分钟线
+        MIN5     = 1,  ///<5分钟线
+        MIN15    = 2,  ///<15分钟线
+        MIN30    = 3,  ///<30分钟线
+        MIN60    = 4,  ///<60分钟线
+        DAY      = 5,  ///<日线
+        WEEK     = 6,  ///<周线
+        MONTH    = 7,  ///<月线
+        QUARTER  = 8,  ///<季线
+        HALFYEAR = 9,  ///<半年线
+        YEAR     = 10, ///<年线
+
+        //BTC扩展
+        MIN3     = 11,  ///<3分钟线
+        HOUR2    = 12,  ///<2小时线
+        HOUR4    = 13,  ///<4小时线
+        HOUR6    = 14,  ///<6小时线
+        HOUR12   = 15,  ///<12小时线
+        INVALID_KTYPE = 16
+    };*/
+    typedef string KType;
+
+    static const string MIN;
+    static const string MIN5;
+    static const string MIN15;
+    static const string MIN30;
+    static const string MIN60;
+    static const string DAY;
+    static const string WEEK;
+    static const string MONTH;
+    static const string QUARTER;
+    static const string HALFYEAR;
+    static const string YEAR;
+    static const string MIN3;
+    static const string HOUR2;
+    static const string HOUR4;
+    static const string HOUR6;
+    static const string HOUR12;
+    // static const string INVALID_KTYPE;
+
+    /** 获取所有的 KType */
+    static const vector<KType>& getAllKType();
+
+    static int32_t getKTypeInMin(KType);
+
+    /** 判断是否为有效 ktype */
+    static bool isKType(const string& ktype);
+
+    /**
+     * 复权类型
+     * @note 日线以上，如周线/月线不支持复权
+     */
+    enum RecoverType {
+        NO_RECOVER = 0,      ///< 不复权
+        FORWARD = 1,         ///< 前向复权
+        BACKWARD = 2,        ///< 后向复权
+        EQUAL_FORWARD = 3,   ///< 等比前向复权
+        EQUAL_BACKWARD = 4,  ///< 等比后向复权
+        INVALID_RECOVER_TYPE = 5
+    };
+
+    /** 默认构造，按索引方式查询全部日线数据，不复权 */
+    KQuery()
+    : m_start(0),
+      m_end(Null<int64_t>()),
+      m_queryType(INDEX),
+      m_dataType(DAY),
+      m_recoverType(NO_RECOVER) {};
+
+    /**
+     * K线查询，范围[start, end)
+     * @param start 起始索引，支持负数
+     * @param end  结束索引（不包含本身），支持负数
+     * @param dataType K线类型
+     * @param recoverType 复权类型
+     * @param queryType 默认按索引方式查询
+     */
+    KQuery(int64_t start,  // cppcheck-suppress [noExplicitConstructor]
+           int64_t end = Null<int64_t>(), const KType& dataType = DAY,
+           RecoverType recoverType = NO_RECOVER, QueryType queryType = INDEX)
+    : m_start(start),
+      m_end(end),
+      m_queryType(queryType),
+      m_dataType(dataType),
+      m_recoverType(recoverType) {
+        to_upper(m_dataType);
+    }
+
+    /**
+     * 按指定日期查询 K 线，范围[start, end)
+     * @param start 起始日期
+     * @param end  结束日期
+     * @param ktype K线类型
+     * @param recoverType 复权类型
+     */
+    KQuery(Datetime start,  // cppcheck-suppress [noExplicitConstructor]
+           Datetime end = Null<Datetime>(), const KType& ktype = DAY,
+           RecoverType recoverType = NO_RECOVER);
+
+    /**
+     * 按索引方式查询时，返回指定的起始索引，否则返回Null<int64_t>()
+     */
+    int64_t start() const {
+        return m_queryType != INDEX ? Null<int64_t>() : m_start;
+    }
+
+    /**
+     * 按索引方式查询时，返回指定的结束索引，否则返回Null<int64_t>()
+     */
+    int64_t end() const {
+        return m_queryType != INDEX ? Null<int64_t>() : m_end;
+    }
+
+    /**
+     * 按日期方式查询时，返回指定的起始日期，否则返回Null<Datetime>()
+     */
+    Datetime startDatetime() const;
+
+    /**
+     * 按日期方式查询时，返回指定的结束日期，否则返回Null<Datetime>()
+     */
+    Datetime endDatetime() const;
+
+    /** 获取查询条件类型 */
+    QueryType queryType() const {
+        return m_queryType;
+    }
+
+    /** 获取K线数据类型 */
+    // KType kType() const { return m_dataType; }
+    string kType() const {
+        return m_dataType;
+    }
+
+    /** 获取复权类型 */
+    RecoverType recoverType() const {
+        return m_recoverType;
+    }
+
+    /** 设置复权类型 */
+    void recoverType(RecoverType recoverType) {
+        m_recoverType = recoverType;
+    }
+
+    /** 获取queryType名称，用于显示输出 */
+    static string getQueryTypeName(QueryType);
+
+    /** 获取KType名称，用于显示输出 */
+    static string getKTypeName(KType);
+
+    /** 获取recoverType名称，用于显示输出 */
+    static string getRecoverTypeName(RecoverType);
+
+    /** 根据字符串名称获取相应的queryType枚举值 */
+    static QueryType getQueryTypeEnum(const string&);
+
+    /** 根据字符串名称，获取相应的枚举值 */
+    static KType getKTypeEnum(const string&);
+
+    /** 根据字符串名称，获取相应的枚举值 */
+    static RecoverType getRecoverTypeEnum(const string&);
+
+private:
+    int64_t m_start;
+    int64_t m_end;
+    QueryType m_queryType;
+    KType m_dataType;
+    RecoverType m_recoverType;
+};
+
+/**
+ * 构造按索引方式K线查询，范围[start, end)
+ * @param start 起始索引，支持负数
+ * @param end  结束索引（不包含本身），支持负数
+ * @param dataType K线类型
+ * @param recoverType 复权类型
+ * @see KQuery
+ * @ingroup StockManage*
+ */
+KQuery HKU_API KQueryByIndex(int64_t start = 0, int64_t end = Null<int64_t>(),
+                             const KQuery::KType& dataType = KQuery::DAY,
+                             KQuery::RecoverType recoverType = KQuery::NO_RECOVER);
+
+inline KQuery KQueryByIndex(int64_t start, int64_t end, const KQuery::KType& dataType,
+                            KQuery::RecoverType recoverType) {
+    return KQuery(start, end, dataType, recoverType, KQuery::INDEX);
+}
+
+/**
+ * 构造按日期方式K线查询，范围[startDatetime, endDatetime)
+ * @param start 起始日期
+ * @param end  结束日期（不包含本身）
+ * @param dataType K线类型
+ * @param recoverType 复权类型
+ * @see KQuery
+ * @ingroup StockManage
+ */
+KQuery HKU_API KQueryByDate(const Datetime& start = Datetime::min(),
+                            const Datetime& end = Null<Datetime>(),
+                            const KQuery::KType& dataType = KQuery::DAY,
+                            KQuery::RecoverType recoverType = KQuery::NO_RECOVER);
+
+inline KQuery KQueryByDate(const Datetime& start, const Datetime& end,
+                           const KQuery::KType& dataType, KQuery::RecoverType recoverType) {
+    return KQuery(start, end, dataType, recoverType);
+}
+
+/**
+ * 输出KQuery信息，如：KQuery(start, end, queryType, kType, recoverType)
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream& os, const KQuery& query);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// 关系比较函数, 不直接在类中定义是为了支持 Null<>() == d，Null可以放在左边
+//
+///////////////////////////////////////////////////////////////////////////////
+bool HKU_API operator==(const KQuery&, const KQuery&);
+bool HKU_API operator!=(const KQuery&, const KQuery&);
+
+/**
+ * 提供KQuery的Null值
+ * @ingroup StockManage
+ */
+template <>
+class Null<KQuery> {
+public:
+    Null() {}
+    operator KQuery() {
+        return KQuery(Null<int64_t>(), Null<int64_t>(),
+                      "",  // KQuery::INVALID_KTYPE,
+                      KQuery::INVALID_RECOVER_TYPE, KQuery::INVALID);
+    }
+};
+
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::KQuery> : ostream_formatter {};
+#endif
+
+#endif /* KQUERY_H_ */