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]);

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::IntegerOverflow for compact shape or offset arithmetic overflow, or tenferro_tensor_core::ValidationError::ViewOutOfBounds when the compact shape reaches beyond data.

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());

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::RankMismatch when shape and strides have different ranks, tenferro_tensor_core::ValidationError::ViewOutOfBounds when the layout reaches beyond data, tenferro_tensor_core::ValidationError::OverlappingMutableLayout when logical elements alias, or tenferro_tensor_core::ValidationError::IntegerOverflow for layout arithmetic overflow.

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]);

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::RankMismatch when the typed rank does not match shape or strides, tenferro_tensor_core::ValidationError::ViewOutOfBounds when the layout reaches beyond data, tenferro_tensor_core::ValidationError::OverlappingMutableLayout when logical elements alias, or tenferro_tensor_core::ValidationError::IntegerOverflow for layout arithmetic overflow.

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 rank(&self) -> usize

Return the logical rank carried by this mutable view.

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]);

Errors

Returns crate::Error::RuntimeState when this view wraps a backend buffer; backend storage must be downloaded before host inspection.

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. Prefer scalar element accessors when mutating a logical region; tensor-sized copies belong to an active backend.

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));

Errors

Returns crate::Error::RuntimeState when this view wraps a backend buffer; backend storage must be downloaded before host inspection.

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().unwrap());

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 layout_linear_offset(&self, indices: &[usize]) -> Result<usize>

Compute the physical element offset for a logical index, returning a typed error.

Examples

use tenferro_tensor::TypedTensorViewMut;

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

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::RankMismatch when indices has the wrong rank, tenferro_tensor_core::ValidationError::InvalidArgument when an index is outside its axis extent, or tenferro_tensor_core::ValidationError::IntegerOverflow when offset arithmetic overflows.

pub fn is_col_major_contiguous(&self) -> Result<bool>

Return whether this mutable view is compact column-major.

Examples

use tenferro_tensor::TypedTensorViewMut;

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

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::IntegerOverflow when compactness arithmetic overflows.

pub fn layout_summary(&self) -> String

Return a compact string summary of this mutable view’s layout metadata.

Examples

use tenferro_tensor::TypedTensorViewMut;

let mut data = [1_i32, 2];
let view = TypedTensorViewMut::from_slice([2], [1], 0, &mut data)?;
assert!(view.layout_summary().contains("shape=[2]"));

pub fn assert_col_major_contiguous(&self) -> Result<()>

Assert this mutable view is compact column-major.

Examples

use tenferro_tensor::TypedTensorViewMut;

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

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::IntegerOverflow when compactness arithmetic overflows, or tenferro_tensor_core::ValidationError::InvalidArgument when the view is not compact column-major.

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 duplicate(&self) -> Result<TypedTensor<T, R>>

where T: TensorScalar,

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));

Explicitly duplicate the compact host data visible through this mutable view into a new owner.

Errors

Returns crate::Error::HostAccess or ValidationError::NonContiguousViewAsSlice when the view is backend owned or not contiguous, and ValidationError::InvalidArgument when the static-rank shape cannot be reconstructed.

Examples

use tenferro_tensor::TypedTensorViewMut;

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

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

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]);

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::InvalidPermutationLength, tenferro_tensor_core::ValidationError::AxisOutOfBounds, or tenferro_tensor_core::ValidationError::DuplicateAxis when axes is not a valid permutation, tenferro_tensor_core::ValidationError::OverlappingMutableLayout when the permutation creates aliases, or tenferro_tensor_core::ValidationError::IntegerOverflow for layout arithmetic overflow.

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));

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::RankMismatch when the slice count differs from the view rank, tenferro_tensor_core::ValidationError::InvalidSliceStep or tenferro_tensor_core::ValidationError::InvalidSliceBounds for an invalid slice, tenferro_tensor_core::ValidationError::ViewOutOfBounds when the result exceeds the backing buffer, tenferro_tensor_core::ValidationError::OverlappingMutableLayout when logical elements alias, or tenferro_tensor_core::ValidationError::IntegerOverflow for layout arithmetic overflow.

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));

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::AxisOutOfBounds when axis is outside the view rank, tenferro_tensor_core::ValidationError::InvalidSliceStep or tenferro_tensor_core::ValidationError::InvalidSliceBounds for an invalid slice, tenferro_tensor_core::ValidationError::ViewOutOfBounds when the result exceeds the backing buffer, tenferro_tensor_core::ValidationError::OverlappingMutableLayout when logical elements alias, or tenferro_tensor_core::ValidationError::IntegerOverflow for layout arithmetic overflow.

pub fn try_multi_slice_mut( &mut self, first: &[StridedSliceSpec], second: &[StridedSliceSpec], ) -> Result<Option<TypedTensorViewMutSplit<'_, 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]);

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::RankMismatch for either slice count, tenferro_tensor_core::ValidationError::InvalidSliceStep or tenferro_tensor_core::ValidationError::InvalidSliceBounds for invalid parameters, tenferro_tensor_core::ValidationError::ViewOutOfBounds when a result exceeds the backing buffer, tenferro_tensor_core::ValidationError::OverlappingMutableLayout when a result aliases, tenferro_tensor_core::ValidationError::InvalidArgument for a negative reachable offset, or tenferro_tensor_core::ValidationError::IntegerOverflow for layout arithmetic overflow. The method returns Ok(None) when the two ranges overlap or the view uses backend storage.

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]);

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::NonContiguousViewAsSlice when the source is not compact column-major, tenferro_tensor_core::ValidationError::ShapeMismatch (whose tenferro_tensor_core::ShapeMismatch::ReshapeElementCount source records the counts) when element counts differ, tenferro_tensor_core::ValidationError::OverlappingMutableLayout when the reshaped layout aliases, tenferro_tensor_core::ValidationError::IntegerOverflow for shape or layout arithmetic overflow, or tenferro_tensor_core::ValidationError::ViewOutOfBounds when the reshaped view exceeds the backing buffer.

impl<'a, R: TensorRank> TypedTensorViewMut<'a, Complex32, R>

pub fn as_real_view_mut( &mut self, ) -> Result<TypedTensorViewMut<'_, f32, DynRank>>

Borrow this mutable complex view as an interleaved real view.

This changes only the typed descriptor and borrows the same host allocation. The result has dynamic rank because the component axis is prepended. Backend-native buffers are rejected until their provider phase supplies the corresponding mapping capability.

Errors

Returns an error when the view layout is not injective, the sealed representation is invalid, or backend reinterpretation is unsupported.

impl<'a, R: TensorRank> TypedTensorViewMut<'a, Complex64, R>

pub fn as_real_view_mut( &mut self, ) -> Result<TypedTensorViewMut<'_, f64, DynRank>>

Borrow this mutable complex view as an interleaved real view.

This changes only the typed descriptor and borrows the same host allocation. The result has dynamic rank because the component axis is prepended. Backend-native buffers are rejected until their provider phase supplies the corresponding mapping capability.

Errors

Returns an error when the view layout is not injective, the sealed representation is invalid, or backend reinterpretation is unsupported.

impl<'a, R: TensorRank> TypedTensorViewMut<'a, f32, R>

pub fn as_complex_view_mut( &mut self, ) -> Result<TypedTensorViewMut<'_, Complex32, DynRank>>

Borrow this mutable interleaved real view as a complex view.

The source must have a leading extent and stride of 2 and 1, and all remaining strides plus the offset must be divisible by 2.

Errors

Returns an error when the view layout is not injective, the sealed representation is invalid, or backend reinterpretation is unsupported.

impl<'a, R: TensorRank> TypedTensorViewMut<'a, f64, R>

pub fn as_complex_view_mut( &mut self, ) -> Result<TypedTensorViewMut<'_, Complex64, DynRank>>

Borrow this mutable interleaved real view as a complex view.

The source must have a leading extent and stride of 2 and 1, and all remaining strides plus the offset must be divisible by 2.

Errors

Returns an error when the view layout is not injective, the sealed representation is invalid, or backend reinterpretation is unsupported.

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.

impl<'a, T> From<TypedTensorViewMut<'a, T>> for TypedTensorWrite<'a, T>

fn from(view: TypedTensorViewMut<'a, T>) -> Self

Converts to this type from the input type.