hikyuu 2.6.8.4__py3-none-macosx_11_0_arm64.whl → 2.7.0.4__py3-none-macosx_11_0_arm64.whl

hikyuu/include/hikyuu/trade_sys/multifactor/MultiFactorBase.h

@@ -8,7 +8,8 @@
 #pragma once
 
 #include "hikyuu/KData.h"
-#include "ScoreRecord.h"
+#include "ScoresFilterBase.h"
+#include "buildin_norm.h"
 
 namespace hku {
 
@@ -108,6 +109,9 @@ public:
     ScoreRecordList getScores(const Datetime& date, size_t start, size_t end,
                               std::function<bool(const Datetime&, const ScoreRecord&)>&& filter);
 
+    ScoreRecordList getScores(const Datetime& date, size_t start, size_t end,
+                              const ScoresFilterPtr& filter);
+
     /** 获取所有截面数据，已按降序排列 */
     const vector<ScoreRecordList>& getAllScores();
 
@@ -128,12 +132,29 @@ public:
     Indicator getICIR(int ir_n, int ic_n = 0);
 
     /**
-     * 获取所有处理过的原始因子值（归一化、标准化）
+     * 获取所有处理过的原始因子值（归一化、标准化）。每次都会计算。
      * @note 考虑到内存占用，该数据没有缓存，一般用与测试或者想查看处理过的原始因子值
      * @return vector<IndicatorList>  stks x inds
      */
     vector<IndicatorList> getAllSrcFactors();
 
+    /**
+     * 设置因子标准化/归一化操作
+     * @param norm 标准化操作
+     */
+    void setNormalize(NormPtr norm);
+
+    /**
+     * 对指定名称的指标应用特定的标准化/归一化、行业中性化、风格因子中性化操作。
+     * @note 标准化操作、行业中性化、风格因子中性化彼此无关，可同时指定也可分开指定。
+     * @param name 指标名称
+     * @param norm 标准化操作
+     * @param category 指标所属板块类别(需要中性化指定)
+     * @param style_inds 指标风格列表
+     */
+    void addSpecialNormalize(const string& name, NormalizePtr norm, const string& category = "",
+                             const IndicatorList& style_inds = IndicatorList());
+
     void reset();
 
     typedef std::shared_ptr<MultiFactorBase> MultiFactorPtr;
@@ -154,7 +175,9 @@ private:
 
     void initParam();
 
-protected:
+    // 构造每个指标构造行业哑变量，以便进行行业中性化处理
+    unordered_map<string, PriceList> _buildDummyIndex();
+
     void _buildIndex();      // 计算完成后创建截面索引
     void _buildIndexDesc();  // 创建降序排列的索引
     void _buildIndexAsc();   // 创建升序排列的索引
@@ -178,6 +201,12 @@ protected:
     vector<ScoreRecordList> m_stk_factor_by_date;
     Indicator m_ic;
 
+    NormPtr m_norm;                                    // 全局标准化/归一化操作
+    unordered_map<string, NormPtr> m_special_norms;    // 对特定指标执行特定的标准化操作
+    unordered_map<string, string> m_special_category;  // 对特定指标执行行业中性化时指定的板块分类
+    unordered_map<string, IndicatorList>
+      m_special_style_inds;  // 对特定指标执行风格因子中性化时指定的风格因子
+
 private:
     std::mutex m_mutex;
     bool m_calculated{false};
@@ -197,6 +226,8 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_ref_stk);
         ar& BOOST_SERIALIZATION_NVP(m_query);
         ar& BOOST_SERIALIZATION_NVP(m_ref_dates);
+        ar& BOOST_SERIALIZATION_NVP(m_special_norms);
+        ar& BOOST_SERIALIZATION_NVP(m_special_category);
         // 以下不需要保存，加载后重新计算
         // ar& BOOST_SERIALIZATION_NVP(m_stk_map);
         // ar& BOOST_SERIALIZATION_NVP(m_all_factors);
@@ -215,6 +246,8 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_ref_stk);
         ar& BOOST_SERIALIZATION_NVP(m_query);
         ar& BOOST_SERIALIZATION_NVP(m_ref_dates);
+        ar& BOOST_SERIALIZATION_NVP(m_special_norms);
+        ar& BOOST_SERIALIZATION_NVP(m_special_category);
         // ar& BOOST_SERIALIZATION_NVP(m_stk_map);
         // ar& BOOST_SERIALIZATION_NVP(m_all_factors);
         // ar& BOOST_SERIALIZATION_NVP(m_date_index);

hikyuu/include/hikyuu/trade_sys/multifactor/NormalizeBase.h

@@ -0,0 +1,125 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/utilities/Parameter.h"
+
+namespace hku {
+
+/**
+ * 时间截面数据归一化基类
+ */
+class HKU_API NormalizeBase {
+    PARAMETER_SUPPORT_WITH_CHECK
+
+public:
+    NormalizeBase() = default;
+    NormalizeBase(const string& name) : m_name(name) {}
+
+    NormalizeBase(const NormalizeBase& other) : m_params(other.m_params), m_name(other.m_name) {}
+
+    virtual ~NormalizeBase() = default;
+
+    /** 获取名称 */
+    const string& name() const {
+        return m_name;
+    }
+
+    /** 设置名称 */
+    void name(const string& name) {
+        m_name = name;
+    }
+
+    typedef std::shared_ptr<NormalizeBase> NormPtr;
+    NormPtr clone();
+
+    virtual NormPtr _clone() = 0;
+
+    virtual PriceList normalize(const PriceList& data) = 0;
+
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
+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(MultiFactorBase)
+#endif
+
+#if HKU_SUPPORT_SERIALIZATION
+/**
+ * 对于没有私有变量的继承子类，可直接使用该宏定义序列化
+ * @code
+ * class Drived: public NormalizeBase {
+ *     NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+ *
+ * public:
+ *     Drived();
+ *     ...
+ * };
+ * @endcode
+ * @ingroup MultiFactor
+ */
+#define NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION               \
+private:                                                        \
+    friend class boost::serialization::access;                  \
+    template <class Archive>                                    \
+    void serialize(Archive& ar, const unsigned int version) {   \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(NormalizeBase); \
+    }
+#else
+#define NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+typedef std::shared_ptr<NormalizeBase> NormPtr;
+typedef std::shared_ptr<NormalizeBase> NormalizePtr;
+
+#define NORMALIZE_IMP(classname)              \
+public:                                       \
+    virtual NormalizePtr _clone() override {  \
+        return std::make_shared<classname>(); \
+    }                                         \
+    PriceList normalize(const PriceList& data) override;
+
+HKU_API std::ostream& operator<<(std::ostream&, const NormalizeBase&);
+HKU_API std::ostream& operator<<(std::ostream&, const NormalizePtr&);
+
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::NormalizeBase> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<hku::NormalizePtr> : ostream_formatter {};
+#endif

hikyuu/include/hikyuu/trade_sys/multifactor/ScoresFilterBase.h

@@ -0,0 +1,125 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_manage/TradeManagerBase.h"
+#include "ScoreRecord.h"
+
+namespace hku {
+
+/**
+ * 评分过滤器
+ * @note 虽然直接使用 std::function 即可，但如果使用 python 函数会造成并行死锁
+ * @ingroup Selector
+ */
+class HKU_API ScoresFilterBase {
+    PARAMETER_SUPPORT_WITH_CHECK
+    friend HKU_API std::ostream& operator<<(std::ostream&, const ScoresFilterBase&);
+
+public:
+    ScoresFilterBase() = default;
+    ScoresFilterBase(const ScoresFilterBase&) = default;
+    ScoresFilterBase(const string& name) : m_name(name) {}
+    virtual ~ScoresFilterBase() = default;
+
+    const string& name() const {
+        return m_name;
+    }
+
+    void name(const string& name) {
+        m_name = name;
+    }
+
+    ScoreRecordList filter(const ScoreRecordList& scores, const Datetime& date,
+                           const KQuery& query);
+
+    virtual ScoreRecordList _filter(const ScoreRecordList& scores, const Datetime& date,
+                                    const KQuery& query) = 0;
+
+    typedef std::shared_ptr<ScoresFilterBase> ScoresFilterPtr;
+    ScoresFilterPtr clone();
+
+    virtual ScoresFilterPtr _clone() = 0;
+
+public:
+    friend HKU_API ScoresFilterPtr operator|(const ScoresFilterPtr& a, const ScoresFilterPtr& b);
+
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
+protected:
+    string m_name;
+    ScoresFilterPtr m_child;
+
+//============================================
+// 序列化支持
+//============================================
+#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);
+        ar& BOOST_SERIALIZATION_NVP(m_child);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_params);
+        ar& BOOST_SERIALIZATION_NVP(m_child);
+    }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+#endif /* HKU_SUPPORT_SERIALIZATION */
+};
+
+#if HKU_SUPPORT_SERIALIZATION
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(ScoresFilterBase)
+#endif
+
+#if HKU_SUPPORT_SERIALIZATION
+#define SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION               \
+private:                                                           \
+    friend class boost::serialization::access;                     \
+    template <class Archive>                                       \
+    void serialize(Archive& ar, const unsigned int version) {      \
+        ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(ScoresFilterBase); \
+    }
+#else
+#define SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+#endif
+
+typedef std::shared_ptr<ScoresFilterBase> ScoresFilterPtr;
+typedef std::shared_ptr<ScoresFilterBase> SCFilterPtr;
+
+#define SCORESFILTER_IMP(classname)                                                      \
+public:                                                                                  \
+    virtual ScoresFilterPtr _clone() override {                                          \
+        return std::make_shared<classname>();                                            \
+    }                                                                                    \
+    virtual ScoreRecordList _filter(const ScoreRecordList& scores, const Datetime& date, \
+                                    const KQuery& query) override;
+
+HKU_API std::ostream& operator<<(std::ostream&, const ScoresFilterBase&);
+HKU_API std::ostream& operator<<(std::ostream&, const ScoresFilterPtr&);
+
+HKU_API ScoresFilterPtr operator|(const ScoresFilterPtr& a, const ScoresFilterPtr& b);
+
+}  // namespace hku
+
+#if FMT_VERSION >= 90000
+template <>
+struct fmt::formatter<hku::ScoresFilterBase> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<hku::ScoresFilterPtr> : ostream_formatter {};
+#endif

hikyuu/include/hikyuu/trade_sys/multifactor/build_in.h

@@ -7,6 +7,9 @@
 
 #pragma once
 
+#include "buildin_norm.h"
+#include "buildin_scfilter.h"
+
 #include "crt/MF_Weight.h"
 #include "crt/MF_EqualWeight.h"
 #include "crt/MF_ICWeight.h"

hikyuu/include/hikyuu/trade_sys/multifactor/buildin_norm.h

@@ -0,0 +1,36 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "NormalizeBase.h"
+
+namespace hku {
+
+/**
+ * @ingroup MultiFactor
+ * @{
+ */
+
+inline NormPtr NORM_NOTHING() {
+    return NormPtr();
+}
+
+/** 最小-最大标准化 */
+NormPtr HKU_API NORM_MinMax();
+
+/** 正态标准化 */
+NormPtr HKU_API NORM_Zscore(bool outExtreme = false, double nsigma = 3.0, bool recursive = false);
+
+/** 分位数分布标准化 */
+NormPtr HKU_API NORM_Quantile(double quantile_min = 0.01, double quantile_max = 0.99);
+
+/** 分位数均匀分布标准化 */
+NormPtr HKU_API NORM_Quantile_Uniform(double quantile_min = 0.01, double quantile_max = 0.99);
+
+/* @} */
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/buildin_scfilter.h

@@ -0,0 +1,51 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "ScoresFilterBase.h"
+
+namespace hku {
+
+/**
+ * @ingroup MultiFactor
+ * @{
+ */
+
+ScoresFilterPtr HKU_API SCFilter_IgnoreNan();
+
+ScoresFilterPtr HKU_API SCFilter_LessOrEqualValue(double value = 0.0);
+
+ScoresFilterPtr HKU_API SCFilter_TopN(int topn = 10);
+
+/**
+ * 过滤掉成交金额在评分列表末尾百分比范围内的截面
+ * @note
+ * 和传入的截面评分列表顺序相关，如果是降序，过滤的是成交金额较小的系统评分记录；反之，则是金额较大的系统评分记录
+ * @param min_amount_percent_limit 最小成交金额百分比限制
+ * @return ScoresFilterPtr
+ */
+ScoresFilterPtr HKU_API SCFilter_AmountLimit(double min_amount_percent_limit = 0.1);
+
+/**
+ * 筛选指定分组的截面
+ * @param group 分组数量
+ * @param group_index 分组索引，从0开始
+ * @return ScoresFilterPtr
+ */
+ScoresFilterPtr HKU_API SCFilter_Group(int group = 10, int group_index = 0);
+
+/**
+ * 筛选指定价格范围 [min_price, max_price] 内的截面
+ * @param min_price 最低价格
+ * @param max_price 最高价格
+ * @return ScoresFilterPtr
+ */
+ScoresFilterPtr HKU_API SCFilter_Price(double min_price = 10., double max_price = 100000.);
+
+/* @} */
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/GroupSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API GroupSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(GroupSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    GroupSCFilter();
+    virtual ~GroupSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/IgnoreLessOrEqualValueSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-14
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API IgnoreLessOrEqualValueSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(IgnoreLessOrEqualValueSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IgnoreLessOrEqualValueSCFilter();
+    virtual ~IgnoreLessOrEqualValueSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/IgnoreNanSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-14
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API IgnoreNanSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(IgnoreNanSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IgnoreNanSCFilter();
+    virtual ~IgnoreNanSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/MinAmountPercentSCFilter.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API MinAmountPercentSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(MinAmountPercentSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    MinAmountPercentSCFilter();
+    virtual ~MinAmountPercentSCFilter() override = default;
+
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/PriceSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API PriceSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(PriceSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    PriceSCFilter();
+    virtual ~PriceSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/filter/TopNSCFilter.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-14
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../ScoresFilterBase.h"
+
+namespace hku {
+
+class HKU_API TopNSCFilter : public ScoresFilterBase {
+    SCORESFILTER_IMP(TopNSCFilter)
+    SCORESFILTER_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    TopNSCFilter();
+    virtual ~TopNSCFilter() override = default;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/imp/EqualWeightMultiFactor.h

@@ -20,7 +20,7 @@ public:
     EqualWeightMultiFactor(const vector<Indicator>& inds, const StockList& stks,
                            const KQuery& query, const Stock& ref_stk, int ic_n, bool spearman,
                            int mode, bool save_all_factors);
-    virtual ~EqualWeightMultiFactor() = default;
+    virtual ~EqualWeightMultiFactor() override = default;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/imp/ICIRMultiFactor.h

@@ -20,7 +20,7 @@ public:
     ICIRMultiFactor(const IndicatorList& inds, const StockList& stks, const KQuery& query,
                     const Stock& ref_stk, int ic_n, int ic_rolling_n, bool spearman, int mode,
                     bool save_all_factors);
-    virtual ~ICIRMultiFactor() = default;
+    virtual ~ICIRMultiFactor() override = default;
 
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/trade_sys/multifactor/imp/ICMultiFactor.h

@@ -20,7 +20,7 @@ public:
     ICMultiFactor(const IndicatorList& inds, const StockList& stks, const KQuery& query,
                   const Stock& ref_stk, int ic_n, int ic_rolling_n, bool spearman, int mode,
                   bool save_all_factors);
-    virtual ~ICMultiFactor() = default;
+    virtual ~ICMultiFactor() override = default;
 
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/trade_sys/multifactor/imp/WeightMultiFactor.h

@@ -22,7 +22,7 @@ public:
     WeightMultiFactor(const vector<Indicator>& inds, const PriceList& weights,
                       const StockList& stks, const KQuery& query, const Stock& ref_stk, int ic_n,
                       bool spearman, int mode, bool save_all_factors);
-    virtual ~WeightMultiFactor() = default;
+    virtual ~WeightMultiFactor() override = default;
 
 private:
     PriceList m_weights;  // 每个指标权重，与输入 inds 列表等长

hikyuu/include/hikyuu/trade_sys/multifactor/normalize/NormMinMax.h

@@ -0,0 +1,23 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../NormalizeBase.h"
+
+namespace hku {
+
+class NormMinMax : public NormalizeBase {
+    NORMALIZE_IMP(NormMinMax)
+    NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    NormMinMax();
+    virtual ~NormMinMax() override;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/multifactor/normalize/NormQuantile.h

@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-10-03
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../NormalizeBase.h"
+
+namespace hku {
+
+/*
+ * 分位数均匀分布标准化
+ */
+class NormQuantile : public NormalizeBase {
+    NORMALIZE_IMP(NormQuantile)
+    NORMALIZE_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    NormQuantile();
+    NormQuantile(double quantile_min, double quantile_max);
+    virtual ~NormQuantile() override;
+    virtual void _checkParam(const string& name) const override;
+};
+
+}  // namespace hku