use std::ops::{
Deref,
DerefMut,
Index,
IndexMut,
};
use burn::{
prelude::TensorData,
tensor::{
AsIndex,
BoolStore,
DType,
DataError,
Element,
},
};
use crate::zspace::ravel_dims;
pub trait TensorDataViewExt {
fn try_index_view<E: Element>(&self) -> Result<TensorDataView<'_, E>, DataError>;
fn expect_index_view<E: Element>(&self) -> TensorDataView<'_, E> {
self.try_index_view().unwrap()
}
fn try_index_mut_view<E: Element>(&mut self) -> Result<TensorDataViewMut<'_, E>, DataError>;
fn expect_index_mut_view<E: Element>(&mut self) -> TensorDataViewMut<'_, E> {
self.try_index_mut_view().unwrap()
}
}
fn matches_target_dtype<E: Element>(data: &TensorData) -> bool {
let target_dtype = E::dtype();
match data.dtype {
DType::Bool(BoolStore::U8) => {
matches!(target_dtype, DType::U8 | DType::Bool(BoolStore::U8))
}
DType::Bool(BoolStore::U32) => {
matches!(target_dtype, DType::U32 | DType::Bool(BoolStore::U32))
}
dtype => dtype == target_dtype,
}
}
impl TensorDataViewExt for TensorData {
fn try_index_view<E: Element>(&self) -> Result<TensorDataView<'_, E>, DataError> {
TensorDataView::try_view(self)
}
fn try_index_mut_view<E: Element>(&mut self) -> Result<TensorDataViewMut<'_, E>, DataError> {
TensorDataViewMut::try_mut_view(self)
}
}
#[derive(Debug)]
pub struct TensorDataView<'a, E: Element> {
data: &'a TensorData,
_phantom: std::marker::PhantomData<&'a E>,
}
impl<'a, E: Element> Deref for TensorDataView<'a, E> {
type Target = TensorData;
fn deref(&self) -> &Self::Target {
self.data
}
}
impl<'a, E: Element> TensorDataView<'a, E> {
pub fn try_view(data: &'a TensorData) -> Result<TensorDataView<'a, E>, DataError> {
if !matches_target_dtype::<E>(data) {
Err(DataError::TypeMismatch(format!(
"Cannot view TensorData DType \"{:?}\" as \"{:?}\"",
data.dtype,
E::dtype()
)))
} else {
Ok(TensorDataView {
data,
_phantom: std::marker::PhantomData,
})
}
}
pub fn ravel_dims<I: AsIndex>(
&self,
dims: &[I],
) -> usize {
ravel_dims(&self.data.shape, dims)
}
}
impl<'a, I: AsIndex, E: Element> Index<&[I]> for TensorDataView<'a, E> {
type Output = E;
fn index(
&self,
index: &[I],
) -> &Self::Output {
let o = self.ravel_dims(index);
&self.data.as_slice::<E>().unwrap()[o]
}
}
#[derive(Debug)]
pub struct TensorDataViewMut<'a, E: Element> {
data: &'a mut TensorData,
_phantom: std::marker::PhantomData<&'a E>,
}
impl<'a, E: Element> Deref for TensorDataViewMut<'a, E> {
type Target = TensorData;
fn deref(&self) -> &Self::Target {
self.data
}
}
impl<'a, E: Element> DerefMut for TensorDataViewMut<'a, E> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.data
}
}
impl<'a, E: Element> TensorDataViewMut<'a, E> {
pub fn try_mut_view(data: &'a mut TensorData) -> Result<TensorDataViewMut<'a, E>, DataError> {
if !matches_target_dtype::<E>(data) {
Err(DataError::TypeMismatch(format!(
"Cannot view TensorData DType \"{:?}\" as \"{:?}\"",
data.dtype,
E::dtype()
)))
} else {
Ok(TensorDataViewMut {
data,
_phantom: std::marker::PhantomData,
})
}
}
pub fn ravel_dims<I: AsIndex>(
&self,
dims: &[I],
) -> usize {
ravel_dims(&self.data.shape, dims)
}
}
impl<'a, I: AsIndex, E: Element> Index<&[I]> for TensorDataViewMut<'a, E> {
type Output = E;
fn index(
&self,
index: &[I],
) -> &Self::Output {
let o = self.ravel_dims(index);
&self.data.as_slice::<E>().unwrap()[o]
}
}
impl<'a, I: AsIndex, E: Element> IndexMut<&[I]> for TensorDataViewMut<'a, E> {
fn index_mut(
&mut self,
index: &[I],
) -> &mut Self::Output {
let o = self.ravel_dims(index);
&mut self.data.as_mut_slice::<E>().unwrap()[o]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_tensor_data_try_view_dtype_mismatch() {
let data = TensorData::from([[1.0, 2.0], [3.0, 4.0]]);
let result = data.try_index_view::<i32>();
assert!(matches!(result, Err(DataError::TypeMismatch(_))));
}
#[test]
#[should_panic(expected = "Cannot view TensorData DType")]
fn test_tensor_data_expect_view_dtype_mismatch() {
let data = TensorData::from([[1.0, 2.0], [3.0, 4.0]]);
let _view = data.expect_index_view::<i32>();
}
#[test]
fn test_tensor_data_try_mut_view_dtype_mismatch() {
let mut data = TensorData::from([[1.0, 2.0], [3.0, 4.0]]);
let result = data.try_index_mut_view::<i32>();
assert!(matches!(result, Err(DataError::TypeMismatch(_))));
}
#[test]
#[should_panic(expected = "Cannot view TensorData DType")]
fn test_tensor_data_expect_mut_view_dtype_mismatch() {
let mut data = TensorData::from([[1.0, 2.0], [3.0, 4.0]]);
let _view = data.expect_index_mut_view::<i32>();
}
#[test]
fn test_tensor_data_index_view() {
let data = TensorData::from([[1.0, 2.0], [3.0, 4.0]]);
let view = data.expect_index_view::<f64>();
assert_eq!(&data.shape, &view.shape);
assert_eq!(view[&[0, 0]], 1.0);
assert_eq!(view[&[0, 1]], 2.0);
assert_eq!(view[&[1, 0]], 3.0);
assert_eq!(view[&[1, 1]], 4.0);
}
#[test]
fn test_tensor_data_index_mut_view() {
let mut data = TensorData::from([[1.0, 2.0], [3.0, 4.0]]);
let shape = data.shape.clone();
let mut view = data.expect_index_mut_view::<f64>();
assert_eq!(&view.shape, &shape);
assert_eq!(view[&[0, 0]], 1.0);
assert_eq!(view[&[0, 1]], 2.0);
assert_eq!(view[&[1, 0]], 3.0);
assert_eq!(view[&[1, 1]], 4.0);
view[&[0, 0]] = 10.0;
assert_eq!(view[&[0, 0]], 10.0);
}
#[test]
fn test_tensor_data_index_view_rejects_out_of_range() {
let data = TensorData::from([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
let view = data.expect_index_view::<f64>();
assert_eq!(view[&[-1, -1]], 6.0);
let read = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| view[&[0, 3]]));
assert!(read.is_err(), "view[&[0, 3]] read {:?}", read.ok());
}
#[test]
fn test_tensor_data_index_mut_view_rejects_out_of_range() {
let mut data = TensorData::from([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]);
let mut view = data.expect_index_mut_view::<f64>();
let write = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
view[&[0, 3]] = 10.0;
}));
assert!(write.is_err(), "view[&[0, 3]] = 10.0 did not panic");
assert_eq!(
data.to_vec::<f64>().unwrap(),
vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
);
}
}