boris
483 lines
15 KiB
Rust
483 lines
15 KiB
Rust
use std::collections::BTreeSet;
|
|
|
|
use chrono::NaiveDate;
|
|
use serde::Serialize;
|
|
|
|
use crate::data::{BenchmarkSnapshot, DataSet, EligibleUniverseSnapshot};
|
|
use crate::risk_control::{ChinaAShareRiskControl, FidcRiskControlConfig, FidcRiskDecisionAudit};
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum BandRegime {
|
|
Bullish,
|
|
Neutral,
|
|
Defensive,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize)]
|
|
pub struct UniverseCandidate {
|
|
pub symbol: String,
|
|
pub market_cap_bn: f64,
|
|
pub free_float_cap_bn: f64,
|
|
pub band_low: f64,
|
|
pub band_high: f64,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize)]
|
|
pub struct SelectionDiagnostics {
|
|
pub decision_date: NaiveDate,
|
|
pub reference_level: f64,
|
|
pub band_low: f64,
|
|
pub band_high: f64,
|
|
pub factor_total: usize,
|
|
pub market_cap_missing_count: usize,
|
|
pub candidate_missing_count: usize,
|
|
pub market_missing_count: usize,
|
|
pub not_eligible_count: usize,
|
|
pub paused_count: usize,
|
|
pub out_of_band_count: usize,
|
|
pub selected_before_limit: usize,
|
|
pub selected_after_limit: usize,
|
|
pub missing_market_cap_symbols: Vec<String>,
|
|
pub selected_symbols: Vec<String>,
|
|
pub rejection_examples: Vec<String>,
|
|
pub risk_decisions: Vec<FidcRiskDecisionAudit>,
|
|
}
|
|
|
|
pub struct SelectionContext<'a> {
|
|
pub decision_date: NaiveDate,
|
|
pub benchmark: &'a BenchmarkSnapshot,
|
|
pub reference_level: f64,
|
|
pub data: &'a DataSet,
|
|
pub dynamic_universe: Option<&'a BTreeSet<String>>,
|
|
pub risk_config: Option<&'a FidcRiskControlConfig>,
|
|
pub defer_selection_risk: bool,
|
|
}
|
|
|
|
impl SelectionContext<'_> {
|
|
fn eligible_universe(&self) -> Vec<EligibleUniverseSnapshot> {
|
|
let eligible = if self.defer_selection_risk {
|
|
self.data.fundamental_universe_on(self.decision_date)
|
|
} else {
|
|
match self.risk_config {
|
|
Some(risk_config) => self
|
|
.data
|
|
.eligible_universe_on_with_risk_config(self.decision_date, risk_config),
|
|
None => self.data.eligible_universe_on(self.decision_date).to_vec(),
|
|
}
|
|
};
|
|
match self.dynamic_universe {
|
|
Some(symbols) if !symbols.is_empty() => eligible
|
|
.into_iter()
|
|
.filter(|row| symbols.contains(&row.symbol))
|
|
.collect(),
|
|
_ => eligible,
|
|
}
|
|
}
|
|
|
|
fn selection_risk_decisions(&self) -> Vec<FidcRiskDecisionAudit> {
|
|
if self.defer_selection_risk {
|
|
return Vec::new();
|
|
}
|
|
let default_risk_config;
|
|
let risk_config = match self.risk_config {
|
|
Some(value) => value,
|
|
None => {
|
|
default_risk_config = FidcRiskControlConfig::default();
|
|
&default_risk_config
|
|
}
|
|
};
|
|
let mut decisions = Vec::new();
|
|
for factor in self.data.factor_snapshots_on(self.decision_date) {
|
|
if self
|
|
.dynamic_universe
|
|
.is_some_and(|symbols| !symbols.is_empty() && !symbols.contains(&factor.symbol))
|
|
{
|
|
continue;
|
|
}
|
|
let Some(candidate) = self.data.candidate(self.decision_date, &factor.symbol) else {
|
|
continue;
|
|
};
|
|
let Some(market) = self.data.market(self.decision_date, &factor.symbol) else {
|
|
continue;
|
|
};
|
|
if let Some(decision) = ChinaAShareRiskControl::selection_rejection_decision_with_config(
|
|
self.decision_date,
|
|
candidate,
|
|
market,
|
|
self.data.instrument(&factor.symbol),
|
|
risk_config,
|
|
) {
|
|
decisions.push(decision);
|
|
}
|
|
}
|
|
decisions
|
|
}
|
|
}
|
|
|
|
pub trait UniverseSelector {
|
|
fn select(&self, ctx: &SelectionContext<'_>) -> Vec<UniverseCandidate>;
|
|
fn select_with_diagnostics(
|
|
&self,
|
|
ctx: &SelectionContext<'_>,
|
|
) -> (Vec<UniverseCandidate>, SelectionDiagnostics);
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct DynamicMarketCapBandSelector {
|
|
pub base_index_level: f64,
|
|
pub base_cap_floor: f64,
|
|
pub cap_span: f64,
|
|
pub xs: f64,
|
|
pub top_n: usize,
|
|
pub padding_ratio: f64,
|
|
pub min_padding: f64,
|
|
pub max_padding: f64,
|
|
}
|
|
|
|
impl DynamicMarketCapBandSelector {
|
|
pub fn new(
|
|
base_index_level: f64,
|
|
base_cap_floor: f64,
|
|
cap_span: f64,
|
|
xs: f64,
|
|
top_n: usize,
|
|
padding_ratio: f64,
|
|
min_padding: f64,
|
|
max_padding: f64,
|
|
) -> Self {
|
|
Self {
|
|
base_index_level,
|
|
base_cap_floor,
|
|
cap_span,
|
|
xs,
|
|
top_n,
|
|
padding_ratio,
|
|
min_padding,
|
|
max_padding,
|
|
}
|
|
}
|
|
|
|
pub fn demo(top_n: usize) -> Self {
|
|
Self::new(2000.0, 7.0, 10.0, 4.0 / 500.0, top_n, 0.5, 8.0, 20.0)
|
|
}
|
|
|
|
pub fn regime(&self, benchmark_level: f64) -> BandRegime {
|
|
if benchmark_level >= self.base_index_level + 400.0 {
|
|
BandRegime::Bullish
|
|
} else if benchmark_level >= self.base_index_level {
|
|
BandRegime::Neutral
|
|
} else {
|
|
BandRegime::Defensive
|
|
}
|
|
}
|
|
|
|
pub fn band_for_level(&self, benchmark_level: f64) -> (f64, f64) {
|
|
let start = ((benchmark_level - self.base_index_level) * self.xs) + self.base_cap_floor;
|
|
let low = start.round();
|
|
let high = low + self.cap_span;
|
|
|
|
// Apply padding to expand the range
|
|
let span = high - low;
|
|
let padding = (span * self.padding_ratio)
|
|
.max(self.min_padding)
|
|
.min(self.max_padding);
|
|
|
|
let lower_bound = (low - padding).max(0.0);
|
|
let upper_bound = high + padding;
|
|
|
|
(lower_bound, upper_bound)
|
|
}
|
|
}
|
|
|
|
impl UniverseSelector for DynamicMarketCapBandSelector {
|
|
fn select(&self, ctx: &SelectionContext<'_>) -> Vec<UniverseCandidate> {
|
|
self.select_with_diagnostics(ctx).0
|
|
}
|
|
|
|
fn select_with_diagnostics(
|
|
&self,
|
|
ctx: &SelectionContext<'_>,
|
|
) -> (Vec<UniverseCandidate>, SelectionDiagnostics) {
|
|
let _regime = self.regime(ctx.reference_level);
|
|
let (min_cap, max_cap) = self.band_for_level(ctx.reference_level);
|
|
let mut diagnostics = SelectionDiagnostics {
|
|
decision_date: ctx.decision_date,
|
|
reference_level: ctx.reference_level,
|
|
band_low: min_cap,
|
|
band_high: max_cap,
|
|
factor_total: 0,
|
|
market_cap_missing_count: 0,
|
|
candidate_missing_count: 0,
|
|
market_missing_count: 0,
|
|
not_eligible_count: 0,
|
|
paused_count: 0,
|
|
out_of_band_count: 0,
|
|
selected_before_limit: 0,
|
|
selected_after_limit: 0,
|
|
missing_market_cap_symbols: Vec::new(),
|
|
selected_symbols: Vec::new(),
|
|
rejection_examples: Vec::new(),
|
|
risk_decisions: Vec::new(),
|
|
};
|
|
|
|
diagnostics.factor_total = ctx.data.factor_snapshots_on(ctx.decision_date).len();
|
|
diagnostics.risk_decisions = ctx.selection_risk_decisions();
|
|
diagnostics.not_eligible_count = diagnostics.risk_decisions.len();
|
|
diagnostics.paused_count = diagnostics
|
|
.risk_decisions
|
|
.iter()
|
|
.filter(|decision| decision.rule_code == "paused")
|
|
.count();
|
|
diagnostics.rejection_examples = diagnostics
|
|
.risk_decisions
|
|
.iter()
|
|
.take(8)
|
|
.map(|decision| format!("{} rejected by {}", decision.symbol, decision.rule_code))
|
|
.collect();
|
|
let eligible = ctx.eligible_universe();
|
|
diagnostics.market_cap_missing_count =
|
|
diagnostics.factor_total.saturating_sub(eligible.len());
|
|
let start_idx = lower_bound_by_market_cap(&eligible, min_cap);
|
|
let mut selected = Vec::new();
|
|
|
|
for factor in eligible.iter().skip(start_idx) {
|
|
if factor.market_cap_bn > max_cap {
|
|
break;
|
|
}
|
|
selected.push(to_universe_candidate(factor, min_cap, max_cap));
|
|
}
|
|
|
|
diagnostics.out_of_band_count = eligible.len().saturating_sub(selected.len());
|
|
|
|
diagnostics.selected_before_limit = selected.len();
|
|
if selected.len() > self.top_n {
|
|
selected.truncate(self.top_n);
|
|
}
|
|
diagnostics.selected_symbols = selected.iter().map(|item| item.symbol.clone()).collect();
|
|
diagnostics.selected_after_limit = diagnostics.selected_symbols.len();
|
|
(selected, diagnostics)
|
|
}
|
|
}
|
|
|
|
fn lower_bound_by_market_cap(rows: &[EligibleUniverseSnapshot], target: f64) -> usize {
|
|
let mut left = 0usize;
|
|
let mut right = rows.len();
|
|
while left < right {
|
|
let mid = left + (right - left) / 2;
|
|
if rows[mid].market_cap_bn < target {
|
|
left = mid + 1;
|
|
} else {
|
|
right = mid;
|
|
}
|
|
}
|
|
left
|
|
}
|
|
|
|
fn to_universe_candidate(
|
|
factor: &EligibleUniverseSnapshot,
|
|
band_low: f64,
|
|
band_high: f64,
|
|
) -> UniverseCandidate {
|
|
UniverseCandidate {
|
|
symbol: factor.symbol.clone(),
|
|
market_cap_bn: factor.market_cap_bn,
|
|
free_float_cap_bn: factor.free_float_cap_bn,
|
|
band_low,
|
|
band_high,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::data::{
|
|
BenchmarkSnapshot, CandidateEligibility, DailyFactorSnapshot, DailyMarketSnapshot, DataSet,
|
|
};
|
|
use crate::instrument::Instrument;
|
|
|
|
fn d() -> NaiveDate {
|
|
NaiveDate::from_ymd_opt(2025, 1, 2).unwrap()
|
|
}
|
|
|
|
fn instrument(symbol: &str) -> Instrument {
|
|
Instrument {
|
|
symbol: symbol.to_string(),
|
|
name: symbol.to_string(),
|
|
board: symbol.rsplit('.').next().unwrap_or("").to_string(),
|
|
round_lot: 100,
|
|
listed_at: Some(NaiveDate::from_ymd_opt(2020, 1, 1).unwrap()),
|
|
delisted_at: None,
|
|
status: "active".to_string(),
|
|
}
|
|
}
|
|
|
|
fn market(symbol: &str, price: f64) -> DailyMarketSnapshot {
|
|
DailyMarketSnapshot {
|
|
date: d(),
|
|
symbol: symbol.to_string(),
|
|
timestamp: Some("2025-01-02 10:00:00".to_string()),
|
|
day_open: price,
|
|
open: price,
|
|
high: price,
|
|
low: price,
|
|
close: price,
|
|
last_price: price,
|
|
bid1: price,
|
|
ask1: price,
|
|
prev_close: price,
|
|
volume: 1_000_000,
|
|
minute_volume: 10_000,
|
|
bid1_volume: 10_000,
|
|
ask1_volume: 10_000,
|
|
trading_phase: Some("continuous".to_string()),
|
|
paused: false,
|
|
upper_limit: price * 1.1,
|
|
lower_limit: price * 0.9,
|
|
price_tick: 0.01,
|
|
}
|
|
}
|
|
|
|
fn factor(symbol: &str, market_cap_bn: f64) -> DailyFactorSnapshot {
|
|
DailyFactorSnapshot {
|
|
date: d(),
|
|
symbol: symbol.to_string(),
|
|
market_cap_bn,
|
|
free_float_cap_bn: market_cap_bn,
|
|
pe_ttm: 10.0,
|
|
turnover_ratio: Some(0.01),
|
|
effective_turnover_ratio: Some(0.01),
|
|
extra_factors: Default::default(),
|
|
}
|
|
}
|
|
|
|
fn candidate(symbol: &str, is_st: bool, is_kcb: bool) -> CandidateEligibility {
|
|
CandidateEligibility {
|
|
date: d(),
|
|
symbol: symbol.to_string(),
|
|
is_st,
|
|
is_star_st: false,
|
|
is_new_listing: false,
|
|
is_paused: false,
|
|
allow_buy: true,
|
|
allow_sell: true,
|
|
is_kcb,
|
|
is_one_yuan: false,
|
|
risk_level_code: None,
|
|
}
|
|
}
|
|
|
|
fn benchmark() -> BenchmarkSnapshot {
|
|
BenchmarkSnapshot {
|
|
date: d(),
|
|
benchmark: "000852.SH".to_string(),
|
|
open: 2000.0,
|
|
close: 2000.0,
|
|
prev_close: 1990.0,
|
|
volume: 1_000_000,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn selector_records_structured_selection_risk_decisions() {
|
|
let data = DataSet::from_components(
|
|
vec![
|
|
instrument("000001.SZ"),
|
|
instrument("688001.SH"),
|
|
instrument("000002.SZ"),
|
|
],
|
|
vec![
|
|
market("000001.SZ", 10.0),
|
|
market("688001.SH", 10.0),
|
|
market("000002.SZ", 10.0),
|
|
],
|
|
vec![
|
|
factor("000001.SZ", 8.0),
|
|
factor("688001.SH", 9.0),
|
|
factor("000002.SZ", 10.0),
|
|
],
|
|
vec![
|
|
candidate("000001.SZ", true, false),
|
|
candidate("688001.SH", false, true),
|
|
candidate("000002.SZ", false, false),
|
|
],
|
|
vec![benchmark()],
|
|
)
|
|
.unwrap();
|
|
let selector = DynamicMarketCapBandSelector::new(2000.0, 7.0, 10.0, 0.0, 10, 0.0, 0.0, 0.0);
|
|
let (_selected, diagnostics) = selector.select_with_diagnostics(&SelectionContext {
|
|
decision_date: d(),
|
|
benchmark: &benchmark(),
|
|
reference_level: 2000.0,
|
|
data: &data,
|
|
dynamic_universe: None,
|
|
risk_config: Some(&FidcRiskControlConfig::default()),
|
|
defer_selection_risk: false,
|
|
});
|
|
|
|
let rules = diagnostics
|
|
.risk_decisions
|
|
.iter()
|
|
.map(|decision| decision.rule_code.as_str())
|
|
.collect::<BTreeSet<_>>();
|
|
assert!(rules.contains("st"), "{:?}", diagnostics.risk_decisions);
|
|
assert!(rules.contains("kcb"), "{:?}", diagnostics.risk_decisions);
|
|
assert_eq!(
|
|
diagnostics.not_eligible_count,
|
|
diagnostics.risk_decisions.len()
|
|
);
|
|
assert!(
|
|
diagnostics.risk_decisions[0]
|
|
.diagnostic_line()
|
|
.starts_with("risk_decision=")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn selector_defers_static_execution_risk_for_lagged_execution() {
|
|
let data = DataSet::from_components(
|
|
vec![
|
|
instrument("000001.SZ"),
|
|
instrument("688001.SH"),
|
|
instrument("000002.SZ"),
|
|
],
|
|
vec![
|
|
market("000001.SZ", 10.0),
|
|
market("688001.SH", 10.0),
|
|
market("000002.SZ", 10.0),
|
|
],
|
|
vec![
|
|
factor("000001.SZ", 8.0),
|
|
factor("688001.SH", 9.0),
|
|
factor("000002.SZ", 10.0),
|
|
],
|
|
vec![
|
|
candidate("000001.SZ", true, false),
|
|
candidate("688001.SH", false, true),
|
|
candidate("000002.SZ", false, false),
|
|
],
|
|
vec![benchmark()],
|
|
)
|
|
.unwrap();
|
|
let selector = DynamicMarketCapBandSelector::new(2000.0, 7.0, 10.0, 0.0, 10, 0.0, 0.0, 0.0);
|
|
let (selected, diagnostics) = selector.select_with_diagnostics(&SelectionContext {
|
|
decision_date: d(),
|
|
benchmark: &benchmark(),
|
|
reference_level: 2000.0,
|
|
data: &data,
|
|
dynamic_universe: None,
|
|
risk_config: Some(&FidcRiskControlConfig::default()),
|
|
defer_selection_risk: true,
|
|
});
|
|
|
|
let selected_symbols = selected
|
|
.iter()
|
|
.map(|candidate| candidate.symbol.as_str())
|
|
.collect::<BTreeSet<_>>();
|
|
assert!(selected_symbols.contains("000001.SZ"));
|
|
assert!(selected_symbols.contains("688001.SH"));
|
|
assert!(selected_symbols.contains("000002.SZ"));
|
|
assert_eq!(diagnostics.not_eligible_count, 0);
|
|
assert!(diagnostics.risk_decisions.is_empty());
|
|
}
|
|
}
|