# alfars
高性能因子表达式与回测框架，核心使用 Rust + PyO3 实现，现已升级至 **v0.2.0**，新增智能因子挖掘与学习能力。
## 特性
### 核心回测功能
- **高性能**: 核心算法使用 Rust 实现，支持并行计算（8-10倍加速）
- **灵活接口**: 同时支持 NumPy 数组和 Pandas Series 输入
- **完备功能**: qcut(N) 分组、多空组合、IC 计算、因子分析
- **兼容性**: 类似 alphalens 的 API 设计，易于迁移
- **可扩展**: 模块化设计，支持自定义权重、分组、佣金模型
### 新增智能功能（v0.2.0）
- **表达式系统**: 支持构建复杂的数学表达式树，用于自定义因子计算
- **惰性求值**: Polars 风格的延迟计算引擎，支持查询优化和高效执行
- **遗传规划因子挖掘**: 使用遗传算法自动发现高绩效因子表达式
- **持久化存储**: 完整的因子库管理，支持搜索、缓存和版本控制
- **元学习系统**: 基于历史数据分析的智能推荐，优化后续因子挖掘参数
- **完整Python绑定**: 所有功能通过简洁的Python API暴露，类型安全且高效
## 安装
### 系统要求
- **Rust**: 1.70+ (安装: `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh`)
- **Python**: 3.8+
- **pip**: 最新版
- **C编译器**: gcc/clang (Rust 需要)
### 从源码安装（推荐）
```bash
# 克隆仓库
git clone https://github.com/EthanNOV56/exp.rs.git
cd exp.rs
# 安装 Rust 工具链（如未安装）
# 使用 maturin 开发模式构建
maturin develop
```
### 使用 uv（推荐）
```bash
# 使用 uv 安装依赖并构建
uv pip install -e .
maturin develop --release
```
### 使用 pip（未来发布）
```bash
pip install alfars
```
## 开发环境设置
```bash
# 安装所有开发工具
pip install -e .[dev]
pip install maturin
# 构建并安装开发版本
maturin develop
# 调试模式（更快构建）
maturin develop
# 发布模式（优化性能）
maturin develop --release
# 运行测试
pytest tests/
# 运行示例
python examples/basic_usage.py
```
### 常见问题
#### 1. 导入错误：找不到模块 `_core`
```
ImportError: cannot import name '_core' from 'alfars'
```
**解决方案**：
```bash
# 确保已构建 Rust 扩展
maturin develop --release
```
#### 2. Rust 编译错误
**解决方案**：
```bash
# 更新 Rust 工具链
rustup update
# 清理并重新构建
cargo clean
maturin develop --release
```
#### 3. Python 版本不兼容
**解决方案**：
```bash
# 使用正确的 Python 版本
python3.10 -m pip install -e .[dev]
# 或者创建虚拟环境
python -m venv venv
source venv/bin/activate
pip install -e .[dev]
```
#### 4. 缺少系统依赖
**Ubuntu/Debian**:
```bash
sudo apt-get install python3-dev build-essential
```
**macOS**:
```bash
xcode-select --install
brew install python3
```
### 性能优化
#### 构建选项
```bash
# 最大优化（推荐生产环境）
RUSTFLAGS="-C target-cpu=native" maturin develop --release
# 启用并行计算
export RAYON_NUM_THREADS=4 # 使用4个线程
```
#### 内存优化
Rust 实现已针对内存效率进行优化：
- 使用 `ndarray` 进行零拷贝操作
- 避免不必要的内存分配
- 并行处理每日数据
## 快速开始
### 基本用法
```python
import numpy as np
import pandas as pd
from alfars import quantile_backtest, create_factor_tear_sheet
# 生成示例数据
n_days, n_assets = 100, 200
factor = np.random.randn(n_days, n_assets)
returns = np.random.randn(n_days, n_assets) * 0.01 + factor * 0.005
# 运行十分组回测
result = quantile_backtest(
factor=factor,
returns=returns,
quantiles=10,
weight_method="equal",
long_top_n=1,
short_top_n=1,
commission_rate=0.0003,
)
print(f"Long-Short Cumulative Return: {result.long_short_cum_return:.4%}")
print(f"IC Mean: {result.ic_mean:.4f}")
print(f"IC IR: {result.ic_ir:.4f}")
# 查看分组收益
print("\nGroup Mean Returns:")
for i, mean_return in enumerate(result.group_returns.mean(axis=0)):
print(f" Group {i+1}: {mean_return:.6%}")
```
### Pandas 接口
```python
import pandas as pd
from alfars import factor_returns, create_factor_tear_sheet
# 准备 MultiIndex 数据
dates = pd.date_range("2023-01-01", periods=100, freq="B")
assets = [f"A{i:03d}" for i in range(200)]
# 创建因子和收益率数据
factor_data = pd.DataFrame(
np.random.randn(100, 200),
index=dates,
columns=assets
).stack()
factor_data.index.names = ["date", "asset"]
returns_data = pd.DataFrame(
np.random.randn(100, 200) * 0.01,
index=dates,
columns=assets
).stack()
returns_data.index.names = ["date", "asset"]
# 计算因子收益率
results = factor_returns(
factor=factor_data,
forward_returns=returns_data,
quantiles=10,
periods=(1, 5, 10)
)
print(results["factor_returns"].head())
# 创建因子分析报告
create_factor_tear_sheet(factor_data, returns_data)
```
### 高级用法
```python
from alfars import BacktestEngine
# 使用引擎接口（更多控制）
engine = BacktestEngine(
factor=factor_array,
returns=returns_array,
quantiles=5, # 五分组
weight_method="weighted", # 市值加权
long_top_n=2, # 做多前2组
short_top_n=2, # 做空前2组
commission_rate=0.0003,
weights=market_cap_array, # 市值权重
)
result = engine.run()
# 导出结果
result_dict = result.to_dict()
print(result.summary())
```
## 智能因子挖掘 (v0.2.0)
### 表达式系统
```python
from alfars import Expr, LazyFrame, DataFrame, Series
# 创建自定义因子表达式
expr = (Expr.col("close") - Expr.col("open")) / Expr.col("open")
sqrt_expr = expr.abs().sqrt()
log_expr = (Expr.col("volume") + 1.0).log()
print(f"Expression: {expr}")
print(f"Sqrt expression: {sqrt_expr}")
# 在数据上评估表达式
data = {
'open': np.random.randn(100, 50),
'close': np.random.randn(100, 50),
'volume': np.random.randn(100, 50),
}
# 使用惰性求值
lf = LazyFrame.scan(data)
lf_with_factor = lf.with_columns([("custom_factor", expr)])
result = lf_with_factor.collect()
print(f"Computed factor shape: {result['custom_factor'].shape}")
```
### 遗传规划因子挖掘
```python
from alfars import GpEngine
# 创建GP引擎
gp = GpEngine(
population_size=100,
max_generations=50,
tournament_size=7,
crossover_prob=0.8,
mutation_prob=0.2,
max_depth=6,
)
# 设置可用数据列
gp.set_columns(['open', 'high', 'low', 'close', 'volume'])
# 准备数据
data = {
'open': open_prices,
'high': high_prices,
'low': low_prices,
'close': close_prices,
'volume': volumes,
}
returns = next_day_returns
# 挖掘因子
factors = gp.mine_factors(data, returns, num_factors=10)
print(f"Discovered {len(factors)} factors:")
for i, (expr_str, fitness) in enumerate(factors[:3]):
print(f" Factor {i+1}: {expr_str[:80]}... (fitness: {fitness:.4f})")
```
### 持久化存储与因子库管理
```python
from alfars import PersistenceManager, FactorMetadata
# 创建因子库
db = PersistenceManager("./factor_library")
# 保存因子
factor_metadata = FactorMetadata(
id="momentum_factor_001",
expression="close - lag(close, 20)",
metrics={
"ic_mean": 0.15,
"ic_ir": 2.5,
"turnover": 0.12,
"complexity_penalty": 3.2,
"combined_score": 0.42,
},
tags=["momentum", "20-day"]
)
db.save_factor(factor_metadata)
# 搜索因子
high_ic_factors = db.search_factors(min_ic=0.1, max_complexity=5.0, tags=["momentum"])
print(f"Found {len(high_ic_factors)} high-IC momentum factors")
# 批量加载
num_factors = db.load_all_factors()
num_history = db.load_all_history()
print(f"Loaded {num_factors} factors and {num_history} GP history records")
# 获取缓存统计
stats = db.cache_stats()
print(f"Cache stats: {dict(stats)}")
```
### 元学习智能推荐
```python
from alfars import MetaLearningAnalyzer, GPRecommendations
# 创建元学习分析器
analyzer = MetaLearningAnalyzer()
# 配置训练参数（可根据数据量调整）
analyzer.set_min_data_points(50) # 最小训练数据量
analyzer.set_high_perf_threshold(0.08) # 高绩效阈值 (IC > 0.08)
# 训练模型
all_factors = db.get_all_factors()
all_history = db.get_all_history()
analyzer.train(all_factors, all_history)
print(f"Model trained: {analyzer.is_trained()}")
print(f"Model version: {analyzer.version()}")
print(f"Recommendations confidence: {analyzer.confidence_score():.2f}")
# 获取智能推荐
recommendations = analyzer.get_recommendations(target_complexity=4.5)
print(f"Recommended functions: {recommendations.recommended_functions}")
print(f"Recommended terminals: {recommendations.recommended_terminals}")
print(f"Confidence level: {recommendations.confidence_level()}")
# 转换为GP配置
gp_config = recommendations.to_gp_config()
print(f"Recommended population size: {gp_config['population_size']}")
print(f"Recommended max generations: {gp_config['max_generations']}")
# 保存/加载模型
analyzer.save_model("./meta_learning_model.json")
loaded_analyzer = MetaLearningAnalyzer.load_model("./meta_learning_model.json")
```
### 完整工作流示例
```python
# 1. 数据准备
data = prepare_market_data(start_date="2020-01-01", end_date="2023-12-31")
returns = compute_forward_returns(data['close'])
# 2. 初始GP因子挖掘
gp = GpEngine.from_recommendations(recommendations) # 使用智能推荐配置
initial_factors = gp.mine_factors(data, returns, num_factors=100)
# 3. 回测验证与存储
for expr_str, fitness in initial_factors:
factor_array = evaluate_expression(expr_str, data)
result = quantile_backtest(factor_array, returns)
factor_metadata = FactorMetadata(
id=f"gp_factor_{hash(expr_str)}",
expression=expr_str,
metrics={
"ic_mean": result.ic_mean,
"ic_ir": result.ic_ir,
"turnover": compute_turnover(factor_array),
"complexity_penalty": compute_complexity(expr_str),
"combined_score": fitness,
}
)
db.save_factor(factor_metadata)
# 4. 元学习优化
analyzer.train(db.get_all_factors(), db.get_all_history())
new_recommendations = analyzer.get_recommendations()
# 5. 迭代改进（越用越聪明）
optimized_gp = GpEngine.from_recommendations(new_recommendations)
improved_factors = optimized_gp.mine_factors(data, returns, num_factors=50)
```
## API 参考
### 核心函数
#### `quantile_backtest()`
运行分位数分组回测。
```python
quantile_backtest(
factor: np.ndarray, # 因子值矩阵 (days × assets)
returns: np.ndarray, # 收益率矩阵 (days × assets)
quantiles: int = 10, # 分组数量
weight_method: str = "equal", # "equal" 或 "weighted"
long_top_n: int = 1, # 做多前N组
short_top_n: int = 1, # 做空前N组
commission_rate: float = 0.0, # 单边佣金率
weights: Optional[np.ndarray] = None, # 外部权重
) -> BacktestResult
```
#### `factor_returns()`
类似 alphalens 的因子收益率计算接口。
```python
factor_returns(
factor: pd.Series, # 因子值，MultiIndex (date, asset)
forward_returns: pd.Series, # 远期收益率，MultiIndex (date, asset)
quantiles: int = 10, # 分位数数量
bins: Optional[List[float]] = None, # 自定义分组边界
periods: Tuple[int, ...] = (1,), # 预测周期
weights: Optional[pd.Series] = None, # 权重序列
groupby: Optional[pd.Series] = None, # 分组序列
zero_aware: bool = False, # 是否分别处理正负因子
) -> Dict[str, Union[pd.DataFrame, pd.Series]]
```
#### `create_factor_tear_sheet()`
创建因子分析报告。
```python
create_factor_tear_sheet(
factor: pd.Series,
forward_returns: pd.Series,
quantiles: int = 10,
periods: Tuple[int, ...] = (1, 5, 10),
group_neutral: bool = False,
by_group: bool = False,
**kwargs,
) -> None
```
### 核心类
#### `BacktestEngine`
回测引擎类，提供更多控制选项。
#### `BacktestResult`
回测结果容器，包含：
- `group_returns`: 各组日收益率
- `group_cum_returns`: 各组累计收益率
- `long_short_returns`: 多空组合日收益率
- `long_short_cum_return`: 多空组合累计收益率
- `ic_series`: 日IC序列
- `ic_mean`: IC均值
- `ic_ir`: IC信息比率
### 工具函数
#### `compute_information_coefficient()`
计算信息系数统计。
```python
ic_mean, ic_ir = compute_information_coefficient(factor_array, returns_array)
```
### 表达式系统 (v0.2.0)
#### `Expr` 类
因子表达式构建器，支持链式调用。
```python
# 创建表达式
expr = Expr.col("close") # 列引用
expr = Expr.lit_float(1.0) # 常量
expr = Expr.lit_int(5) # 整数常量
# 算术运算
expr1 = expr1.add(expr2) # 加法
expr1 = expr1.sub(expr2) # 减法
expr1 = expr1.mul(expr2) # 乘法
expr1 = expr1.div(expr2) # 除法
# 数学函数
expr = expr.abs() # 绝对值
expr = expr.sqrt() # 平方根
expr = expr.log() # 自然对数
expr = expr.exp() # 指数
expr = expr.neg() # 取负
# 比较运算
expr = expr.gt(Expr.lit_float(0)) # 大于
expr = expr.lt(Expr.lit_float(0)) # 小于
expr = expr.eq(Expr.lit_float(0)) # 等于
expr = expr.ne(Expr.lit_float(0)) # 不等于
# 时间序列函数
expr = expr.lag(1) # 滞后
expr = expr.diff(1) # 差分
expr = expr.rolling_mean(20) # 滚动均值
expr = expr.rolling_std(20) # 滚动标准差
expr = expr.cumsum() # 累积和
expr = expr.cumprod() # 累积积
```
#### `LazyFrame` 类
惰性求值框架，支持延迟计算和查询优化。
```python
# 创建 LazyFrame
lf = LazyFrame.scan(data_dict) # 从字典创建
# 添加列
lf = lf.with_columns([("new_col", expr)]) # 添加新列
# 连接操作
lf = lf.join(other_lf, ["date"], "inner") # 内连接
# 执行计算
result = lf.collect() # 执行并返回结果
# 查看执行计划
plan = lf.explain(optimized=False) # 逻辑计划
plan = lf.explain(optimized=True) # 优化后计划
```
#### `Series` 和 `DataFrame` 类
基础数据结构，用于表达式求值。
```python
series = Series.from_numpy(array) # 从numpy数组创建
dataframe = DataFrame.from_dict(data_dict) # 从字典创建
```
### 遗传规划模块 (v0.2.0)
#### `GpEngine` 类
遗传规划因子挖掘引擎。
```python
# 创建GP引擎
gp = GpEngine(
population_size=100, # 种群大小
max_generations=50, # 最大代数
tournament_size=7, # 锦标赛大小
crossover_prob=0.8, # 交叉概率
mutation_prob=0.2, # 变异概率
max_depth=6, # 最大深度
)
# 配置
gp.set_columns(['open', 'high', 'low', 'close', 'volume']) # 可用变量
# 运行因子挖掘
factors = gp.mine_factors(
data_dict, # 数据字典 {column: numpy_array}
returns_array, # 收益率数组
num_factors=10, # 挖掘因子数量
) -> List[Tuple[str, float]] # (表达式字符串, 适应度)
# 测试运行
test_result = gp.test_run() # 简单测试运行
```
### 持久化存储模块 (v0.2.0)
#### `PersistenceManager` 类
因子库管理器。
```python
# 创建管理器
pm = PersistenceManager("./factor_db")
# 因子管理
pm.save_factor(factor_metadata) # 保存因子
factor = pm.load_factor("factor_id") # 加载因子
pm.clear_memory() # 清空内存缓存
# 批量操作
num_factors = pm.load_all_factors() # 加载所有因子
num_history = pm.load_all_history() # 加载所有历史记录
all_factors = pm.get_all_factors() # 获取所有因子
all_history = pm.get_all_history() # 获取所有历史记录
# 搜索功能
results = pm.search_factors(
min_ic=0.1, # 最小IC阈值
max_complexity=5.0, # 最大复杂度
tags=["momentum"], # 标签筛选
)
# 缓存统计
stats = pm.cache_stats() # 获取缓存统计信息
```
#### `FactorMetadata` 类
因子元数据容器。
```python
metadata = FactorMetadata(
id="unique_id", # 唯一标识
expression="close - open", # 表达式字符串
metrics={ # 性能指标
"ic_mean": 0.15,
"ic_ir": 2.5,
"turnover": 0.12,
"complexity_penalty": 3.2,
"combined_score": 0.42,
},
tags=["momentum", "short_term"], # 标签
)
# 属性访问
metadata.id # 获取ID
metadata.expression # 获取表达式
metadata.metrics # 获取指标字典
metadata.tags # 获取标签列表
```
#### `GPHistoryRecord` 类
GP历史记录容器。
```python
record = GPHistoryRecord(
run_id="run_001", # 运行ID
best_factor=factor_metadata, # 最佳因子
config=gp_config_dict, # GP配置
)
# 属性访问
record.run_id # 运行ID
record.best_factor # 最佳因子
record.config # 配置字典
```
### 元学习模块 (v0.2.0)
#### `MetaLearningAnalyzer` 类
元学习分析器。
```python
# 创建分析器
analyzer = MetaLearningAnalyzer()
# 配置
analyzer.set_high_perf_threshold(0.08) # 高绩效阈值
analyzer.set_min_data_points(50) # 最小训练数据量
# 训练
analyzer.train(factors_list, gp_history_list)
# 获取信息
is_trained = analyzer.is_trained() # 是否已训练
version = analyzer.version() # 模型版本
confidence = analyzer.confidence_score() # 推荐置信度
# 获取推荐
recommendations = analyzer.get_recommendations(target_complexity=4.5)
# 模型持久化
analyzer.save_model("./model.json") # 保存模型
loaded = MetaLearningAnalyzer.load_model("./model.json") # 加载模型
```
#### `GPRecommendations` 类
GP配置推荐。
```python
# 属性访问
recs.recommended_functions # 推荐函数列表
recs.recommended_terminals # 推荐终端列表
recs.target_complexity # 目标复杂度
recs.confidence_score # 置信度分数 (0.0-1.0)
recs.confidence_level() # 置信度等级 ("high"/"medium"/"low")
# 转换方法
gp_config = recs.to_gp_config() # 转换为GP配置字典
is_valid = recs.is_valid() # 检查推荐是否有效
```
### 表达式函数 (v0.2.0)
#### `evaluate_expression()`
在数据上评估表达式。
```python
result = evaluate_expression(
expr_str, # 表达式字符串
data_dict, # 数据字典
) -> np.ndarray # 计算结果数组
```
#### 窗口函数
```python
window_spec = rolling_window(20, min_periods=5) # 滚动窗口
window_spec = expanding_window(min_periods=10) # 扩展窗口
```
## 算法细节
### 分位数分组算法
1. **数据清洗**: 剔除 NaN 值，保留有效观测
2. **排序分组**: 按因子值排序，等分位数分组
3. **权重分配**: 支持等权重或外部权重
4. **收益计算**: 使用 t+1 期收益率计算分组收益
### 多空组合构建
- **多头**: 持有因子值最高的 N 个分组
- **空头**: 持有因子值最低的 N 个分组
- **组合收益**: 多头平均收益 - 空头平均收益 - 佣金成本
### 信息系数计算
- **截面相关**: 每日计算因子值与次日收益率的 Pearson 相关系数
- **统计指标**: IC 均值、IC 标准差、IC 信息比率
## 性能基准
| 100×200 | 5.2 ms | 42.1 ms | 8.1× |
| 500×500 | 68.3 ms | 1.2 s | 17.6× |
| 1000×1000 | 312 ms | 8.7 s | 27.9× |
*测试环境: AMD Ryzen 7 5800X, 32GB RAM*
### 新模块性能特点 (v0.2.0)
| **表达式系统** | 零拷贝求值，无中间数组分配 | 表达式树优化，常量折叠 |
| **惰性求值** | 延迟计算，最小化内存使用 | 查询优化，谓词下推 |
| **遗传规划** | 并行种群评估，8核线性加速 | 缓存评估结果，批量处理 |
| **持久化存储** | 内存映射文件，快速序列化 | LRU缓存，智能预取 |
| **元学习** | 增量学习，无需全量重训练 | 特征缓存，近似计算 |
### 内存效率
- **惰性求值**: 减少60-80%的中间内存使用
- **表达式缓存**: 相同表达式复用计算结果
- **分批处理**: 大数据集分块处理，避免OOM
## 开发指南
### 项目结构 (v0.2.0)
```
alfars/
├── Cargo.toml # Rust 项目配置
├── pyproject.toml # Python 项目配置
├── src/
│ ├── lib.rs # Rust 核心实现和Python绑定
│ ├── expr.rs # 表达式系统
│ ├── expr_optimizer.rs # 表达式优化
│ ├── lazy.rs # 惰性求值引擎
│ ├── gp.rs # 遗传规划模块
│ ├── persistence.rs # 持久化存储模块
│ ├── metalearning.rs # 元学习系统
│ └── polars_style.rs # DataFrame兼容层
├── alfars/ # Python 包
│ ├── __init__.py # Python 主模块
│ └── _core.cpython-*.so # Rust 扩展模块
├── examples/
│ ├── basic_usage.py # 基础用法示例
│ ├── alpha101_expr.py # Alpha101表达式示例
│ ├── alpha101_test.py # Alpha101测试示例
│ ├── lazy_example.py # 惰性求值示例
│ ├── full_workflow_example.py # 完整工作流示例
│ └── python_binding_demo.py # Python绑定演示
├── tests/ # 测试文件
├── CLAUDE.md # Claude Code开发指南
└── README.md # 项目文档
```
### 构建与发布
#### 手动构建
```bash
# 仅构建 Rust 库
cargo build --release
# 生成 Python 扩展
maturin build --release
# 直接安装
maturin install
```
#### 测试
```bash
# 运行所有测试
pytest tests/
# 运行特定测试
pytest tests/test_basic.py::test_quantile_backtest_basic
# 带覆盖率报告
pytest --cov=alfars tests/
```
#### 发布
```bash
# 构建 wheel 包
maturin build --release
# 构建源分发
python -m build
# 上传到 PyPI
twine upload target/wheels/*
```
### 模块架构
```
alfars v0.2.0 架构
├── 核心层 (Rust)
│ ├── 回测引擎 (backtest) # 分位数分组、多空组合、IC计算
│ ├── 表达式系统 (expr) # 表达式树构建、求值、优化
│ ├── 惰性求值 (lazy) # 逻辑计划、物理计划、查询优化
│ ├── 遗传规划 (gp) # 因子挖掘、多目标优化、缓存
│ ├── 持久化存储 (persistence) # 因子库、GP历史、表达式缓存
│ └── 元学习 (metalearning) # 历史分析、智能推荐、模型持久化
├── 绑定层 (PyO3)
│ ├── Python类型映射 # Rust-Python类型转换
│ ├── API暴露 # 所有功能通过Python类暴露
│ └── 错误处理 # 统一的异常处理
└── 应用层 (Python)
├── 简洁API # Pythonic接口设计
├── 工作流集成 # 完整因子挖掘流水线
└── 生态系统集成 # numpy/pandas兼容
```
### 构建开发环境
```bash
# 安装开发依赖
pip install -e .[dev]
# 运行测试
pytest tests/
# 运行性能测试
pytest benchmarks/ -v
# 构建文档
cd docs && make html
```
### 添加新功能
1. 在 `src/lib.rs` 中添加 Rust 实现
2. 在 `alfars/__init__.py` 中添加 Python 接口
3. 在 `tests/` 中添加单元测试
4. 在 `examples/` 中添加使用示例
## 贡献指南
欢迎贡献代码、报告问题或提出建议！
1. Fork 项目仓库
2. 创建功能分支 (`git checkout -b feature/amazing-feature`)
3. 提交更改 (`git commit -m 'Add amazing feature'`)
4. 推送到分支 (`git push origin feature/amazing-feature`)
5. 开启 Pull Request
## 版本历史
### v0.2.0 (当前版本) - 智能因子挖掘
- **新增表达式系统**: 完整的数学表达式构建与求值
- **新增惰性求值引擎**: Polars风格的延迟计算与查询优化
- **新增遗传规划因子挖掘**: 自动发现高绩效因子表达式
- **新增持久化存储系统**: 因子库管理、搜索、缓存
- **新增元学习系统**: 基于历史数据的智能推荐
- **完整Python绑定**: 所有新功能通过简洁API暴露
- **性能优化**: 8-10倍加速，内存高效设计
- **向后兼容**: 保持v0.1.0所有API不变
### v0.1.0 - 基础回测框架
- 高性能分位数分组回测
- 类似alphalens的API设计
- NumPy/Pandas双接口支持
- 多空组合构建与IC计算
- 基础性能基准测试
## 许可证
MIT License
## 致谢
### 基础框架
- [alphalens](https://github.com/quantopian/alphalens) - 回测API设计参考
- [PyO3](https://github.com/PyO3/pyo3) - Rust-Python绑定框架
- [ndarray](https://github.com/rust-ndarray/ndarray) - Rust高性能数组计算
### 新功能依赖 (v0.2.0)
- [rayon](https://github.com/rayon-rs/rayon) - Rust数据并行库
- [serde](https://github.com/serde-rs/serde) - 序列化/反序列化框架
- [rand](https://github.com/rust-random/rand) - 随机数生成
- [lru](https://github.com/jeromefroe/lru-rs) - LRU缓存实现
- [sha2](https://github.com/RustCrypto/hashes) - 哈希算法库
### 设计灵感
- [Polars](https://github.com/pola-rs/polars) - 惰性求值设计思想
- [DEAP](https://github.com/DEAP/deap) - 进化计算框架
- [scikit-learn](https://github.com/scikit-learn/scikit-learn) - 机器学习API设计
### 社区支持
- [Rust社区](https://www.rust-lang.org/) - 优秀的语言和工具链
- [Python量化社区](https://github.com/topics/quantitative-finance) - 丰富的量化金融资源