Files
ssw-mpc/crates/mpc-data/src/frame.rs
T
admin 54781b3f83
ci / gate (push) Waiting to run
refactor: 项目改名 ssw-mpc,crate 统一到 mpc-* 前缀
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc
- 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_*
- 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so
- 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容
- 新增 [profile.dev] incremental=false
2026-11-05 15:06:12 +08:00

227 lines
7.1 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 数值联邦数据表 `Frame`,对齐 `refs/nax/nax/data/frame.py` 的本地算法层。
//!
//! 参考实现里 `VFrame`/`HFrame` 的分布式外壳(`Site`/`Vault`/PSI 对齐)复用既有原语;
//! 这里把**本地数据平面**落成列主序 `f64` 表:列选择 / 丢弃、取矩阵、列和、列平方和。
//! 统计量在 [`crate::stats`],mock 合成在 [`crate::mock`]。
/// 列主序数值表:`data[j]` 是第 j 列(长度 n)。
#[derive(Clone, Debug, PartialEq)]
pub struct Frame {
pub columns: Vec<String>,
pub data: Vec<Vec<f64>>,
}
impl Frame {
/// 构造并校验:列数 == 数据块数,各列等长。
pub fn new(columns: Vec<String>, data: Vec<Vec<f64>>) -> Result<Self, String> {
if columns.len() != data.len() {
return Err(format!(
"列名 {} 个,数据块 {} 个,不匹配",
columns.len(),
data.len()
));
}
if let Some(first) = data.first() {
let n = first.len();
for (j, col) in data.iter().enumerate() {
if col.len() != n {
return Err(format!(
"第 {j} 列长度 {} ≠ 首列 {n}",
col.len()
));
}
}
}
Ok(Self { columns, data })
}
/// 全数值表(无列名,用 c0.. 占位)。
pub fn from_rows(rows: Vec<Vec<f64>>) -> Result<Self, String> {
let ncols = rows.first().map(|r| r.len()).unwrap_or(0);
for (i, r) in rows.iter().enumerate() {
if r.len() != ncols {
return Err(format!("第 {i} 行长度 {} ≠ {ncols}", r.len()));
}
}
let nrows = rows.len();
let mut data = vec![vec![0.0; nrows]; ncols];
for (i, r) in rows.iter().enumerate() {
for j in 0..ncols {
data[j][i] = r[j];
}
}
let columns = (0..ncols).map(|j| format!("c{j}")).collect();
Ok(Self { columns, data })
}
pub fn nrows(&self) -> usize {
self.data.first().map(|c| c.len()).unwrap_or(0)
}
pub fn ncols(&self) -> usize {
self.data.len()
}
pub fn column_names(&self) -> &[String] {
&self.columns
}
/// 取某一列,找不到返回 `None`。
pub fn column(&self, name: &str) -> Option<&[f64]> {
self.columns
.iter()
.position(|c| c == name)
.map(|j| self.data[j].as_slice())
}
fn index_of(&self, name: &str) -> Result<usize, String> {
self.columns
.iter()
.position(|c| c == name)
.ok_or_else(|| format!("列 {name:?} 不存在(有 {:?})", self.columns))
}
/// 按给定顺序选列。
pub fn select(&self, cols: &[&str]) -> Result<Frame, String> {
let mut idx = Vec::with_capacity(cols.len());
for c in cols {
idx.push(self.index_of(c)?);
}
let columns = idx.iter().map(|&j| self.columns[j].clone()).collect();
let data = idx.iter().map(|&j| self.data[j].clone()).collect();
Ok(Frame { columns, data })
}
/// 丢弃指定列。
pub fn drop_cols(&self, cols: &[&str]) -> Result<Frame, String> {
let drop: Vec<usize> = cols
.iter()
.map(|c| self.index_of(c))
.collect::<Result<_, _>>()?;
let mut columns = Vec::new();
let mut data = Vec::new();
for (j, name) in self.columns.iter().enumerate() {
if !drop.contains(&j) {
columns.push(name.clone());
data.push(self.data[j].clone());
}
}
Ok(Frame { columns, data })
}
/// 取行主序矩阵 `(n, k)`。`columns` 指定保留列,`drop` 指定丢弃列。
pub fn matrix(
&self,
columns: Option<&[&str]>,
drop: Option<&[&str]>,
) -> Result<Vec<Vec<f64>>, String> {
let keep: Vec<usize> = match columns {
Some(cs) => cs
.iter()
.map(|c| self.index_of(c))
.collect::<Result<_, _>>()?,
None => (0..self.ncols()).collect(),
};
let drop_idx: Vec<usize> = match drop {
Some(ds) => ds
.iter()
.map(|c| self.index_of(c))
.collect::<Result<_, _>>()?,
None => Vec::new(),
};
let keep: Vec<usize> = keep.into_iter().filter(|j| !drop_idx.contains(j)).collect();
let n = self.nrows();
let mut out = vec![vec![0.0; keep.len()]; n];
for (k, &j) in keep.iter().enumerate() {
for i in 0..n {
out[i][k] = self.data[j][i];
}
}
Ok(out)
}
/// 列和(各列分别求和),对齐 `_f_colsum`。
pub fn colsum(&self) -> Vec<f64> {
self.data.iter().map(|c| c.iter().sum()).collect()
}
/// 列平方和,对齐 `_f_colsumsq`。
pub fn colsumsq(&self) -> Vec<f64> {
self.data
.iter()
.map(|c| c.iter().map(|v| v * v).sum())
.collect()
}
/// 第 i 行(行主序)。
pub fn row(&self, i: usize) -> Vec<f64> {
self.data.iter().map(|c| c[i]).collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sample() -> Frame {
Frame::new(
vec!["a".into(), "b".into(), "c".into()],
vec![
vec![1.0, 2.0, 3.0, 4.0],
vec![2.0, 4.0, 6.0, 9.0],
vec![10.0, 20.0, 30.0, 40.0],
],
)
.unwrap()
}
#[test]
fn construct_and_shape() {
let f = sample();
assert_eq!(f.nrows(), 4);
assert_eq!(f.ncols(), 3);
assert_eq!(f.column_names(), &["a", "b", "c"]);
assert_eq!(f.column("b").unwrap(), &[2.0, 4.0, 6.0, 9.0]);
assert!(f.column("zzz").is_none());
}
#[test]
fn construct_rejects_ragged() {
let bad = Frame::new(vec!["a".into(), "b".into()], vec![vec![1.0], vec![1.0, 2.0]]);
assert!(bad.is_err());
let bad2 = Frame::new(vec!["a".into()], vec![]);
assert!(bad2.is_err());
}
#[test]
fn select_drop_and_matrix() {
let f = sample();
let s = f.select(&["c", "a"]).unwrap();
assert_eq!(s.column_names(), &["c", "a"]);
assert_eq!(s.data[0], vec![10.0, 20.0, 30.0, 40.0]);
let d = f.drop_cols(&["b"]).unwrap();
assert_eq!(d.column_names(), &["a", "c"]);
let m = f.matrix(Some(&["a", "b"]), None).unwrap();
assert_eq!(m, vec![vec![1.0, 2.0], vec![2.0, 4.0], vec![3.0, 6.0], vec![4.0, 9.0]]);
let m2 = f.matrix(None, Some(&["c"])).unwrap();
assert_eq!(m2[0], vec![1.0, 2.0]);
assert_eq!(m2[3], vec![4.0, 9.0]);
}
#[test]
fn colsum_and_squares() {
let f = sample();
assert_eq!(f.colsum(), vec![10.0, 21.0, 100.0]);
// 1+4+9+16=30, 4+16+36+81=137, 100+400+900+1600=3000
assert_eq!(f.colsumsq(), vec![30.0, 137.0, 3000.0]);
}
#[test]
fn row_access() {
let f = sample();
assert_eq!(f.row(2), vec![3.0, 6.0, 30.0]);
}
}