add WMA

Author: fasiondog

hikyuu_cpp/hikyuu/indicator/crt/WMA.h

@@ -20,25 +20,26 @@ namespace hku {
  * @ingroup Indicator
  */
 Indicator HKU_API WMA(int n = 22);
-// Indicator HKU_API MA(const IndParam& n);
-
-// /**
-//  * 简单移动平均
-//  * @param ind 待计算的数据
-//  * @param n 计算均值的周期窗口，n为0时从第一个有效数据开始计算
-//  * @ingroup Indicator
-//  */
+Indicator HKU_API WMA(const IndParam& n);
+
+/**
+ * 加权移动平均
+ * 算法:Yn=(1*X1+2*X2+...+n*Xn)/(1+2+...+n)
+ * @param ind 待计算的数据
+ * @param n 计算均值的周期窗口
+ * @ingroup Indicator
+ */
 inline Indicator HKU_API WMA(const Indicator& ind, int n = 22) {
     return WMA(n)(ind);
 }
 
-// inline Indicator HKU_API MA(const Indicator& ind, const IndParam& n) {
-//     return MA(n)(ind);
-// }
+inline Indicator HKU_API WMA(const Indicator& ind, const IndParam& n) {
+    return WMA(n)(ind);
+}
 
-// inline Indicator MA(const Indicator& ind, const Indicator& n) {
-//     return MA(IndParam(n))(ind);
-// }
+inline Indicator WMA(const Indicator& ind, const Indicator& n) {
+    return WMA(IndParam(n))(ind);
+}
 
 }  // namespace hku
 

hikyuu_cpp/hikyuu/indicator/imp/IWma.cpp

@@ -42,42 +42,49 @@ void IWma::_calculate(const Indicator& ind) {
         return;
     }
 
-    size_t startIdx = m_discard;
-    size_t outIdx = m_discard;
-    size_t trailingIdx = startIdx - 1;
-
-    value_t tempReal = 0.0, periodSum = 0.0, periodSub = 0.0;
-    size_t inIdx = ind.discard();
-    size_t i = 1;
-    while (inIdx < startIdx) {
-        tempReal = src[inIdx++];
-        periodSub += tempReal;
-        periodSum += tempReal * i;
-        i++;
+    value_t subsum = 0.0, sum = 0.0;
+    for (size_t i = ind.discard(), end = m_discard + 1, count = 1; i < end; i++, count++) {
+        subsum += src[i];
+        sum += src[i] * count;
     }
 
-    size_t endIdx = total - 1;
-    value_t trailingValue = 0.;
     value_t divider = n * (n + 1) / 2.0;
-    while (inIdx <= endIdx) {
-        tempReal = src[inIdx++];
-        periodSub += tempReal;
-        periodSub -= trailingValue;
-        periodSum += tempReal * n;
-        // HKU_INFO("{}: {}, {} ", inIdx - 1, periodSum, divider);
-        trailingValue = src[trailingIdx++];
-        dst[outIdx++] = periodSum / divider;
-        periodSum -= periodSub;
+    dst[m_discard] = sum / divider;
+
+    size_t trailingIdx = ind.discard();
+    for (size_t i = m_discard + 1; i < total; i++) {
+        value_t tmp = src[i];
+        sum -= subsum;
+        subsum += tmp;
+        subsum -= src[trailingIdx++];
+        sum += tmp * n;
+        dst[i] = sum / divider;
     }
 }
 
 void IWma::_dyn_run_one_step(const Indicator& ind, size_t curPos, size_t step) {
+    if (step < 1) {
+        _set(Null<value_t>(), curPos);
+        return;
+    }
+
+    if (step == 1) {
+        _set(ind[curPos], curPos);
+        return;
+    }
+
     size_t start = _get_step_start(curPos, step, ind.discard());
-    price_t sum = 0.0;
-    for (size_t i = start; i <= curPos; i++) {
-        sum += ind[i];
+    if (curPos + 1 - start < step) {
+        _set(Null<value_t>(), curPos);
+        return;
+    }
+
+    value_t sum = 0.0;
+    size_t n = 1;
+    for (size_t i = start; i <= curPos; i++, n++) {
+        sum += (ind[i] * n);
     }
-    _set(sum / (curPos - start + 1), curPos);
+    _set(sum / (step * (step + 1) / 2.), curPos);
 }
 
 Indicator HKU_API WMA(int n) {
@@ -86,10 +93,10 @@ Indicator HKU_API WMA(int n) {
     return Indicator(p);
 }
 
-// Indicator HKU_API MA(const IndParam& n) {
-//     IndicatorImpPtr p = make_shared<IWma>();
-//     p->setIndParam("n", n);
-//     return Indicator(p);
-// }
+Indicator HKU_API WMA(const IndParam& n) {
+    IndicatorImpPtr p = make_shared<IWma>();
+    p->setIndParam("n", n);
+    return Indicator(p);
+}
 
 } /* namespace hku */

hikyuu_cpp/unit_test/hikyuu/indicator/test_Indicator.cpp

@@ -17,6 +17,19 @@
  * @{
  */
 
+/** @par 检测点 */
+TEST_CASE("test_indicator_other") {
+    double dx = Null<double>();
+    size_t ix = size_t(dx);
+    // 随机值
+    HKU_INFO("double nan to size_t: {}", ix);
+
+    float fx = Null<float>();
+    ix = size_t(fx);
+    // 随机值
+    HKU_INFO("float nan to size_t: {}", ix);
+}
+
 /** @par 检测点 */
 TEST_CASE("test_indicator_alike") {
     /** @arg 空 indicator 比较 */

hikyuu_cpp/unit_test/hikyuu/indicator/test_WMA.cpp

@@ -78,15 +78,14 @@ TEST_CASE("test_WMA") {
     CHECK_EQ(result[9], doctest::Approx(6.).epsilon(0.0001));
 }
 
-#if 0
 /** @par 检测点 */
-TEST_CASE("test_SUM_dyn") {
+TEST_CASE("test_WMA_dyn") {
     Stock stock = StockManager::instance().getStock("sh000001");
     KData kdata = stock.getKData(KQuery(-30));
     // KData kdata = stock.getKData(KQuery(0, Null<size_t>(), KQuery::MIN));
     Indicator c = CLOSE(kdata);
-    Indicator expect = SUM(c, 10);
-    Indicator result = SUM(c, CVAL(c, 10));
+    Indicator expect = WMA(c, 10);
+    Indicator result = WMA(c, CVAL(c, 10));
     CHECK_EQ(expect.size(), result.size());
     CHECK_EQ(expect.discard(), result.discard());
     for (size_t i = 0; i < result.discard(); i++) {
@@ -96,18 +95,7 @@ TEST_CASE("test_SUM_dyn") {
         CHECK_EQ(expect[i], doctest::Approx(result[i]));
     }
 
-    result = SUM(c, IndParam(CVAL(c, 10)));
-    CHECK_EQ(expect.size(), result.size());
-    CHECK_EQ(expect.discard(), result.discard());
-    for (size_t i = 0; i < result.discard(); i++) {
-        CHECK_UNARY(std::isnan(result[i]));
-    }
-    for (size_t i = expect.discard(); i < expect.size(); i++) {
-        CHECK_EQ(expect[i], doctest::Approx(result[i]));
-    }
-
-    expect = SUM(c, 0);
-    result = SUM(c, CVAL(c, 0));
+    result = WMA(c, IndParam(CVAL(c, 10)));
     CHECK_EQ(expect.size(), result.size());
     CHECK_EQ(expect.discard(), result.discard());
     for (size_t i = 0; i < result.discard(); i++) {
@@ -117,7 +105,6 @@ TEST_CASE("test_SUM_dyn") {
         CHECK_EQ(expect[i], doctest::Approx(result[i]));
     }
 }
-#endif
 
 //-----------------------------------------------------------------------------
 // test export

hikyuu_pywrap/indicator/_build_in.cpp

@@ -97,6 +97,12 @@ Indicator (*MA_3)(const Indicator&, const IndParam&) = MA;
 Indicator (*MA_4)(const Indicator&, const Indicator&) = MA;
 Indicator (*MA_5)(const Indicator&, int) = MA;
 
+Indicator (*WMA_1)(int) = WMA;
+Indicator (*WMA_2)(const IndParam&) = WMA;
+Indicator (*WMA_3)(const Indicator&, const IndParam&) = WMA;
+Indicator (*WMA_4)(const Indicator&, const Indicator&) = WMA;
+Indicator (*WMA_5)(const Indicator&, int) = WMA;
+
 Indicator (*SMA_1)(int, double) = SMA;
 Indicator (*SMA_2)(int, const IndParam&) = SMA;
 Indicator (*SMA_3)(const IndParam&, double) = SMA;
@@ -729,6 +735,18 @@ void export_Indicator_build_in(py::module& m) {
     :param int|Indicator|IndParam n: 时间窗口
     :rtype: Indicator)");
 
+    m.def("WMA", WMA_1, py::arg("n") = 22);
+    m.def("WMA", WMA_2, py::arg("n"));
+    m.def("WMA", WMA_3, py::arg("data"), py::arg("n"));
+    m.def("WMA", WMA_4, py::arg("data"), py::arg("n"));
+    m.def("WMA", WMA_5, py::arg("data"), py::arg("n") = 22, R"(WMA([data, n=22])
+
+    加权移动平均，算法:Yn=(1*X1+2*X2+...+n*Xn)/(1+2+...+n)
+
+    :param Indicator data: 输入数据
+    :param int|Indicator|IndParam n: 时间窗口
+    :rtype: Indicator)");
+
     m.def("AMA", AMA_1, py::arg("n") = 10, py::arg("fast_n") = 2, py::arg("slow_n") = 30);
     m.def("AMA", AMA_2, py::arg("n"), py::arg("fast_n"), py::arg("slow_n"));
     m.def("AMA", AMA_4, py::arg("data"), py::arg("n"), py::arg("fast_n"), py::arg("slow_n"));
@@ -1935,7 +1953,4 @@ void export_Indicator_build_in(py::module& m) {
     :param Indicator ind: 指定指标
     :param int mode: 计算类型:0-累加,1-平均数,2-最大值,3-最小值.
     :rtype: Indicator)");
-
-    m.def("WMA", py::overload_cast<int>(WMA), py::arg("n"));
-    m.def("WMA", py::overload_cast<const Indicator&, int>(WMA), py::arg("ind"), py::arg("n"));
 }