update

hikyuu_cpp/hikyuu/trade_sys/selector/crt/SE_Optimal.h

@@ -11,8 +11,16 @@
 
 namespace hku {
 
-SEPtr HKU_API SE_Optimal();
-
+/**
+ * 测试账户资产最大寻优选择器
+ * @return SEPtr
+ */
 SEPtr HKU_API SE_MaxFundsOptimal();
 
-}
+/**
+ * 使用 Performance 统计结果进行寻优的选择器
+ * @return SEPtr
+ */
+SEPtr HKU_API SE_PerformanceOptimal();
+
+}  // namespace hku

hikyuu_cpp/hikyuu/trade_sys/selector/imp/optimal/OptimalSelector.cpp → hikyuu_cpp/hikyuu/trade_sys/selector/imp/optimal/OptimalPerformanceSelector.cpp

@@ -6,20 +6,21 @@
  */
 
 #include "hikyuu/trade_manage/Performance.h"
-#include "OptimalSelector.h"
+#include "OptimalPerformanceSelector.h"
 
 #if HKU_SUPPORT_SERIALIZATION
-BOOST_CLASS_EXPORT(hku::OptimalSelector)
+BOOST_CLASS_EXPORT(hku::OptimalPerformanceSelector)
 #endif
 
 namespace hku {
 
-OptimalSelector::OptimalSelector() : OptimalSelectorBase("SE_Optimal") {
+OptimalPerformanceSelector::OptimalPerformanceSelector()
+: OptimalSelectorBase("SE_PerformanceOptimal") {
     setParam<string>("key", "帐户平均年收益率%");
     setParam<int>("mode", 0);  // 0 取最高值，1 取最低值
 }
 
-void OptimalSelector::_checkParam(const string& name) const {
+void OptimalPerformanceSelector::_checkParam(const string& name) const {
     OptimalSelectorBase::_checkParam(name);
     if ("mode" == name) {
         int mode = getParam<int>(name);
@@ -30,7 +31,7 @@ void OptimalSelector::_checkParam(const string& name) const {
     }
 }
 
-SystemWeightList OptimalSelector::getSelected(Datetime date) {
+SystemWeightList OptimalPerformanceSelector::getSelected(Datetime date) {
     SystemWeightList ret;
     auto iter = this->m_sys_dict.find(date);
     if (iter != this->m_sys_dict.end()) {
@@ -39,16 +40,16 @@ SystemWeightList OptimalSelector::getSelected(Datetime date) {
     return ret;
 }
 
-SelectorPtr OptimalSelector::_clone() {
-    return std::make_shared<OptimalSelector>();
+SelectorPtr OptimalPerformanceSelector::_clone() {
+    return std::make_shared<OptimalPerformanceSelector>();
 }
 
-void OptimalSelector::_reset() {
+void OptimalPerformanceSelector::_reset() {
     OptimalSelectorBase::_reset();
     m_sys_dict.clear();
 }
 
-void OptimalSelector::calculate(const SystemList& pf_realSysList, const KQuery& query) {
+void OptimalPerformanceSelector::calculate(const SystemList& pf_realSysList, const KQuery& query) {
     SPEND_TIME(OptimalSelector_calculate);
     HKU_IF_RETURN(m_calculated && m_query == query, void());
 
@@ -98,9 +99,9 @@ void OptimalSelector::calculate(const SystemList& pf_realSysList, const KQuery&
     m_calculated = true;
 }
 
-void OptimalSelector::_calculate_single(const vector<std::pair<size_t, size_t>>& train_ranges,
-                                        const DatetimeList& dates, const string& key, int mode,
-                                        size_t test_len, bool trace) {
+void OptimalPerformanceSelector::_calculate_single(
+  const vector<std::pair<size_t, size_t>>& train_ranges, const DatetimeList& dates,
+  const string& key, int mode, size_t test_len, bool trace) {
     // SPEND_TIME(OptimalSelector_calculate_single);
     size_t dates_len = dates.size();
     Performance per;
@@ -167,9 +168,9 @@ void OptimalSelector::_calculate_single(const vector<std::pair<size_t, size_t>>&
     }
 }
 
-void OptimalSelector::_calculate_parallel(const vector<std::pair<size_t, size_t>>& train_ranges,
-                                          const DatetimeList& dates, const string& key, int mode,
-                                          size_t test_len, bool trace) {
+void OptimalPerformanceSelector::_calculate_parallel(
+  const vector<std::pair<size_t, size_t>>& train_ranges, const DatetimeList& dates,
+  const string& key, int mode, size_t test_len, bool trace) {
     // SPEND_TIME(OptimalSelector_calculate_parallel);
     auto sys_list = parallel_for_index(
       0, train_ranges.size(),
@@ -245,8 +246,8 @@ void OptimalSelector::_calculate_parallel(const vector<std::pair<size_t, size_t>
     }
 }
 
-SEPtr HKU_API SE_Optimal() {
-    return make_shared<OptimalSelector>();
+SEPtr HKU_API SE_PerformanceOptimal() {
+    return make_shared<OptimalPerformanceSelector>();
 }
 
 }  // namespace hku

hikyuu_cpp/hikyuu/trade_sys/selector/imp/optimal/OptimalSelector.h → hikyuu_cpp/hikyuu/trade_sys/selector/imp/optimal/OptimalPerformanceSelector.h

@@ -11,13 +11,13 @@
 
 namespace hku {
 
-class OptimalSelector : public OptimalSelectorBase {
+class OptimalPerformanceSelector : public OptimalSelectorBase {
     CLASS_LOGGER_IMP(SE_Optimal)
     OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:
-    OptimalSelector();
-    virtual ~OptimalSelector() = default;
+    OptimalPerformanceSelector();
+    virtual ~OptimalPerformanceSelector() = default;
 
     virtual void _checkParam(const string& name) const override;
     virtual void calculate(const SystemList& pf_realSysList, const KQuery& query) override;

hikyuu_cpp/hikyuu/trade_sys/selector/imp/optimal/OptimalSelectorBase.cpp

@@ -31,6 +31,7 @@ OptimalSelectorBase::OptimalSelectorBase(const string& name) : SelectorBase(name
 void OptimalSelectorBase::_initParams() {
     setParam<bool>("depend_on_proto_sys", true);
     setParam<string>("market", "SH");
+    setParam<int>("index", 0);  // 取排序后的第 index 个结果
     setParam<int>("train_len", 100);
     setParam<int>("test_len", 20);
     setParam<bool>("parallel", false);
@@ -42,6 +43,8 @@ void OptimalSelectorBase::_checkParam(const string& name) const {
         HKU_ASSERT(getParam<int>("train_len") > 0);
     } else if ("test_len" == name) {
         HKU_ASSERT(getParam<int>("test_len") > 0);
+    } else if ("index" == name) {
+        HKU_ASSERT(getParam<int>("index") >= 0);
     } else if ("depend_on_proto_sys" == name) {
         HKU_ASSERT(getParam<bool>("depend_on_proto_sys"));
     } else if ("market" == name) {
@@ -55,7 +58,12 @@ SystemWeightList OptimalSelectorBase::getSelected(Datetime date) {
     SystemWeightList ret;
     auto iter = m_sys_dict.find(date);
     if (iter != m_sys_dict.end()) {
-        ret.push_back(iter->second->front());
+        int index = getParam<int>("index");
+        if (index < iter->second->size()) {
+            ret.emplace_back(iter->second->at(index));
+        } else {
+            ret.emplace_back(iter->second->at(iter->second->size() - 1));
+        }
     }
     return ret;
 }

hikyuu_cpp/hikyuu/trade_sys/system/crt/SYS_WalkForward.h

@@ -21,7 +21,7 @@ namespace hku {
 SystemPtr HKU_API SYS_WalkForward(const SystemList& candidate_sys_list,
                                   const TradeManagerPtr& tm = TradeManagerPtr(),
                                   size_t train_len = 100, size_t test_len = 20,
-                                  const SelectorPtr& se = SE_Optimal(),
+                                  const SelectorPtr& se = SE_MaxFundsOptimal(),
                                   const TradeManagerPtr& train_tm = TradeManagerPtr());
 
 }  // namespace hku

hikyuu_cpp/hikyuu/trade_sys/system/imp/WalkForwardSystem.cpp

@@ -6,7 +6,7 @@
  */
 
 #include "hikyuu/trade_sys/selector/crt/SE_Optimal.h"
-#include "hikyuu/trade_sys/selector/imp/optimal/OptimalSelector.h"
+#include "hikyuu/trade_sys/selector/imp/optimal/OptimalSelectorBase.h"
 #include "hikyuu/trade_manage/Performance.h"
 #include "WalkForwardSystem.h"
 #include "WalkForwardTradeManager.h"
@@ -37,7 +37,7 @@ string WalkForwardSystem::str() const {
     return os.str();
 }
 
-WalkForwardSystem::WalkForwardSystem() : System("SYS_WalkForward"), m_se(SE_Optimal()) {
+WalkForwardSystem::WalkForwardSystem() : System("SYS_WalkForward"), m_se(SE_MaxFundsOptimal()) {
     initParam();
 }
 

hikyuu_cpp/unit_test/hikyuu/trade_sys/selector/test_SE_Optimal.cpp → hikyuu_cpp/unit_test/hikyuu/trade_sys/selector/test_SE_PerformanceOptimal.cpp

@@ -35,9 +35,9 @@ static SYSPtr create_test_sys(int fast_n, int slow_n) {
 }
 
 /** @par 检测点 */
-TEST_CASE("test_SE_Optimal") {
-    auto se = SE_Optimal();
-    CHECK_EQ(se->name(), "SE_Optimal");
+TEST_CASE("test_SE_PerformanceOptimal") {
+    auto se = SE_PerformanceOptimal();
+    CHECK_EQ(se->name(), "SE_PerformanceOptimal");
 
     /** @arg 尝试加入空系统 */
     CHECK_THROWS(se->addSystem(SYSPtr()));
@@ -229,12 +229,12 @@ TEST_CASE("test_SE_Optimal") {
 #if HKU_SUPPORT_SERIALIZATION
 
 /** @par 检测点 */
-TEST_CASE("test_SE_Optimal_export") {
+TEST_CASE("test_SE_PerformanceOptimal_export") {
     StockManager& sm = StockManager::instance();
     string filename(sm.tmpdir());
-    filename += "/SE_Optimal.xml";
+    filename += "/SE_PerformanceOptimal.xml";
 
-    auto se1 = SE_Optimal();
+    auto se1 = SE_PerformanceOptimal();
     Stock stk = getStock("sz000001");
     vector<std::pair<int, int>> params{{3, 5}, {3, 10}, {5, 10}, {5, 20}};
     for (const auto& param : params) {

hikyuu_pywrap/trade_sys/_System.cpp

@@ -274,7 +274,7 @@ void export_System(py::module& m) {
           SystemList sys_list = python_list_to_vector<SystemPtr>(candidate_sys_list);
           SelectorPtr c_se = se;
           if (!c_se) {
-              c_se = SE_Optimal();
+              c_se = SE_MaxFundsOptimal();
           }
           return SYS_WalkForward(sys_list, tm, train_len, test_len, c_se, train_tm);
       },