ci / gate (push) Waiting to run
- 项目与文档标题: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
227 lines
7.1 KiB
Rust
227 lines
7.1 KiB
Rust
//! 数值联邦数据表 `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]);
|
||
}
|
||
}
|