hikyuu 2.2.2__py3-none-win_amd64.whl

hikyuu/include/hikyuu/indicator/imp/IStdev.h

@@ -0,0 +1,31 @@
+/*
+ * IStdev.h
+ *
+ *  Created on: 2013-4-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 计算N周期内样本标准差
+ * 参数： n: N日时间窗口
+ * TODO      ma : 计算均值的函数原型
+ *       link：均值参数联动标志，默认true
+ *
+ */
+class IStdev : public hku::IndicatorImp {
+    INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(IStdev)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IStdev();
+    virtual ~IStdev();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/IStdp.h

@@ -0,0 +1,33 @@
+/*
+ * IStdp.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-4-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_ISTDP_H_
+#define INDICATOR_IMP_ISTDP_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 计算N周期内总体标准差
+ * 参数： n: N日时间窗口
+ */
+class IStdp : public hku::IndicatorImp {
+    INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(IStdp)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IStdp();
+    virtual ~IStdp();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_ISTDP_H_ */

hikyuu/include/hikyuu/indicator/imp/ISum.h

@@ -0,0 +1,27 @@
+/*
+ * ISum.h
+ *
+ *  Created on: 2019-4-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_HKU_ISUM_H_
+#define INDICATOR_IMP_HKU_ISUM_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class ISum : public IndicatorImp {
+    INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(ISum)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    ISum();
+    virtual ~ISum();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_HKU_ISUM_H_ */

hikyuu/include/hikyuu/indicator/imp/ISumBars.h

@@ -0,0 +1,30 @@
+/*
+ * ISumBars.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-5-5
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_ISUMBARS_H_
+#define INDICATOR_IMP_ISUMBARS_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class ISumBars : public IndicatorImp {
+    INDICATOR_IMP(ISumBars)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    ISumBars();
+    virtual ~ISumBars();
+
+    virtual void _dyn_calculate(const Indicator&) override;
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_ISUMBARS_H_ */

hikyuu/include/hikyuu/indicator/imp/ITan.h

@@ -0,0 +1,28 @@
+/*
+ * ITan.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-5-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_ITAN_H_
+#define INDICATOR_IMP_ITAN_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class ITan : public IndicatorImp {
+    INDICATOR_IMP(ITan)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    ITan();
+    virtual ~ITan();
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_ITAN_H_ */

hikyuu/include/hikyuu/indicator/imp/ITime.h

@@ -0,0 +1,33 @@
+/*
+ *  Copyright (c) 2023 hikyuu.org
+ *
+ *  Created on: 2023-11-09
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_ITIME_H_
+#define INDICATOR_IMP_ITIME_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 通达信时间函数实现
+ */
+class ITime : public IndicatorImp {
+    INDICATOR_IMP(ITime)
+    INDICATOR_NEED_CONTEXT
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    ITime();
+    ITime(const KData&, const string& type);
+    virtual ~ITime();
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku
+
+#endif  // INDICATOR_IMP_ITIME_H_

hikyuu/include/hikyuu/indicator/imp/ITimeLine.h

@@ -0,0 +1,32 @@
+/*
+ * ITimeLine.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-5-15
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_ITIMELINE_H_
+#define INDICATOR_IMP_ITIMELINE_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class ITimeLine : public IndicatorImp {
+    INDICATOR_IMP(ITimeLine)
+    INDICATOR_NEED_CONTEXT
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    ITimeLine();
+    explicit ITimeLine(const KData&);
+    virtual ~ITimeLine();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */
+
+#endif /* INDICATOR_IMP_ITIMELINE_H_ */

hikyuu/include/hikyuu/indicator/imp/IVar.h

@@ -0,0 +1,32 @@
+/*
+ * IVar.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-5-2
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_IVAR_H_
+#define INDICATOR_IMP_IVAR_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 估算样本方差
+ */
+class IVar : public hku::IndicatorImp {
+    INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(IVar)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IVar();
+    virtual ~IVar();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_IVAR_H_ */

hikyuu/include/hikyuu/indicator/imp/IVarp.h

@@ -0,0 +1,32 @@
+/*
+ * IVarp.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-5-2
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef INDICATOR_IMP_IVARP_H_
+#define INDICATOR_IMP_IVARP_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 估算总体样本方差
+ */
+class IVarp : public hku::IndicatorImp {
+    INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(IVarp)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IVarp();
+    virtual ~IVarp();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */
+#endif /* INDICATOR_IMP_IVARP_H_ */

hikyuu/include/hikyuu/indicator/imp/IVigor.h

@@ -0,0 +1,35 @@
+/*
+ * IVigor.h
+ *
+ *  Created on: 2013-4-12
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef IVIGOR_H_
+#define IVIGOR_H_
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 亚历山大.艾尔德力度指数
+ * 参见《走进我的交易室》（2007年 地震出版社） (Alexander Elder) P131
+ * 计算公式：（收盘价今－收盘价昨）＊成交量今
+ * n: 用于EMA平滑的周期窗口，必须为大于0的整数
+ */
+class IVigor : public IndicatorImp {
+    INDICATOR_IMP(IVigor)
+    INDICATOR_NEED_CONTEXT
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IVigor();
+    explicit IVigor(int n);
+    virtual ~IVigor();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */
+#endif /* IVIGOR_H_ */

hikyuu/include/hikyuu/indicator/imp/IZScore.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-03-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class IZScore : public IndicatorImp {
+    INDICATOR_IMP(IZScore)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IZScore();
+    IZScore(bool outExtreme, double nsigma, bool recursive);
+    virtual ~IZScore();
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/indicator/imp/IZhBond10.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-03-01
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/*
+ * 根据上下文或输入参数获取10年期中国国债收益率
+ * 1. 上下文日期优先
+ * 2. 如果时间早于不存在国债数据的情况下，使用默认值替代
+ * 3. 时间如果大于已有国债数据，则取最后的国债数据
+ */
+class IZhBond10 : public IndicatorImp {
+    INDICATOR_IMP(IZhBond10)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IZhBond10();
+    explicit IZhBond10(const DatetimeList& dates, double default_val = 4.0);
+    virtual ~IZhBond10();
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/indicator/imp/IZongGuBen.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-04-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class IZongGuBen : public IndicatorImp {
+    INDICATOR_IMP(IZongGuBen)
+    INDICATOR_NEED_CONTEXT
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IZongGuBen();
+    explicit IZongGuBen(const KData&);
+    virtual ~IZongGuBen();
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/python/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/python/pickle_support.h

@@ -0,0 +1,90 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2020-5-24
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef PICKLE_SUPPORT_H_
+#define PICKLE_SUPPORT_H_
+
+#include <hikyuu/config.h>
+
+#if HKU_SUPPORT_BINARY_ARCHIVE || HKU_SUPPORT_XML_ARCHIVE || HKU_SUPPORT_TEXT_ARCHIVE
+#define HKU_PYTHON_SUPPORT_PICKLE 1
+#endif
+
+#if HKU_PYTHON_SUPPORT_PICKLE
+#if HKU_SUPPORT_BINARY_ARCHIVE
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::binary_oarchive
+#define INPUT_ARCHIVE boost::archive::binary_iarchive
+
+#else
+#if HKU_SUPPORT_XML_ARCHIVE
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::xml_oarchive
+#define INPUT_ARCHIVE boost::archive::xml_iarchive
+
+#else
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::text_oarchive
+#define INPUT_ARCHIVE boost::archive::text_iarchive
+#endif /* HKU_SUPPORT_XML_ARCHIVE */
+
+#endif /* HKU_SUPPORT_BINARY_ARCHIVE */
+#endif /* HKU_PYTHON_SUPPORT_PICKLE */
+
+#if HKU_PYTHON_SUPPORT_PICKLE
+#include <string>
+#include <sstream>
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+#define DEF_PICKLE(classname)                                                                      \
+    .def(py::pickle(                                                                               \
+      [](const classname& p) {                                                                     \
+          std::ostringstream os;                                                                   \
+          OUTPUT_ARCHIVE oa(os);                                                                   \
+          oa << p;                                                                                 \
+          std::string tmp(os.str());                                                               \
+          return py::make_tuple(py::handle(PyBytes_FromStringAndSize(tmp.data(), tmp.size())));    \
+      },                                                                                           \
+      [](py::tuple t) {                                                                            \
+          classname result;                                                                        \
+          if (len(t) != 1) {                                                                       \
+              PyErr_SetObject(                                                                     \
+                PyExc_ValueError,                                                                  \
+                py::str("expected 1-item tuple in call to __setstate__; got {}").format(t).ptr()); \
+              throw py::error_already_set();                                                       \
+          }                                                                                        \
+          py::object obj = t[0];                                                                   \
+          if (py::isinstance<py::str>(obj)) {                                                      \
+              std::string st = obj.cast<py::str>();                                                \
+              std::istringstream is(st);                                                           \
+              INPUT_ARCHIVE ia(is);                                                                \
+              ia >> result;                                                                        \
+          } else if (PyBytes_Check(py::object(t[0]).ptr())) {                                      \
+              py::object obj = t[0];                                                               \
+              char* data = PyBytes_AsString(obj.ptr());                                            \
+              auto num = PyBytes_Size(obj.ptr());                                                  \
+              std::istringstream sin(std::string(data, num));                                      \
+              INPUT_ARCHIVE ia(sin);                                                               \
+              ia >> result;                                                                        \
+              return result;                                                                       \
+          } else {                                                                                 \
+              throw std::runtime_error("Unable to unpickle, error in input file.");                \
+          }                                                                                        \
+          return result;                                                                           \
+      }))
+
+#else
+#define DEF_PICKLE(classname)
+#endif /* HKU_PYTHON_SUPPORT_PICKLE */
+
+#endif /* PICKLE_SUPPORT_H_ */

hikyuu/include/hikyuu/python/pybind_utils.h

@@ -0,0 +1,103 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2020-5-25
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_PYTHON_BIND_UTILS_H
+#define HIKYUU_PYTHON_BIND_UTILS_H
+
+#include <pybind11/pybind11.h>
+
+#include <pybind11/operators.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include <vector>
+#include <string>
+#include "convert_any.h"
+#include "pickle_support.h"
+#include "ioredirect.h"
+
+namespace py = pybind11;
+
+namespace hku {
+
+template <typename T>
+py::bytes vector_to_python_bytes(const std::vector<T>& vect) {
+    return py::bytes((char*)vect.data(), vect.size() * sizeof(T));
+}
+
+template <typename T>
+std::vector<T> python_bytes_to_vector(const py::bytes& obj) {
+    auto bytes_len = len(obj);
+    if (bytes_len % sizeof(T) != 0) {
+        throw std::runtime_error("The length bytes not match!");
+    }
+    auto vect_len = bytes_len / sizeof(T);
+    std::vector<T> result(vect_len);
+
+    char* buffer = nullptr;
+    Py_ssize_t length = 0;
+    if (PyBytes_AsStringAndSize(obj.ptr(), &buffer, &length) != 0) {
+        throw std::runtime_error("trans bytes to vector failed!");
+    }
+
+    if (length != static_cast<Py_ssize_t>(vect_len * sizeof(T))) {
+        throw std::runtime_error("The length bytes not match!");
+    }
+
+    memcpy(result.data(), buffer, length);
+    return result;
+}
+
+template <typename T>
+std::vector<T> python_list_to_vector(const py::sequence& obj) {
+    auto total = len(obj);
+    std::vector<T> vect(total);
+    for (auto i = 0; i < total; ++i) {
+        vect[i] = obj[i].cast<T>();
+    }
+    return vect;
+}
+
+template <typename T>
+py::list vector_to_python_list(const std::vector<T>& vect) {
+    py::list obj;
+    for (unsigned long i = 0; i < vect.size(); ++i)
+        obj.append(vect[i]);
+    return obj;
+}
+
+template <typename T>
+void extend_vector_with_python_list(std::vector<T>& v, const py::sequence& l) {
+    for (const auto& item : l)
+        v.push_back(item.cast<T>());
+}
+
+template <typename T>
+std::string to_py_str(const T& item) {
+    std::stringstream out;
+    out << item;
+    return out.str();
+}
+
+// 直接使用 pybind11 重载 _clone，在 C++ 中会丢失 python 中的类型
+// 参考：https://github.com/pybind/pybind11/issues/1049 进行修改
+// PYBIND11_OVERLOAD(IndicatorImpPtr, IndicatorImp, _clone, );
+#define PY_CLONE(pyclassname, classname)                                     \
+public:                                                                      \
+    std::shared_ptr<classname> _clone() override {                           \
+        auto self = py::cast(this);                                          \
+        auto cloned = self.attr("_clone")();                                 \
+                                                                             \
+        auto keep_python_state_alive = std::make_shared<py::object>(cloned); \
+        auto ptr = cloned.cast<pyclassname*>();                              \
+                                                                             \
+        return std::shared_ptr<classname>(keep_python_state_alive, ptr);     \
+    }
+
+}  // namespace hku
+
+#endif  // HIKYUU_PYTHON_BIND_UTILS_H

hikyuu/include/hikyuu/serialization/Block_serialization.h

@@ -0,0 +1,55 @@
+/*
+ * Block_serialization.h
+ *
+ *  Created on: 2015年2月9日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef BLOCK_SERIALIZATION_H_
+#define BLOCK_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../Block.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#include "Stock_serialization.h"
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, const hku::Block& blk, unsigned int version) {
+    hku::string category = blk.category();
+    hku::string name = blk.name();
+    ar& boost::serialization::make_nvp("category", category);
+    ar& boost::serialization::make_nvp("name", name);
+    hku::StockList stock_list;
+    stock_list.reserve(blk.size());
+    for (auto iter = blk.begin(); iter != blk.end(); ++iter) {
+        stock_list.push_back(*iter);
+    }
+    ar& boost::serialization::make_nvp("stock_list", stock_list);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::Block& blk, unsigned int version) {
+    hku::string category, name;
+    ar& boost::serialization::make_nvp("category", category);
+    ar& boost::serialization::make_nvp("name", name);
+    hku::StockList stock_list;
+    ar& boost::serialization::make_nvp("stock_list", stock_list);
+    HKU_IF_RETURN(category.empty() && name.empty(), void());
+    blk.category(category);
+    blk.name(name);
+    for (auto iter = stock_list.begin(); iter != stock_list.end(); ++iter) {
+        blk.add(*iter);
+    }
+}
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::Block)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* BLOCK_SERIALIZATION_H_ */