add macosx support

.github/workflows/macos_arm64.yml → .github/workflows/macos.yml

@@ -15,7 +15,7 @@ jobs:
       matrix:
         os: [macos-14]
         arch: [arm64]
-        kind: [shared]
+        kind: [static]
 
     runs-on: ${{ matrix.os }}
 
@@ -46,8 +46,16 @@ jobs:
 
       - name: config
         run: |
-          xmake f -c -k ${{ matrix.kind }} -y -vD --mysql=n --hdf5=n
+          xmake f -c -k ${{ matrix.kind }} -y -vD --feedback=n
 
       - name: build
         run: |
-          xmake -b core
+          xmake -b core          
+
+      - name: build
+        run: |
+          xmake -b small-test
+
+      - name: test
+        run: |
+          xmake r small-test

hikyuu/draw/drawplot/matplotlib_draw.py

@@ -27,7 +27,8 @@ def set_mpl_params():
     rcParams['font.family'] = 'sans-serif'
     rcParams['axes.unicode_minus'] = False
 
-    expected_fonts = ['Microsoft YaHei', 'SimSun', 'SimHei', 'Source Han Sans CN', 'Noto Sans CJK JP']
+    expected_fonts = ['Microsoft YaHei', 'SimSun', 'SimHei',
+                      'Source Han Sans CN', 'Noto Sans CJK JP', 'Arial Unicode MS']
     current_fonts = matplotlib.rcParams['font.sans-serif']
     for font in expected_fonts:
         if font in current_fonts:

hikyuu/test/Datetime.py

@@ -2,10 +2,10 @@
 # -*- coding: utf8 -*-
 # cp936
 
-#===============================================================================
+# ===============================================================================
 # 作者：fasiondog
 # 历史：1）20120927, Added by fasiondog
-#===============================================================================
+# ===============================================================================
 
 import unittest
 
@@ -24,16 +24,16 @@ def test_Datetime(self):
         self.assertEqual(Datetime(140001010000), Datetime.min())
         self.assertEqual(Datetime(999912310000), Datetime.max())
 
-        self.assert_(d == Datetime(201209272301))
-        self.assert_(d != Datetime(200101010000))
-        self.assert_(d >= Datetime(201209272301))
-        self.assert_(d >= Datetime(201209272259))
-        self.assert_(d <= Datetime(201209272301))
-        self.assert_(d <= Datetime(201209272302))
-        self.assert_(not (d > Datetime(201209272301)))
-        self.assert_(d > Datetime(201209272259))
-        self.assert_(not (d < Datetime(201209272301)))
-        self.assert_(d < Datetime(201209272302))
+        self.assertEqual(d, Datetime(201209272301))
+        self.assertNotEqual(d, Datetime(200101010000))
+        self.assertGreaterEqual(d, Datetime(201209272301))
+        self.assertTrue(d >= Datetime(201209272259))
+        self.assertTrue(d <= Datetime(201209272301))
+        self.assertTrue(d <= Datetime(201209272302))
+        self.assertTrue(not (d > Datetime(201209272301)))
+        self.assertTrue(d > Datetime(201209272259))
+        self.assertTrue(not (d < Datetime(201209272301)))
+        self.assertTrue(d < Datetime(201209272302))
 
         d = Datetime(200101010159)
         self.assertEqual(str(d), "2001-01-01 01:59:00")

hikyuu/test/Indicator.py

@@ -48,21 +48,21 @@ def test_PythonIndicator(self):
         self.assertEqual(m.name, "AddIndicator")
         self.assertEqual(len(m), 4)
         self.assertEqual(m.empty(), False)
-        self.assert_(abs(m[0] - 1) < 0.0001)
-        self.assert_(abs(m[1] - 2) < 0.0001)
-        self.assert_(abs(m[2] - 3) < 0.0001)
-        self.assert_(abs(m[3] - 4) < 0.0001)
+        self.assertTrue(abs(m[0] - 1) < 0.0001)
+        self.assertTrue(abs(m[1] - 2) < 0.0001)
+        self.assertTrue(abs(m[2] - 3) < 0.0001)
+        self.assertTrue(abs(m[3] - 4) < 0.0001)
 
         b = toPriceList([1, 2, 3, 4])
         x = PRICELIST(b)
         m.get_imp()._calculate(m)
         m = m(x)
         self.assertEqual(len(m), 4)
         self.assertEqual(m.empty(), False)
-        self.assert_(abs(m[0] - 2) < 0.0001)
-        self.assert_(abs(m[1] - 3) < 0.0001)
-        self.assert_(abs(m[2] - 4) < 0.0001)
-        self.assert_(abs(m[3] - 5) < 0.0001)
+        self.assertTrue(abs(m[0] - 2) < 0.0001)
+        self.assertTrue(abs(m[1] - 3) < 0.0001)
+        self.assertTrue(abs(m[2] - 4) < 0.0001)
+        self.assertTrue(abs(m[3] - 5) < 0.0001)
 
     def test_operator(self):
         a = toPriceList([0, 1, 2, 3, 5])
@@ -76,16 +76,16 @@ def test_operator(self):
         self.assertEqual(a[3], 7)
 
         a = x1 + 1.1
-        self.assert_(abs(a[0] - 1.1) < 0.0001)
-        self.assert_(abs(a[1] - 2.1) < 0.0001)
-        self.assert_(abs(a[2] - 3.1) < 0.0001)
-        self.assert_(abs(a[3] - 4.1) < 0.0001)
+        self.assertTrue(abs(a[0] - 1.1) < 0.0001)
+        self.assertTrue(abs(a[1] - 2.1) < 0.0001)
+        self.assertTrue(abs(a[2] - 3.1) < 0.0001)
+        self.assertTrue(abs(a[3] - 4.1) < 0.0001)
 
         a = 2.1 + x1
-        self.assert_(abs(a[0] - 2.1) < 0.0001)
-        self.assert_(abs(a[1] - 3.1) < 0.0001)
-        self.assert_(abs(a[2] - 4.1) < 0.0001)
-        self.assert_(abs(a[3] - 5.1) < 0.0001)
+        self.assertTrue(abs(a[0] - 2.1) < 0.0001)
+        self.assertTrue(abs(a[1] - 3.1) < 0.0001)
+        self.assertTrue(abs(a[2] - 4.1) < 0.0001)
+        self.assertTrue(abs(a[3] - 5.1) < 0.0001)
 
         a = x2 - x1
         self.assertEqual(a[0], 1)
@@ -124,10 +124,10 @@ def test_operator(self):
         self.assertEqual(a[3], 6)
 
         a = x2 / x1
-        self.assert_(isinf(a[0]))
+        self.assertTrue(isinf(a[0]))
         self.assertEqual(a[1], 2)
         self.assertEqual(a[2], 1.5)
-        self.assert_(abs(a[3] - 4.0 / 3.0) < 0.0001)
+        self.assertTrue(abs(a[3] - 4.0 / 3.0) < 0.0001)
 
         a = x1 / 0.5
         self.assertEqual(a[0], 0)
@@ -136,10 +136,10 @@ def test_operator(self):
         self.assertEqual(a[3], 6)
 
         a = 2. / x1
-        self.assert_(isinf(a[0]))
+        self.assertTrue(isinf(a[0]))
         self.assertEqual(a[1], 2.0)
         self.assertEqual(a[2], 1.)
-        self.assert_(abs(a[3] - 2.0/3.0) < 0.0001)
+        self.assertTrue(abs(a[3] - 2.0/3.0) < 0.0001)
 
         a = x1 > x2
         self.assertEqual(a[0], 0 > 1)
@@ -180,30 +180,30 @@ def test_IKDATA(self):
         self.assertEqual(a.empty(), False)
         self.assertEqual(v.empty(), False)
 
-        self.assert_(abs(o[0] - 96.05) < 0.0001)
-        self.assert_(abs(h[0] - 99.98) < 0.0001)
-        self.assert_(abs(l[0] - 95.79) < 0.0001)
-        self.assert_(abs(c[0] - 99.98) < 0.0001)
-        self.assert_(abs(a[0] - 49.4) < 0.0001)
-        self.assert_(abs(v[0] - 1260) < 0.0001)
+        self.assertTrue(abs(o[0] - 96.05) < 0.0001)
+        self.assertTrue(abs(h[0] - 99.98) < 0.0001)
+        self.assertTrue(abs(l[0] - 95.79) < 0.0001)
+        self.assertTrue(abs(c[0] - 99.98) < 0.0001)
+        self.assertTrue(abs(a[0] - 49.4) < 0.0001)
+        self.assertTrue(abs(v[0] - 1260) < 0.0001)
 
-        self.assert_(abs(o[1] - 104.3) < 0.0001)
-        self.assert_(abs(h[1] - 104.39) < 0.0001)
-        self.assert_(abs(l[1] - 99.98) < 0.0001)
-        self.assert_(abs(c[1] - 104.39) < 0.0001)
-        self.assert_(abs(a[1] - 8.4) < 0.0001)
-        self.assert_(abs(v[1] - 197) < 0.0001)
+        self.assertTrue(abs(o[1] - 104.3) < 0.0001)
+        self.assertTrue(abs(h[1] - 104.39) < 0.0001)
+        self.assertTrue(abs(l[1] - 99.98) < 0.0001)
+        self.assertTrue(abs(c[1] - 104.39) < 0.0001)
+        self.assertTrue(abs(a[1] - 8.4) < 0.0001)
+        self.assertTrue(abs(v[1] - 197) < 0.0001)
 
     def test_MA(self):
         a = toPriceList([0, 1, 2, 3])
         x = PRICELIST(a)
         m = MA(x, 2)
         self.assertEqual(len(m), 4)
         self.assertEqual(m.discard, 0)
-        self.assert_(abs(m[0] - 0.0) < 0.0001)
-        self.assert_(abs(m[1] - 0.5) < 0.0001)
-        self.assert_(abs(m[2] - 1.5) < 0.0001)
-        self.assert_(abs(m[3] - 2.5) < 0.0001)
+        self.assertTrue(abs(m[0] - 0.0) < 0.0001)
+        self.assertTrue(abs(m[1] - 0.5) < 0.0001)
+        self.assertTrue(abs(m[2] - 1.5) < 0.0001)
+        self.assertTrue(abs(m[3] - 2.5) < 0.0001)
 
     def test_pickle(self):
         if not constant.pickle_support:

hikyuu/test/KData.py

@@ -2,10 +2,10 @@
 # -*- coding: utf8 -*-
 # gb18030
 
-#===============================================================================
+# ===============================================================================
 # 作者：fasiondog
 # 历史：1）20130220, Added by fasiondog
-#===============================================================================
+# ===============================================================================
 
 import unittest
 
@@ -33,14 +33,14 @@ def test_kdata(self):
         self.assertEqual(k.end_pos, 10)
         self.assertEqual(k.last_pos, 9)
         self.assertEqual(k[0].datetime, Datetime(199012190000))
-        self.assert_(abs(k[0].open - 96.05) < 0.0001)
-        self.assert_(abs(k[0].high - 99.980) < 0.0001)
-        self.assert_(abs(k[0].low - 95.79) < 0.0001)
-        self.assert_(abs(k[0].close - 99.98) < 0.0001)
-        self.assert_(abs(k[0].amount - 49.4) < 0.0001)
-        self.assert_(abs(k[0].volume - 1260) < 0.0001)
-        self.assert_(abs(k[1].open - 104.3) < 0.0001)
-        self.assert_(abs(k[9].open - 127.61) < 0.0001)
+        self.assertTrue(abs(k[0].open - 96.05) < 0.0001)
+        self.assertTrue(abs(k[0].high - 99.980) < 0.0001)
+        self.assertTrue(abs(k[0].low - 95.79) < 0.0001)
+        self.assertTrue(abs(k[0].close - 99.98) < 0.0001)
+        self.assertTrue(abs(k[0].amount - 49.4) < 0.0001)
+        self.assertTrue(abs(k[0].volume - 1260) < 0.0001)
+        self.assertTrue(abs(k[1].open - 104.3) < 0.0001)
+        self.assertTrue(abs(k[9].open - 127.61) < 0.0001)
 
     def test_pickle(self):
         if not constant.pickle_support:
@@ -61,4 +61,4 @@ def test_pickle(self):
 
 
 def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(KDataTest)
+    return unittest.TestLoader().loadTestsFromTestCase(KDataTest)

hikyuu/test/Stock.py

@@ -36,12 +36,12 @@ def test_stock(self):
 
         s1 = sm['sh000001']
         s2 = sm['sh000001']
-        self.assert_(s1 == s2)
-        self.assert_(not (s1 != s2))
+        self.assertTrue(s1 == s2)
+        self.assertTrue(not (s1 != s2))
 
         s2 = sm['sz000001']
-        self.assert_(not (s1 == s2))
-        self.assert_(s1 != s2)
+        self.assertTrue(not (s1 == s2))
+        self.assertTrue(s1 != s2)
 
     def test_pickle(self):
         if not constant.pickle_support:
@@ -79,7 +79,7 @@ def test_external_stock(self):
 
         self.assertEqual(stk.valid, False)
         stk.valid = True
-        self.assert_(stk.valid)
+        self.assertTrue(stk.valid)
 
         self.assertNotEqual(stk.type, constant.STOCKTYPE_A)
         stk.type = constant.STOCKTYPE_A
@@ -113,14 +113,14 @@ def test_external_stock(self):
         self.assertEqual(len(k), 1)
         self.assertEqual(k[0], KRecord(Datetime(20010101), 5.0, 9.0, 4.0, 6.5, 1000.0, 100000.0))
 
-        self.assert_(stk not in sm)
+        self.assertTrue(stk not in sm)
         sm.add_stock(stk)
-        self.assert_(stk in sm)
+        self.assertTrue(stk in sm)
         stk2 = sm['ab000001']
-        self.assert_(not stk2.is_null())
-        self.assert_(stk2, stk)
+        self.assertTrue(not stk2.is_null())
+        self.assertTrue(stk2, stk)
         sm.remove_stock("ab000001")
-        self.assert_(stk not in sm)
+        self.assertTrue(stk not in sm)
 
 
 def suite():

hikyuu_cpp/hikyuu/DataType.h

@@ -17,6 +17,7 @@
 #define NOMINMAX
 #endif
 
+#include "config.h"
 #include <boost/config.hpp>
 
 #include <stdio.h>
@@ -28,8 +29,9 @@
 // #include <vector>
 #include <map>
 #include <unordered_map>
+#include <set>
+#include <unordered_set>
 
-#include "config.h"
 #include "utilities/Log.h"
 #include "utilities/osdef.h"
 #include "utilities/cppdef.h"

hikyuu_cpp/hikyuu/indicator/imp/IRecover.cpp

@@ -38,7 +38,7 @@ void IRecover::_checkParam(const string& name) const {
 }
 
 void IRecover::checkInputIndicator(const Indicator& ind) {
-    HKU_CHECK(typeid(*(ind.getImp())) == typeid(IKData),
+    HKU_CHECK(dynamic_cast<IKData*>(ind.getImp().get()) != nullptr,
               "Only the following indicators are accepted: OPEN|HIGH|CLOSE|LOW");
     string part = ind.getParam<string>("kpart");
     HKU_CHECK(part == "CLOSE" || part == "OPEN" || part == "HIGH" || part == "LOW",

hikyuu_cpp/hikyuu/trade_manage/OrderBrokerBase.h

@@ -147,8 +147,33 @@ class HKU_API OrderBrokerBase {
 
 protected:
     string m_name;
+
+//============================================
+// 序列化支持
+//============================================
+#if HKU_SUPPORT_SERIALIZATION
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void save(Archive& ar, const unsigned int version) const {
+        ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+#endif /* HKU_SUPPORT_SERIALIZATION */
 };
 
+#if HKU_SUPPORT_SERIALIZATION
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(OrderBrokerBase)
+#endif
+
 /**
  * 客户程序应使用此类型进行实际操作
  * @ingroup OrderBroker

hikyuu_cpp/hikyuu/trade_manage/TradeManagerBase.h

@@ -737,10 +737,6 @@ class HKU_API TradeManagerBase {
 #endif /* HKU_SUPPORT_SERIALIZATION */
 };
 
-#if HKU_SUPPORT_SERIALIZATION
-BOOST_SERIALIZATION_ASSUME_ABSTRACT(TradeManagerBase)
-#endif
-
 inline void TradeManagerBase::baseCheckParam(const string& name) const {
     if ("precision" == name) {
         int precision = getParam<int>("precision");

hikyuu_cpp/hikyuu/trade_sys/multifactor/imp/ICIRMultiFactor.cpp

@@ -106,7 +106,7 @@ IndicatorList ICIRMultiFactor::_calculate(const vector<IndicatorList>& all_stk_i
 
     return all_factors;
 #else
-    return parallel_for_index(0, stk_count, [&, this, discard, ind_count, days_total](size_t si) {
+    return parallel_for_index(0, stk_count, [&, discard, ind_count, days_total](size_t si) {
         PriceList new_values(days_total, 0.0);
         PriceList sum_weight(days_total, 0.0);
         for (size_t di = 0; di < discard; di++) {

hikyuu_cpp/hikyuu/trade_sys/multifactor/imp/ICMultiFactor.cpp

@@ -106,7 +106,7 @@ IndicatorList ICMultiFactor::_calculate(const vector<IndicatorList>& all_stk_ind
     return all_factors;
 
 #else
-    return parallel_for_index(0, stk_count, [&, this, ind_count, days_total, discard](size_t si) {
+    return parallel_for_index(0, stk_count, [&, ind_count, days_total, discard](size_t si) {
         PriceList new_values(days_total, 0.0);
         PriceList sum_weight(days_total, 0.0);
         for (size_t di = 0; di < discard; di++) {

hikyuu_cpp/hikyuu/trade_sys/selector/imp/optimal/PerformanceOptimalSelector.h

@@ -22,7 +22,7 @@ class PerformanceOptimalSelector : public OptimalSelectorBase {
     virtual void _checkParam(const string& name) const override;
     virtual void calculate(const SystemList& pf_realSysList, const KQuery& query) override;
 
-    virtual SystemWeightList getSelected(Datetime date);
+    virtual SystemWeightList getSelected(Datetime date) override;
     virtual SelectorPtr _clone() override;
     virtual void _reset() override;