use crate::descriptor::cursor::{ByteCursor, ByteWriter};
use crate::{Error, Result};
const STATISTICS_BYTE_LEN: usize = 72;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StatisticsMask(pub u32);
impl StatisticsMask {
pub const NNZ_VALID: u32 = 1 << 0;
pub const SPARSITY_VALID: u32 = 1 << 1;
pub const VALUE_RANGE_VALID: u32 = 1 << 2;
pub const VALUE_STATS_VALID: u32 = 1 << 3;
pub const NM_SPARSITY_VALID: u32 = 1 << 4;
pub const NAN_INF_VALID: u32 = 1 << 5;
const RESERVED_MASK: u32 = !0x3F;
#[inline]
pub fn nnz_valid(self) -> bool {
self.0 & Self::NNZ_VALID != 0
}
#[inline]
pub fn sparsity_valid(self) -> bool {
self.0 & Self::SPARSITY_VALID != 0
}
#[inline]
pub fn value_range_valid(self) -> bool {
self.0 & Self::VALUE_RANGE_VALID != 0
}
#[inline]
pub fn value_stats_valid(self) -> bool {
self.0 & Self::VALUE_STATS_VALID != 0
}
#[inline]
pub fn nm_sparsity_valid(self) -> bool {
self.0 & Self::NM_SPARSITY_VALID != 0
}
#[inline]
pub fn nan_inf_valid(self) -> bool {
self.0 & Self::NAN_INF_VALID != 0
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct Statistics {
pub computed_mask: StatisticsMask,
pub nnz: u64,
pub sparsity_ratio: f64,
pub value_min: f64,
pub value_max: f64,
pub value_abs_max: f64,
pub value_mean: f64,
pub value_stddev: f64,
pub nm_n: u8,
pub nm_m: u8,
pub has_nan: bool,
pub has_inf: bool,
}
impl Statistics {
pub(crate) fn encode_into(&self, w: &mut ByteWriter) {
w.write_u32_le(self.computed_mask.0); w.write_u32_le(0u32); w.write_u64_le(self.nnz); w.write_f64_le(self.sparsity_ratio); w.write_f64_le(self.value_min); w.write_f64_le(self.value_max); w.write_f64_le(self.value_abs_max); w.write_f64_le(self.value_mean); w.write_f64_le(self.value_stddev); w.write_u8(self.nm_n); w.write_u8(self.nm_m); w.write_u8(u8::from(self.has_nan)); w.write_u8(u8::from(self.has_inf)); w.write_zeros(4); }
pub(crate) fn decode_from(cursor: &mut ByteCursor<'_>) -> Result<Self> {
let start_pos = cursor.pos();
let computed_mask_raw = cursor.read_u32_le()?; let reserved1 = cursor.read_u32_le()?; let nnz = cursor.read_u64_le()?; let sparsity_ratio = cursor.read_f64_le()?; let value_min = cursor.read_f64_le()?; let value_max = cursor.read_f64_le()?; let value_abs_max = cursor.read_f64_le()?; let value_mean = cursor.read_f64_le()?; let value_stddev = cursor.read_f64_le()?; let nm_n = cursor.read_u8()?; let nm_m = cursor.read_u8()?; let has_nan_raw = cursor.read_u8()?; let has_inf_raw = cursor.read_u8()?; let reserved2 = cursor.read_bytes(4)?;
debug_assert_eq!(cursor.pos() - start_pos, STATISTICS_BYTE_LEN);
if computed_mask_raw & StatisticsMask::RESERVED_MASK != 0 {
return Err(Error::StatisticsReservedMaskBitsSet {
mask: computed_mask_raw,
});
}
if reserved1 != 0 {
return Err(Error::ReservedBytesNonZero {
field: "statistics._reserved",
});
}
if reserved2 != [0u8, 0, 0, 0] {
return Err(Error::ReservedBytesNonZero {
field: "statistics._reserved2",
});
}
Ok(Self {
computed_mask: StatisticsMask(computed_mask_raw),
nnz,
sparsity_ratio,
value_min,
value_max,
value_abs_max,
value_mean,
value_stddev,
nm_n,
nm_m,
has_nan: has_nan_raw != 0,
has_inf: has_inf_raw != 0,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::descriptor::cursor::{ByteCursor, ByteWriter};
fn sample_stats() -> Statistics {
Statistics {
computed_mask: StatisticsMask(
StatisticsMask::NNZ_VALID
| StatisticsMask::SPARSITY_VALID
| StatisticsMask::VALUE_RANGE_VALID
| StatisticsMask::VALUE_STATS_VALID
| StatisticsMask::NM_SPARSITY_VALID
| StatisticsMask::NAN_INF_VALID,
),
nnz: 1000,
sparsity_ratio: 0.5,
value_min: -1.0,
value_max: 1.0,
value_abs_max: 1.0,
value_mean: 0.0,
value_stddev: 0.5,
nm_n: 2,
nm_m: 4,
has_nan: false,
has_inf: true,
}
}
#[test]
fn statistics_round_trip() {
let stats = sample_stats();
let mut w = ByteWriter::new();
stats.encode_into(&mut w);
let bytes = w.into_vec();
assert_eq!(bytes.len(), STATISTICS_BYTE_LEN);
let mut c = ByteCursor::new(&bytes, bytes.len());
let decoded = Statistics::decode_from(&mut c).unwrap();
assert_eq!(decoded.computed_mask, stats.computed_mask);
assert_eq!(decoded.nnz, stats.nnz);
assert_eq!(decoded.sparsity_ratio, stats.sparsity_ratio);
assert_eq!(decoded.value_min, stats.value_min);
assert_eq!(decoded.value_max, stats.value_max);
assert_eq!(decoded.value_abs_max, stats.value_abs_max);
assert_eq!(decoded.value_mean, stats.value_mean);
assert_eq!(decoded.value_stddev, stats.value_stddev);
assert_eq!(decoded.nm_n, stats.nm_n);
assert_eq!(decoded.nm_m, stats.nm_m);
assert_eq!(decoded.has_nan, stats.has_nan);
assert_eq!(decoded.has_inf, stats.has_inf);
}
#[test]
fn statistics_reserved_mask_bits_rejected() {
let mut w = ByteWriter::new();
w.write_u32_le(0x0000_0040u32);
w.write_zeros(68);
let bytes = w.into_vec();
let mut c = ByteCursor::new(&bytes, bytes.len());
let err = Statistics::decode_from(&mut c).unwrap_err();
assert!(matches!(err, Error::StatisticsReservedMaskBitsSet { .. }));
}
#[test]
fn statistics_reserved_bytes_rejected() {
let mut w = ByteWriter::new();
w.write_u32_le(0u32); w.write_u32_le(1u32); w.write_zeros(64);
let bytes = w.into_vec();
let mut c = ByteCursor::new(&bytes, bytes.len());
let err = Statistics::decode_from(&mut c).unwrap_err();
assert!(matches!(err, Error::ReservedBytesNonZero { .. }));
}
#[test]
fn statistics_reserved2_bytes_rejected() {
let mut w = ByteWriter::new();
w.write_u32_le(0u32); w.write_u32_le(0u32); w.write_zeros(60); w.write_u8(0x01); w.write_zeros(3);
let bytes = w.into_vec();
let mut c = ByteCursor::new(&bytes, bytes.len());
let err = Statistics::decode_from(&mut c).unwrap_err();
assert!(matches!(err, Error::ReservedBytesNonZero { .. }));
}
#[test]
fn encoded_length_is_72_bytes() {
let mut w = ByteWriter::new();
sample_stats().encode_into(&mut w);
assert_eq!(w.len(), STATISTICS_BYTE_LEN);
}
}