rust-pyfunc 0.43.0__tar.gz → 0.44.1__tar.gz

{rust_pyfunc-0.43.0 → rust_pyfunc-0.44.1}/Cargo.lock

@@ -2016,9 +2016,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "roots"
+version = "0.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "082f11ffa03bbef6c2c6ea6bea1acafaade2fd9050ae0234ab44a2153742b058"
+
 [[package]]
 name = "rust_pyfunc"
-version = "0.43.0"
+version = "0.44.1"
 dependencies = [
  "arrow",
  "base64 0.21.7",
@@ -2029,6 +2035,7 @@ dependencies = [
  "faer",
  "lapack",
  "libc",
+ "log",
  "memmap2",
  "nalgebra",
  "ndarray",
@@ -2044,6 +2051,7 @@ dependencies = [
  "rand",
  "rayon",
  "rmp-serde",
+ "roots",
  "rustc-hash",
  "serde",
  "serde_json",

{rust_pyfunc-0.43.0 → rust_pyfunc-0.44.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust_pyfunc"
-version = "0.43.0"
+version = "0.44.1"
 edition = "2021"
 description = "A collection of high-performance Python functions implemented in Rust"
 readme = "README.md"
@@ -41,6 +41,8 @@ arrow = "51.0"
 parquet = "51.0"
 rustc-hash = "1.1"
 thiserror = "1.0"
+roots = "0.0.8"
+log = "0.4"
 # Unix-specific dependencies for fork mode
 [target.'cfg(unix)'.dependencies]
 nix = { version = "0.27", features = ["process", "signal", "fs"] }

{rust_pyfunc-0.43.0 → rust_pyfunc-0.44.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust_pyfunc
-Version: 0.43.0
+Version: 0.44.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{rust_pyfunc-0.43.0 → rust_pyfunc-0.44.1}/python/rust_pyfunc/statistical_analysis.pyi

@@ -1000,4 +1000,110 @@ def hmm_trend_prediction(
     ...     columns=['更新后下跌概率', '更新后震荡概率', '更新后上涨概率']
     ... )
     """
+    ...
+
+def distances_to_frontier(
+    r: NDArray[np.float64],
+    group_size: int,
+    drop_last: bool = True,
+    ddof: int = 1,
+    ridge: float = 1e-6
+) -> NDArray[np.float64]:
+    """计算收益序列中每个聚合块到马科维茨有效前沿的距离。
+
+    基于马科维茨投资组合理论的有效前沿距离计算功能。给定单日3秒频率收益序列，
+    按指定块大小聚合后计算每个资产点到有效前沿的最短距离。
+
+    算法步骤：
+    1. 数据分块聚合：将收益序列按指定大小分块，计算每块均值
+    2. 协方差矩阵计算：计算块间样本协方差矩阵（带岭化保证正定性）
+    3. 有效前沿构造：使用马科维茨无约束闭式解构造有效前沿
+    4. 距离计算：使用KKT-λ四次方程法计算每个资产点到前沿的最短欧氏距离
+
+    参数说明：
+    ----------
+    r : NDArray[np.float64]
+        1D float64数组，单日3秒频率收益序列
+    group_size : int
+        每多少行聚合成一块（x），必须大于0
+    drop_last : bool, default=True
+        尾部不足group_size行时是否丢弃，True丢弃，False则报错
+    ddof : int, default=1
+        协方差/方差的自由度调整，0或1，默认1（样本协方差）
+    ridge : float, default=1e-6
+        岭化强度系数，用于保证协方差矩阵正定
+
+    返回值：
+    -------
+    NDArray[np.float64]
+        shape=(m,)的1D数组，包含每个资产点到有效前沿的距离
+        其中m = floor(len(r) / group_size)（如果drop_last=True）
+
+    异常：
+    -----
+    ValueError
+        当输入参数无效时抛出：
+        - group_size <= 0
+        - 输入序列为空
+        - drop_last=False且序列长度不能被group_size整除
+        - 块大小 <= 自由度调整
+        - 协方差矩阵不正定（可尝试增大ridge）
+        - 有效前沿参数计算失败（Δ <= 0）
+
+    数值提示：
+    --------
+    - 当 m >> group_size 时，协方差矩阵可能秩亏，需要通过增大ridge参数保证可逆性
+    - 如果出现数值不稳定错误，建议将ridge增大10倍或100倍
+    - 默认使用样本协方差（ddof=1），符合统计学习习惯
+
+    性能特点：
+    --------
+    - 使用Rust实现，计算性能优异
+    - 采用Cholesky分解避免显式矩阵求逆，数值稳定性好
+    - 支持大规模数据处理，内存使用优化
+    - 多项式求根采用高效算法，避免数值迭代
+
+    应用场景：
+    --------
+    - 投资组合绩效评估：评估各时间段表现相对有效前沿的距离
+    - 市场效率分析：通过距离分布判断市场效率变化
+    - 风险管理：识别偏离有效前沿的异常时期
+    - 资产配置优化：为动态调整提供量化依据
+
+    示例：
+    -----
+    >>> import numpy as np
+    >>> from rust_pyfunc import distances_to_frontier
+    >>>
+    >>> # 生成测试数据
+    >>> np.random.seed(0)
+    >>> r = 1e-4 * np.random.randn(4800).astype(np.float64)
+    >>>
+    >>> # 每1分钟聚合（20个3秒间隔）
+    >>> distances = distances_to_frontier(r, group_size=20)
+    >>> print(f"距离数组形状: {distances.shape}")  # (240,)
+    >>> print(f"平均距离: {np.mean(distances):.6e}")
+    >>>
+    >>> # 每2分半聚合（50个3秒间隔）
+    >>> distances2 = distances_to_frontier(r, group_size=50)
+    >>> print(f"距离数组形状: {distances2.shape}")  # (96,)
+    >>>
+    >>> # 增大岭化系数处理病态数据
+    >>> distances3 = distances_to_frontier(r, group_size=100, ridge=1e-4)
+    >>> print(f"距离数组形状: {distances3.shape}")  # (48,)
+    >>>
+    >>> # 分析距离分布
+    >>> import matplotlib.pyplot as plt
+    >>> plt.hist(distances, bins=30, alpha=0.7)
+    >>> plt.xlabel('到有效前沿的距离')
+    >>> plt.ylabel('频次')
+    >>> plt.title('距离分布直方图')
+    >>> plt.show()
+
+    注意：
+    -----
+    - 函数保证返回的距离值非负且有限
+    - 在极少数情况下如果多项式求根失败，对应距离会设为0并发出警告
+    - 所有计算都使用双精度浮点数，确保数值精度
+    """
     ...

{rust_pyfunc-0.43.0 → rust_pyfunc-0.44.1}/src/backup_reader.rs

@@ -1,5 +1,7 @@
 use memmap2::Mmap;
+use numpy::PyArray1;
 use pyo3::prelude::*;
+use rayon::iter::IndexedParallelIterator;
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
@@ -2138,6 +2140,16 @@ pub fn read_backup_results_factor_only_ultra_fast(
         })?
     };
 
+    #[cfg(target_family = "unix")]
+    unsafe {
+        // 提示内核按顺序访问，增加预读窗口
+        let _ = libc::madvise(
+            mmap.as_ptr() as *mut libc::c_void,
+            file_len,
+            libc::MADV_SEQUENTIAL,
+        );
+    }
+
     // 读取文件头
     let header = unsafe { &*(mmap.as_ptr() as *const FileHeader) };
 
@@ -2147,10 +2159,7 @@ pub fn read_backup_results_factor_only_ultra_fast(
 
     let record_count = header.record_count as usize;
     if record_count == 0 {
-        return Python::with_gil(|py| {
-            let numpy = py.import("numpy")?;
-            Ok(numpy.call_method1("array", (Vec::<f64>::new(),))?.into())
-        });
+        return Python::with_gil(|py| Ok(PyArray1::<f64>::from_vec(py, Vec::new()).into_py(py)));
     }
 
     let record_size = header.record_size as usize;
@@ -2196,29 +2205,28 @@ pub fn read_backup_results_factor_only_ultra_fast(
         })?;
 
     // 并行读取所有因子值
-    let factors: Vec<f64> = pool.install(|| {
-        (0..record_count)
-            .into_par_iter()
-            .map(|i| {
+    let mut factors = vec![0f64; record_count];
+    pool.install(|| {
+        factors
+            .par_iter_mut()
+            .enumerate()
+            .with_min_len(4096)
+            .for_each(|(i, slot)| {
                 let record_offset = records_start + i * record_size;
 
                 // 直接读取因子值，完全跳过其他字段的解析
                 unsafe {
                     let factor_ptr = mmap.as_ptr().add(record_offset + factor_offset) as *const f64;
-                    *factor_ptr
+                    *slot = *factor_ptr;
                 }
-            })
-            .collect()
+            });
     });
 
     // 显式释放mmap
     drop(mmap);
 
     // 创建numpy数组
-    Python::with_gil(|py| {
-        let numpy = py.import("numpy")?;
-        Ok(numpy.call_method1("array", (factors,))?.into())
-    })
+    Python::with_gil(|py| Ok(PyArray1::from_vec(py, factors).into_py(py)))
 }
 
 /// 超高速查询备份文件中的指定列（完整版本v2）

{rust_pyfunc-0.43.0 → rust_pyfunc-0.44.1}/src/factor_neutralization_io_optimized.rs

@@ -703,9 +703,7 @@ pub fn batch_factor_neutralization_io_optimized(
             // 显示进度：有处理进展或者已经运行超过5秒
             if processed > 0 || elapsed.as_secs() >= 5 {
                 let current_time = Local::now().format("%Y-%m-%d %H:%M:%S");
-                print!("\r[{}] 📊 处理进度: {}/{} ({:.1}%) - 成功: {}, 失败: {} - 已用时间: {} - 预计剩余: {}", 
-                         current_time, processed, total_files, progress_percent, 
-                         success_count, errors, elapsed_time_str, remaining_time_str);
+                print!("\r[{}] 📊 处理进度: {}/{} ({:.1}%) - 成功: {}, 失败: {} - 已用时间: {} - 预计剩余: {}", current_time, processed, total_files, progress_percent, success_count, errors, elapsed_time_str, remaining_time_str);
                 io::stdout().flush().unwrap();
             }
         }