Enum TensorRead 

pub enum TensorRead<'a> {
    Tensor(&'a Tensor),
    View(TensorView<'a>),
}

Read-only tensor input accepted by synchronous eager kernels.

TensorRead lets kernels accept either an owned tensor reference or a borrowed TensorView without forcing callers to materialize first. The View variant preserves arbitrary strides and offsets, so kernels that support strided reads can consume transposes, slices, and broadcasts directly.

TensorRead is intentionally borrowed. It is an input-dispatch type, not an owned lazy tensor value. APIs that need to store a lazy layout result should keep an owned base tensor plus layout metadata, then expose a TensorRead only for the duration of kernel dispatch.

Examples

use tenferro_tensor::{DType, Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let read = TensorRead::from_tensor(&tensor);

assert_eq!(read.dtype(), DType::F64);
assert_eq!(read.shape(), &[2]);

Variants

Tensor(&'a Tensor)

View(TensorView<'a>)

Implementations

impl<'a> TensorRead<'a>

pub fn from_tensor(tensor: &'a Tensor) -> TensorRead<'a>

Borrow an owned tensor as a read target without copying it.

Examples

use tenferro_tensor::{Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
let read = TensorRead::from_tensor(&tensor);
assert_eq!(read.as_slice::<f64>()?, &[1.0, 2.0]);

pub fn from_view(view: TensorView<'a>) -> TensorRead<'a>

Wrap a borrowed dtype-erased view as a read target.

Examples

use tenferro_tensor::{TensorRead, TensorView};

let read = TensorRead::from_view(TensorView::i32(&[2], &[3, 4])?);
assert_eq!(read.as_slice::<i32>()?, &[3, 4]);
assert!(read.as_tensor().is_none());

pub fn tensor_view(self) -> TensorView<'a>

Convert this read target into a dtype-erased tensor view.

Owned tensors are borrowed without copying their storage. Existing views preserve their layout and placement metadata.

Examples

let view = TensorRead::from_tensor(&tensor).tensor_view();
assert_eq!(view.shape(), &[2]);
assert_eq!(view.as_slice::<f64>()?, &[1.0, 2.0]);

pub fn as_slice<T>(&self) -> Result<&'a [T], Error>

where T: TensorScalar,

Borrow this read target as a typed compact host slice without allocation.

This delegates to TensorView::as_slice. Cloning a TensorRead is a shallow clone of its borrowed reference or view metadata, so the returned slice retains the original 'a storage lifetime and never outlives the storage borrowed by this read target. This method does not materialize, transfer, or otherwise canonicalize the input.

Errors

Returns ValidationError::DTypeMismatch when T does not match the input dtype, ValidationError::NonContiguousViewAsSlice for a noncompact view, or a typed runtime-state host-access error for backend-owned storage. Backend-owned inputs are never downloaded implicitly.

Examples

use tenferro_tensor::{Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
let read = TensorRead::from_tensor(&tensor);
assert_eq!(read.as_slice::<f64>()?, &[1.0, 2.0]);

pub fn dtype(&self) -> DType

Return the element dtype of this read target.

Examples

use tenferro_tensor::{DType, Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![1], vec![1_i64])?;
assert_eq!(TensorRead::from_tensor(&tensor).dtype(), DType::I64);

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

Return the logical shape of this read target.

Examples

use tenferro_tensor::{Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![2, 1], vec![1.0_f64, 2.0])?;
assert_eq!(TensorRead::from_tensor(&tensor).shape(), &[2, 1]);

pub fn placement(&self) -> &Placement

Return the placement metadata carried by this read target.

Examples

use tenferro_tensor::{MemoryKind, Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![1], vec![1.0_f64])?;
let read = TensorRead::from_tensor(&tensor);
assert_eq!(read.placement().memory_kind, MemoryKind::UnpinnedHost);

pub fn backend_family(&self) -> Option<&'static str>

Return the physical backend family of this read target, when backend-owned.

Examples

use tenferro_tensor::{Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![1], vec![1.0_f64])?;
assert_eq!(TensorRead::from_tensor(&tensor).backend_family(), None);

pub fn allocation_domain(&self) -> Option<AllocationDomainId>

Return the shared allocation domain of this read target, when present.

Examples

use tenferro_tensor::{Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![1], vec![1.0_f64])?;
assert_eq!(TensorRead::from_tensor(&tensor).allocation_domain(), None);

pub fn strides(&self) -> Result<Vec<isize>, Error>

Return strides in element units; owned tensors report compact column-major strides.

Examples

use tenferro_tensor::{Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![2, 3], vec![0.0_f64; 6])?;
assert_eq!(TensorRead::from_tensor(&tensor).strides()?, vec![1, 2]);

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::IntegerOverflow when column-major stride arithmetic overflows.

pub fn offset(&self) -> isize

Return the physical element offset; owned tensors always start at 0.

Examples

use tenferro_tensor::{TensorRead, TensorView, TypedTensorView};

let data = [1.0_f64, 2.0, 3.0];
let view = TensorView::F64(TypedTensorView::from_slice(vec![2], vec![1], 1, &data)?);
assert_eq!(TensorRead::from_view(view).offset(), 1);

pub fn layout_linear_offset(&self, indices: &[usize]) -> Result<usize, Error>

Compute the physical element offset for a logical index.

Examples

use tenferro_tensor::{Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![2, 3], vec![0.0_f64; 6])?;
let read = TensorRead::from_tensor(&tensor);
assert_eq!(read.layout_linear_offset(&[1, 2])?, 5);
assert!(read.layout_linear_offset(&[2, 0]).is_err());

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, Error>

Return whether this read target is compact column-major.

Examples

use tenferro_tensor::{Tensor, TensorRead, TensorView, TypedTensorView};

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert!(TensorRead::from_tensor(&tensor).is_col_major_contiguous()?);
let data = [1.0_f64, 2.0, 3.0];
let strided = TensorView::F64(TypedTensorView::from_slice(vec![2], vec![2], 0, &data)?);
assert!(!TensorRead::from_view(strided).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 read target’s layout metadata.

Examples

use tenferro_tensor::{Tensor, TensorRead};

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert_eq!(
    TensorRead::from_tensor(&tensor).layout_summary(),
    "shape=[2] strides=[1] offset=0"
);

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

Assert this read target is compact column-major.

Examples

use tenferro_tensor::{Tensor, TensorRead, TensorView, TypedTensorView};

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
TensorRead::from_tensor(&tensor).assert_col_major_contiguous()?;
let data = [1.0_f64, 2.0, 3.0];
let strided = TensorView::F64(TypedTensorView::from_slice(vec![2], vec![2], 0, &data)?);
assert!(TensorRead::from_view(strided).assert_col_major_contiguous().is_err());

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 as_tensor(&self) -> Option<&'a Tensor>

Return the borrowed owned tensor, or None when this read target is a view.

Examples

use tenferro_tensor::{Tensor, TensorRead, TensorView};

let tensor = Tensor::from_vec_col_major(vec![1], vec![1.0_f64])?;
assert!(TensorRead::from_tensor(&tensor).as_tensor().is_some());
assert!(TensorRead::from_view(TensorView::f64(&[1], &[1.0])?).as_tensor().is_none());

Trait Implementations

impl<'a> Clone for TensorRead<'a>

fn clone(&self) -> TensorRead<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for TensorRead<'a>

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

Formats the value using the given formatter.