hikyuu 2.2.2__py3-none-win_amd64.whl

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_ */

hikyuu/include/hikyuu/KRecord.h

@@ -0,0 +1,94 @@
+/*
+ * KRecord.h
+ *
+ *  Created on: 2011-12-24
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef KRECORD_H_
+#define KRECORD_H_
+
+#include "DataType.h"
+
+namespace hku {
+
+/**
+ * K线数据记录
+ * @ingroup StockManage
+ */
+class KRecord {
+public:
+    Datetime datetime;    ///< 日期，格式：YYYYMMDDHHMM 如：200901010930
+    price_t openPrice;    ///< 开盘价
+    price_t highPrice;    ///< 最高价
+    price_t lowPrice;     ///< 最低价
+    price_t closePrice;   ///< 收盘价
+    price_t transAmount;  ///< 成交金额（万元）
+    price_t transCount;   ///< 成交量（手），日线以下为股数
+
+    KRecord()
+    : datetime(Null<Datetime>()),
+      openPrice(0.0),
+      highPrice(0.0),
+      lowPrice(0.0),
+      closePrice(0.0),
+      transAmount(0.0),
+      transCount(0.0) {}
+
+    explicit KRecord(const Datetime& indate)
+    : datetime(indate),
+      openPrice(0.0),
+      highPrice(0.0),
+      lowPrice(0.0),
+      closePrice(0.0),
+      transAmount(0.0),
+      transCount(0.0) {}
+
+    KRecord(const Datetime& date, price_t openPrice, price_t highPrice, price_t lowPrice,
+            price_t closePrice, price_t transAmount, price_t transCount)
+    : datetime(date),
+      openPrice(openPrice),
+      highPrice(highPrice),
+      lowPrice(lowPrice),
+      closePrice(closePrice),
+      transAmount(transAmount),
+      transCount(transCount) {}
+
+    bool isValid() const {
+        return datetime == Null<Datetime>() ? false : true;
+    }
+};
+
+/** @ingroup StockManage */
+typedef vector<KRecord> KRecordList;
+
+/** @ingroup StockManage */
+typedef shared_ptr<KRecordList> KRecordListPtr;
+
+/**
+ * 输出KRecord信息，如：KRecord(datetime, open, high, low, close, transAmount, count)
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream&, const KRecord&);
+
+/**
+ * 比较两个KRecord是否相等，一般仅测试时使用
+ * @ingroup StockManage
+ */
+bool HKU_API operator==(const KRecord& d1, const KRecord& d2);
+
+/**
+ * 两个KRecord不等比较
+ * @ingroup StockManage
+ */
+bool HKU_API operator!=(const KRecord& d1, const KRecord& d2);
+
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::KRecord> : ostream_formatter {};
+#endif
+
+#endif /* KRECORD_H_ */

hikyuu/include/hikyuu/MarketInfo.h

@@ -0,0 +1,132 @@
+/*
+ * MarketInfo.h
+ *
+ *  Created on: 2011-12-5
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef MARKETINFO_H_
+#define MARKETINFO_H_
+
+#include "DataType.h"
+
+namespace hku {
+
+/**
+ * 市场信息记录
+ * @ingroup StockManage
+ */
+class HKU_API MarketInfo {
+public:
+    /** 默认构造函数，返回Null<MarketInfo>() */
+    MarketInfo();
+
+    /**
+     * @param market 市场简称
+     * @param name 市场名称
+     * @param description 市场描述
+     * @param code 基本指数：用于读取该市场的交易日历
+     * @param lastDate 市场当前最后日期
+     * @param openTime1 开市时间段1起始时间
+     * @param closeTime1 开市时间段1结束时间
+     * @param openTime2 开市时间段2起始时间
+     * @param closeTime2 开市时间段2结束时间
+     */
+    MarketInfo(const string& market, const string& name, const string& description,
+               const string& code, const Datetime& lastDate, TimeDelta openTime1,
+               TimeDelta closeTime1, TimeDelta openTime2, TimeDelta closeTime2);
+
+    /** 获取市场简称 */
+    const string& market() const {
+        return m_market;
+    }
+
+    /** 获取市场名称 */
+    const string& name() const {
+        return m_name;
+    }
+
+    /** 获取市场描述 */
+    const string& description() const {
+        return m_description;
+    }
+
+    /** 获取该市场对应的指数代码 */
+    const string& code() const {
+        return m_code;
+    }
+
+    /** 获取市场数据的最后更新日期 */
+    Datetime lastDate() const {
+        return m_lastDate;
+    }
+
+    /** 开市时间1 */
+    TimeDelta openTime1() const {
+        return m_openTime1;
+    }
+
+    /** 闭市时间1 */
+    TimeDelta closeTime1() const {
+        return m_closeTime1;
+    }
+
+    /** 开市时间2 */
+    TimeDelta openTime2() const {
+        return m_openTime2;
+    }
+
+    /** 闭市时间2 */
+    TimeDelta closeTime2() const {
+        return m_closeTime2;
+    }
+
+    /** 仅用于python的__str__ */
+    string toString() const;
+
+private:
+    string m_market;         // 市场标识
+    string m_name;           // 市场名称
+    string m_description;    // 描述信息
+    string m_code;           // 市场对应的指数代码，用于获取交易日历
+    Datetime m_lastDate;     // 当前市场最后日期
+    TimeDelta m_openTime1;   // 上午开市时间
+    TimeDelta m_closeTime1;  // 上午闭市时间
+    TimeDelta m_openTime2;   // 下午开市时间
+    TimeDelta m_closeTime2;  // 下午闭市时间
+};
+
+/**
+ * 输出市场信息，如：
+ * MarketInfo(SH, 上海证券交易所, 上海市场, 000001, 2011-Dec-06 00:00:00)
+ * @ingroup StockManage
+ */
+HKU_API std::ostream& operator<<(std::ostream&, const MarketInfo&);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// 关系比较函数
+//
+///////////////////////////////////////////////////////////////////////////////
+bool operator==(const MarketInfo&, const MarketInfo&);
+bool operator!=(const MarketInfo&, const MarketInfo&);
+
+/** 相等比较 */
+inline bool operator==(const MarketInfo& m1, const MarketInfo& m2) {
+    return m1.market() == m2.market();
+}
+
+/** 不等比较 */
+inline bool operator!=(const MarketInfo& m1, const MarketInfo& m2) {
+    return m1.market() != m2.market();
+}
+
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::MarketInfo> : ostream_formatter {};
+#endif
+
+#endif /* MARKETINFO_H_ */