use crate::error::CoreError;
use crate::modality::{FieldAxis, Modality};
use serde::{Deserialize, Serialize};
pub const SPEC_VERSION: &str = "rufield.mfs.v0.1";
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FieldTensor {
pub spec_version: String,
pub timestamp_ns: u64,
pub modality: Modality,
pub axes: Vec<FieldAxis>,
pub shape: Vec<usize>,
pub values: Vec<f32>,
pub confidence: f32,
pub noise_floor: f32,
pub calibration_id: Option<String>,
pub privacy_class: crate::privacy::PrivacyClass,
}
impl FieldTensor {
pub fn new(
timestamp_ns: u64,
modality: Modality,
axes: Vec<FieldAxis>,
shape: Vec<usize>,
values: Vec<f32>,
confidence: f32,
noise_floor: f32,
calibration_id: Option<String>,
privacy_class: crate::privacy::PrivacyClass,
) -> Result<Self, CoreError> {
let t = FieldTensor {
spec_version: SPEC_VERSION.to_string(),
timestamp_ns,
modality,
axes,
shape,
values,
confidence,
noise_floor,
calibration_id,
privacy_class,
};
t.validate()?;
Ok(t)
}
#[must_use]
pub fn element_count(&self) -> usize {
self.shape.iter().product()
}
pub fn validate(&self) -> Result<(), CoreError> {
let expected = self.element_count();
if expected != self.values.len() {
return Err(CoreError::ShapeMismatch {
expected,
actual: self.values.len(),
});
}
if self.axes.len() != self.shape.len() {
return Err(CoreError::AxisRankMismatch {
axes: self.axes.len(),
rank: self.shape.len(),
});
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::privacy::PrivacyClass;
#[test]
fn valid_tensor_round_trips() {
let t = FieldTensor::new(
1,
Modality::WifiCsi,
vec![FieldAxis::Time, FieldAxis::Frequency],
vec![2, 3],
vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0],
0.9,
0.01,
Some("cal_1".into()),
PrivacyClass::P0,
)
.unwrap();
assert_eq!(t.element_count(), 6);
let j = serde_json::to_string(&t).unwrap();
let back: FieldTensor = serde_json::from_str(&j).unwrap();
assert_eq!(t, back);
}
#[test]
fn shape_mismatch_rejected() {
let err = FieldTensor::new(
1,
Modality::WifiCsi,
vec![FieldAxis::Time, FieldAxis::Frequency],
vec![2, 3],
vec![0.0, 1.0],
0.9,
0.0,
None,
PrivacyClass::P0,
)
.unwrap_err();
matches!(err, CoreError::ShapeMismatch { .. });
}
#[test]
fn axis_rank_mismatch_rejected() {
let err = FieldTensor::new(
1,
Modality::WifiCsi,
vec![FieldAxis::Time],
vec![2, 3],
vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0],
0.9,
0.0,
None,
PrivacyClass::P0,
)
.unwrap_err();
matches!(err, CoreError::AxisRankMismatch { .. });
}
}