Struct TypedTensorViewMut 

pub struct TypedTensorViewMut<'a, T, R: TensorRank = DynRank> { /* private fields */ }

Mutable borrowed view of typed tensor storage with arbitrary strides.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2, 3];
let mut view = TypedTensorViewMut::from_slice(vec![3], vec![-1], 2, &mut data)?;
*view.get_mut(&[2]).unwrap() = 10;
assert_eq!(view.as_read_only().get(&[2]), Some(&10));

Implementations

impl<'a, T: 'static> TypedTensorViewMut<'a, T, DynRank>

pub fn from_col_major(shape: &[usize], data: &'a mut [T]) -> Result<Self>

Create a mutable dynamic-rank view over compact column-major host data.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2, 3, 4];
let view = TypedTensorViewMut::from_col_major(&[2, 2], &mut data)?;
assert_eq!(view.strides(), &[1, 2]);

pub fn from_slice( shape: impl AsRef<[usize]>, strides: impl AsRef<[isize]>, offset: isize, data: &'a mut [T], ) -> Result<Self>

Create a mutable host view from explicit layout metadata.

Layouts where distinct logical elements can alias the same physical element are rejected.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2];
assert!(TypedTensorViewMut::from_slice(vec![2], vec![0], 0, &mut data).is_err());

impl<'a, T: 'static, R: TensorRank> TypedTensorViewMut<'a, T, R>

pub fn from_slice_ranked( shape: impl Into<R::Shape>, strides: impl Into<R::Strides>, offset: isize, data: &'a mut [T], ) -> Result<Self>

Create a rank-generic mutable host view from explicit layout metadata.

Examples

use tenferro_tensor::{Rank, TypedTensorViewMut};

let mut data = [1_i32, 2, 3, 4];
let view = TypedTensorViewMut::<_, Rank<2>>::from_slice_ranked([2, 2], [1, 2], 0, &mut data)?;
assert_eq!(view.shape(), &[2, 2]);

pub fn shape(&self) -> &[usize]

Return the logical shape.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [0_i32; 2];
let view = TypedTensorViewMut::from_slice(vec![2], vec![1], 0, &mut data)?;
assert_eq!(view.shape(), &[2]);

pub fn strides(&self) -> &[isize]

Return strides in element units.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [0_i32; 2];
let view = TypedTensorViewMut::from_slice(vec![2], vec![-1], 1, &mut data)?;
assert_eq!(view.strides(), &[-1]);

pub fn offset(&self) -> isize

Return the physical element offset.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2];
let view = TypedTensorViewMut::from_slice(vec![1], vec![1], 1, &mut data)?;
assert_eq!(view.offset(), 1);

pub fn host_storage(&self) -> Result<&[T]>

Return the borrowed host storage backing this view.

This exposes the entire backing host allocation, not just the logical slice covered by this view. Use TypedTensorViewMut::as_read_only with TypedTensorView::as_slice when the caller needs the contiguous logical region instead.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2];
let view = TypedTensorViewMut::from_slice(vec![2], vec![1], 0, &mut data)?;
assert_eq!(view.host_storage()?, &[1, 2]);

pub fn host_storage_mut(&mut self) -> Result<&mut [T]>

Mutably borrow the host storage backing this view.

This exposes the entire backing host allocation, not just the logical slice covered by this view. Use TypedTensorViewMut::copy_from_contiguous or element accessors when mutating the logical region instead.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2];
let mut view = TypedTensorViewMut::from_slice(vec![2], vec![1], 0, &mut data)?;
view.host_storage_mut()?[0] = 3;
assert_eq!(view.get(&[0]), Some(&3));

pub fn n_elements(&self) -> usize

Return the number of logical elements in this view.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [0_i32; 6];
let view = TypedTensorViewMut::from_slice(vec![2, 3], vec![1, 2], 0, &mut data)?;
assert_eq!(view.n_elements(), 6);

pub fn layout(&self) -> &TensorLayout<R>

Return layout metadata for this view.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2];
let view = TypedTensorViewMut::from_slice(vec![2], vec![1], 0, &mut data)?;
assert!(view.layout().is_compact_col_major());

pub fn placement(&self) -> &Placement

Return placement metadata for this view.

Examples

use tenferro_tensor::{MemoryKind, TypedTensorViewMut};

let mut data = [1_i32];
let view = TypedTensorViewMut::from_slice(vec![1], vec![1], 0, &mut data)?;
assert_eq!(view.placement().memory_kind, MemoryKind::UnpinnedHost);

pub fn linear_offset(&self, indices: &[usize]) -> Option<usize>

Compute the physical element offset for a logical index.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2, 3];
let view = TypedTensorViewMut::from_slice(vec![3], vec![-1], 2, &mut data)?;
assert_eq!(view.linear_offset(&[2]), Some(0));

pub fn get(&self, indices: &[usize]) -> Option<&T>

Borrow one host element by logical index.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2];
let view = TypedTensorViewMut::from_slice(vec![2], vec![1], 0, &mut data)?;
assert_eq!(view.get(&[1]), Some(&2));

pub fn get_mut(&mut self, indices: &[usize]) -> Option<&mut T>

Mutably borrow one host element by logical index.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2];
let mut view = TypedTensorViewMut::from_slice(vec![2], vec![1], 0, &mut data)?;
*view.get_mut(&[1]).unwrap() = 20;
assert_eq!(view.get(&[1]), Some(&20));

pub fn copy_from_contiguous(&mut self, src: &TypedTensor<T, R>) -> Result<()>

where T: Clone,

Copy compact column-major host tensor values into this mutable view.

This is an explicit copy-back boundary. Backend source or destination buffers return an error instead of transferring data implicitly.

Examples

use tenferro_tensor::{Rank, TypedTensor};

let mut tensor = TypedTensor::<i32, Rank<2>>::from_vec_col_major([2, 2], vec![0, 0, 0, 0]).unwrap();
let src = TypedTensor::<i32, Rank<2>>::from_vec_col_major([2, 2], vec![1, 2, 3, 4]).unwrap();
tensor.as_view_mut().transpose_view([1, 0])?.copy_from_contiguous(&src)?;
assert_eq!(tensor.as_slice()?, &[1, 3, 2, 4]);

pub fn as_read_only(&self) -> TypedTensorView<'_, T, R>

Borrow this mutable view as a read-only view.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32];
let view = TypedTensorViewMut::from_slice(vec![1], vec![1], 0, &mut data)?;
assert_eq!(view.as_read_only().get(&[0]), Some(&1));

pub fn into_read_only(self) -> TypedTensorView<'a, T, R>

Convert this mutable view into a read-only view.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32];
let view = TypedTensorViewMut::from_slice(vec![1], vec![1], 0, &mut data)?;
assert_eq!(view.into_read_only().get(&[0]), Some(&1));

pub fn transpose_view( self, axes: impl AsRef<[usize]>, ) -> Result<TypedTensorViewMut<'a, T, R>>

Consume this mutable view and return a metadata-only axis permutation.

Examples

use tenferro_tensor::{Rank, TypedTensorViewMut};

let mut data = [1_i32, 2, 3, 4];
let view = TypedTensorViewMut::<_, Rank<2>>::from_slice_ranked([2, 2], [1, 2], 0, &mut data)?;
let transposed = view.transpose_view([1, 0])?;
assert_eq!(transposed.strides(), &[2, 1]);

pub fn try_slice( &mut self, slices: &[StridedSliceSpec], ) -> Result<TypedTensorViewMut<'_, T, R>>

Return a mutable metadata-only slice using one StridedSliceSpec per axis.

Examples

use tenferro_tensor::{StridedSliceSpec, TypedTensorViewMut};

let mut data = [1_i32, 2, 3];
let mut view = TypedTensorViewMut::from_slice(vec![3], vec![1], 0, &mut data)?;
*view.try_slice(&[StridedSliceSpec::reverse()])?.get_mut(&[0]).unwrap() = 30;
assert_eq!(view.get(&[2]), Some(&30));

pub fn try_slice_axis( &mut self, axis: usize, slice: StridedSliceSpec, ) -> Result<TypedTensorViewMut<'_, T, R>>

Return a mutable metadata-only slice along one axis.

Examples

use tenferro_tensor::{StridedSliceSpec, TypedTensorViewMut};

let mut data = [1_i32, 2, 3, 4];
let mut view = TypedTensorViewMut::from_slice(vec![2, 2], vec![1, 2], 0, &mut data)?;
assert_eq!(view.try_slice_axis(1, StridedSliceSpec::reverse())?.get(&[0, 0]), Some(&3));

pub fn try_multi_slice_mut( &mut self, first: &[StridedSliceSpec], second: &[StridedSliceSpec], ) -> Option<(TypedTensorViewMut<'_, T, R>, TypedTensorViewMut<'_, T, R>)>

Return two mutable metadata-only slices when their physical ranges are disjoint.

Examples

use tenferro_tensor::{StridedSliceSpec, TypedTensorViewMut};

let mut data = [1_i32, 2, 3, 4];
let mut view = TypedTensorViewMut::from_slice(vec![4], vec![1], 0, &mut data)?;
let (left, right) = view
    .try_multi_slice_mut(
        &[StridedSliceSpec::new(0, Some(2), 1)],
        &[StridedSliceSpec::new(2, Some(4), 1)],
    )
    .unwrap();
assert_eq!(left.shape(), &[2]);
assert_eq!(right.shape(), &[2]);

pub fn try_reshape( &mut self, shape: &[usize], ) -> Result<TypedTensorViewMut<'_, T, DynRank>>

Return a mutable metadata-only dynamic-rank reshape for contiguous views.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2, 3, 4];
let mut view = TypedTensorViewMut::from_slice(vec![2, 2], vec![1, 2], 0, &mut data)?;
assert_eq!(view.try_reshape(&[4])?.shape(), &[4]);

Trait Implementations

impl<'a, T: Debug, R: Debug + TensorRank> Debug for TypedTensorViewMut<'a, T, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.