use std::fmt;
use crate::Error;
pub const DYNAMIC: u64 = u64::MAX;
pub const MAX_RANK: usize = 64;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Shape(Vec<u64>);
impl Shape {
pub fn new(dims: impl Into<Vec<u64>>) -> crate::Result<Self> {
let dims = dims.into();
if dims.len() > MAX_RANK {
return Err(Error::RankExceedsMaximum {
rank: dims.len() as u32,
max: MAX_RANK as u32,
});
}
Ok(Self(dims))
}
#[inline]
pub fn scalar() -> Self {
Self(Vec::new())
}
#[inline]
pub fn rank(&self) -> usize {
self.0.len()
}
#[inline]
pub fn dims(&self) -> &[u64] {
&self.0
}
pub fn element_count(&self) -> Option<u64> {
let mut product: u64 = 1;
for &dim in &self.0 {
if dim == DYNAMIC {
return None;
}
product = product.checked_mul(dim)?;
}
Some(product)
}
#[inline]
pub fn is_empty_tensor(&self) -> bool {
self.0.contains(&0)
}
#[inline]
pub fn has_dynamic(&self) -> bool {
self.0.contains(&DYNAMIC)
}
}
impl fmt::Display for Shape {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("[")?;
for (i, &dim) in self.0.iter().enumerate() {
if i > 0 {
f.write_str(", ")?;
}
if dim == DYNAMIC {
f.write_str("?")?;
} else {
write!(f, "{dim}")?;
}
}
f.write_str("]")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn new_rank_0_succeeds() {
let s = Shape::new(vec![]).expect("rank 0 is valid");
assert_eq!(s.rank(), 0);
}
#[test]
fn new_rank_1_succeeds() {
let s = Shape::new(vec![42]).expect("rank 1 is valid");
assert_eq!(s.rank(), 1);
assert_eq!(s.dims(), &[42]);
}
#[test]
fn new_rank_64_succeeds() {
let s = Shape::new(vec![1u64; 64]).expect("rank 64 is valid (MAX_RANK)");
assert_eq!(s.rank(), 64);
}
#[test]
fn new_rank_65_returns_rank_exceeds_maximum() {
let result = Shape::new(vec![1u64; 65]);
assert!(
matches!(result, Err(Error::RankExceedsMaximum { rank: 65, max: 64 })),
"expected RankExceedsMaximum for rank 65, got {result:?}"
);
}
#[test]
fn new_rank_100_returns_rank_exceeds_maximum() {
let result = Shape::new(vec![1u64; 100]);
assert!(matches!(
result,
Err(Error::RankExceedsMaximum { rank: 100, max: 64 })
));
}
#[test]
fn scalar_has_rank_0() {
assert_eq!(Shape::scalar().rank(), 0);
}
#[test]
fn scalar_dims_is_empty() {
assert_eq!(Shape::scalar().dims(), &[] as &[u64]);
}
#[test]
fn scalar_element_count_is_one() {
assert_eq!(Shape::scalar().element_count(), Some(1));
}
#[test]
fn scalar_is_not_empty_tensor() {
assert!(!Shape::scalar().is_empty_tensor());
}
#[test]
fn scalar_has_no_dynamic() {
assert!(!Shape::scalar().has_dynamic());
}
#[test]
fn rank_matches_dims_len() {
for n in [0, 1, 2, 10, 64] {
let s = Shape::new(vec![3u64; n]).expect("valid");
assert_eq!(s.rank(), n, "rank mismatch for n={n}");
}
}
#[test]
fn dims_returns_original_slice() {
let input = vec![3u64, 4, 5];
let s = Shape::new(input.clone()).expect("valid");
assert_eq!(s.dims(), input.as_slice());
}
#[test]
fn dims_is_empty_for_scalar() {
assert!(Shape::scalar().dims().is_empty());
}
#[test]
fn element_count_static_shape_3x4x5() {
let s = Shape::new(vec![3, 4, 5]).expect("valid");
assert_eq!(s.element_count(), Some(60));
}
#[test]
fn element_count_1d_shape() {
assert_eq!(Shape::new(vec![7]).unwrap().element_count(), Some(7));
}
#[test]
fn element_count_scalar_is_one() {
assert_eq!(Shape::scalar().element_count(), Some(1));
}
#[test]
fn element_count_with_zero_dim_is_zero() {
assert_eq!(Shape::new(vec![3, 0, 5]).unwrap().element_count(), Some(0));
}
#[test]
fn element_count_all_zero_dims_is_zero() {
assert_eq!(Shape::new(vec![0, 0]).unwrap().element_count(), Some(0));
}
#[test]
fn element_count_with_dynamic_is_none() {
assert_eq!(
Shape::new(vec![1, DYNAMIC, 768]).unwrap().element_count(),
None
);
}
#[test]
fn element_count_all_dynamic_is_none() {
assert_eq!(
Shape::new(vec![DYNAMIC, DYNAMIC]).unwrap().element_count(),
None
);
}
#[test]
fn element_count_overflow_returns_none() {
let big = u64::MAX / 2 + 1;
let s = Shape::new(vec![big, 2]).expect("rank 2 is valid");
assert_eq!(s.element_count(), None);
}
#[test]
fn is_empty_tensor_true_when_one_dim_is_zero() {
assert!(Shape::new(vec![3, 0, 5]).unwrap().is_empty_tensor());
}
#[test]
fn is_empty_tensor_true_when_all_dims_zero() {
assert!(Shape::new(vec![0]).unwrap().is_empty_tensor());
}
#[test]
fn is_empty_tensor_false_for_static_nonzero_shape() {
assert!(!Shape::new(vec![3, 4, 5]).unwrap().is_empty_tensor());
}
#[test]
fn is_empty_tensor_false_for_dynamic_dim() {
assert!(!Shape::new(vec![1, DYNAMIC, 768]).unwrap().is_empty_tensor());
}
#[test]
fn is_empty_tensor_false_for_scalar() {
assert!(!Shape::scalar().is_empty_tensor());
}
#[test]
fn has_dynamic_true_when_one_dim_is_dynamic() {
assert!(Shape::new(vec![1, DYNAMIC, 768]).unwrap().has_dynamic());
}
#[test]
fn has_dynamic_true_when_all_dims_dynamic() {
assert!(Shape::new(vec![DYNAMIC, DYNAMIC]).unwrap().has_dynamic());
}
#[test]
fn has_dynamic_false_for_fully_static_shape() {
assert!(!Shape::new(vec![1, 128, 768]).unwrap().has_dynamic());
}
#[test]
fn has_dynamic_false_for_scalar() {
assert!(!Shape::scalar().has_dynamic());
}
#[test]
fn display_scalar_is_empty_brackets() {
assert_eq!(Shape::scalar().to_string(), "[]");
}
#[test]
fn display_1d_shape() {
assert_eq!(Shape::new(vec![5]).unwrap().to_string(), "[5]");
}
#[test]
fn display_3d_static_shape() {
assert_eq!(Shape::new(vec![3, 4, 5]).unwrap().to_string(), "[3, 4, 5]");
}
#[test]
fn display_dynamic_dimension_shown_as_question_mark() {
assert_eq!(
Shape::new(vec![1, DYNAMIC, 768]).unwrap().to_string(),
"[1, ?, 768]"
);
}
#[test]
fn display_all_dynamic() {
assert_eq!(
Shape::new(vec![DYNAMIC, DYNAMIC]).unwrap().to_string(),
"[?, ?]"
);
}
#[test]
fn display_zero_dimension() {
assert_eq!(Shape::new(vec![3, 0, 5]).unwrap().to_string(), "[3, 0, 5]");
}
#[test]
fn dynamic_constant_is_u64_max() {
assert_eq!(DYNAMIC, u64::MAX);
}
#[test]
fn max_rank_constant_is_64() {
assert_eq!(MAX_RANK, 64);
}
}