hikyuu 2.5.2__py3-none-win_amd64.whl → 2.5.3__py3-none-win_amd64.whl

hikyuu/include/hikyuu/trade_sys/environment/imp/logic/SubEnvironment.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/environment/EnvironmentBase.h"
+
+namespace hku {
+
+class HKU_API SubEnvironment : public EnvironmentBase {
+public:
+    SubEnvironment();
+    SubEnvironment(const EnvironmentPtr& ev1, const EnvironmentPtr& ev2);
+    virtual ~SubEnvironment();
+
+    virtual void _calculate() override;
+    virtual void _reset() override;
+    virtual EnvironmentPtr _clone() override;
+
+private:
+    EnvironmentPtr m_ev1;
+    EnvironmentPtr m_ev2;
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(EnvironmentBase);
+        ar& BOOST_SERIALIZATION_NVP(m_ev1);
+        ar& BOOST_SERIALIZATION_NVP(m_ev2);
+    }
+#endif
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/environment/imp/logic/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/trade_sys/portfolio/Portfolio.h

@@ -165,10 +165,6 @@ private:
 #endif /* HKU_SUPPORT_SERIALIZATION */
 };
 
-#if HKU_SUPPORT_SERIALIZATION
-BOOST_SERIALIZATION_ASSUME_ABSTRACT(Portfolio)
-#endif
-
 #define PORTFOLIO_IMP(classname)                   \
 public:                                            \
     virtual PortfolioPtr _clone() const override { \

hikyuu/include/hikyuu/trade_sys/signal/crt/SG_Logic.h

@@ -26,13 +26,8 @@ HKU_API SignalPtr operator-(double value, const SignalPtr& sg);
 HKU_API SignalPtr operator*(double value, const SignalPtr& sg);
 HKU_API SignalPtr operator/(double value, const SignalPtr& sg);
 
-inline SignalPtr operator&(const SignalPtr& sg1, const SignalPtr& sg2) {
-    return sg1 * sg2;
-}
-
-inline SignalPtr operator|(const SignalPtr& sg1, const SignalPtr& sg2) {
-    return sg1 + sg2;
-}
+HKU_API SignalPtr operator&(const SignalPtr& sg1, const SignalPtr& sg2);
+HKU_API SignalPtr operator|(const SignalPtr& sg1, const SignalPtr& sg2);
 
 //------------------------------------------------------------------
 // 由于 SG 的 alternate 默认为 True, 在使用如  "sg1 + sg2 + sg3"
@@ -45,22 +40,88 @@ inline SignalPtr SG_Add(const SignalPtr& sg1, const SignalPtr& sg2, bool alterna
     return sg;
 }
 
+inline SignalPtr SG_Add(const vector<SignalPtr> sg_list, bool alternate) {
+    HKU_CHECK(sg_list.size() >= 2, "sg_list is empty!");
+    SignalPtr tmp = SG_Add(sg_list[0], sg_list[1], alternate);
+    for (size_t i = 2; i < sg_list.size(); ++i) {
+        tmp = SG_Add(tmp, sg_list[i], alternate);
+    }
+    return tmp;
+}
+
 inline SignalPtr SG_Sub(const SignalPtr& sg1, const SignalPtr& sg2, bool alternate) {
     auto sg = sg1 - sg2;
     sg->setParam<bool>("alternate", alternate);
     return sg;
 }
 
+inline SignalPtr SG_Sub(const vector<SignalPtr> sg_list, bool alternate) {
+    HKU_CHECK(sg_list.size() >= 2, "sg_list is empty!");
+    SignalPtr tmp = SG_Sub(sg_list[0], sg_list[1], alternate);
+    for (size_t i = 2; i < sg_list.size(); ++i) {
+        tmp = SG_Sub(tmp, sg_list[i], alternate);
+    }
+    return tmp;
+}
+
 inline SignalPtr SG_Mul(const SignalPtr& sg1, const SignalPtr& sg2, bool alternate) {
     auto sg = sg1 * sg2;
     sg->setParam<bool>("alternate", alternate);
     return sg;
 }
 
+inline SignalPtr SG_Mul(const vector<SignalPtr> sg_list, bool alternate) {
+    HKU_CHECK(sg_list.size() >= 2, "sg_list is empty!");
+    SignalPtr tmp = SG_Mul(sg_list[0], sg_list[1], alternate);
+    for (size_t i = 2; i < sg_list.size(); ++i) {
+        tmp = SG_Mul(tmp, sg_list[i], alternate);
+    }
+    return tmp;
+}
+
 inline SignalPtr SG_Div(const SignalPtr& sg1, const SignalPtr& sg2, bool alternate) {
     auto sg = sg1 / sg2;
     sg->setParam<bool>("alternate", alternate);
     return sg;
 }
 
+inline SignalPtr SG_Div(const vector<SignalPtr> sg_list, bool alternate) {
+    HKU_CHECK(sg_list.size() >= 2, "sg_list is empty!");
+    SignalPtr tmp = SG_Div(sg_list[0], sg_list[1], alternate);
+    for (size_t i = 2; i < sg_list.size(); ++i) {
+        tmp = SG_Div(tmp, sg_list[i], alternate);
+    }
+    return tmp;
+}
+
+inline SignalPtr SG_And(const SignalPtr& sg1, const SignalPtr& sg2, bool alternate) {
+    auto sg = sg1 & sg2;
+    sg->setParam<bool>("alternate", alternate);
+    return sg;
+}
+
+inline SignalPtr SG_And(const vector<SignalPtr> sg_list, bool alternate) {
+    HKU_CHECK(sg_list.size() >= 2, "sg_list is empty!");
+    SignalPtr tmp = SG_And(sg_list[0], sg_list[1], alternate);
+    for (size_t i = 2; i < sg_list.size(); ++i) {
+        tmp = SG_And(tmp, sg_list[i], alternate);
+    }
+    return tmp;
+}
+
+inline SignalPtr SG_Or(const SignalPtr& sg1, const SignalPtr& sg2, bool alternate) {
+    auto sg = sg1 | sg2;
+    sg->setParam<bool>("alternate", alternate);
+    return sg;
+}
+
+inline SignalPtr SG_Or(const vector<SignalPtr> sg_list, bool alternate) {
+    HKU_CHECK(sg_list.size() >= 2, "sg_list is empty!");
+    SignalPtr tmp = SG_Or(sg_list[0], sg_list[1], alternate);
+    for (size_t i = 2; i < sg_list.size(); ++i) {
+        tmp = SG_Or(tmp, sg_list[i], alternate);
+    }
+    return tmp;
+}
+
 }  // namespace hku

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/AndSignal.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSignal.h"
+
+namespace hku {
+
+class AndSignal : public OperatorSignal {
+    OPERATOR_SIGNAL_IMP(AndSignal, "SG_And")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/OperatorSignal.h

@@ -60,6 +60,7 @@ private:                                                         \
     friend class boost::serialization::access;                   \
     template <class Archive>                                     \
     void serialize(Archive& ar, const unsigned int version) {    \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SignalBase);     \
         ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(OperatorSignal); \
     }
 #else

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/OperatorValueSignal.h

@@ -58,6 +58,7 @@ private:                                                              \
     friend class boost::serialization::access;                        \
     template <class Archive>                                          \
     void serialize(Archive& ar, const unsigned int version) {         \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(SignalBase);          \
         ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(OperatorValueSignal); \
     }
 #else

hikyuu/include/hikyuu/trade_sys/signal/imp/logic/OrSignal.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-02-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OperatorSignal.h"
+
+namespace hku {
+
+class OrSignal : public OperatorSignal {
+    OPERATOR_SIGNAL_IMP(OrSignal, "SG_Or")
+    OPERATOR_SIGNAL_NO_PRIVATE_MEMBER_SERIALIZATION
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/version.h

@@ -12,13 +12,13 @@
 #define HKU_VERSION_H
 
 // clang-format off
-#define HKU_VERSION "2.5.2"
+#define HKU_VERSION "2.5.3"
 #define HKU_VERSION_MAJOR 2
 #define HKU_VERSION_MINOR 5
-#define HKU_VERSION_ALTER 2
-#define HKU_VERSION_BUILD 202502241314
+#define HKU_VERSION_ALTER 3
+#define HKU_VERSION_BUILD 202503071538
 #define HKU_VERSION_MODE "RELEASE"
-#define HKU_VERSION_GIT "2.5.2 release.5ea8ba65 (RELEASE)"
+#define HKU_VERSION_GIT "2.5.3 release.204e0fc6 (RELEASE)"
 // clang-format on
 
 #endif /* HKU_VERSION_H */

hikyuu/indicator/indicator.py

@@ -156,3 +156,4 @@ VOL = C_VOL()
 VALUE = PRICELIST
 CAPITAL = LIUTONGPAN
 CONST = LASTVALUE
+STD = STDEV