Struct Tensor 

pub struct Tensor { /* private fields */ }

Dynamic tensor over the supported scalar types.

The erased tensor keeps dtype dynamic and rank dynamic: the preset scalars share one Native core whose descriptor records the element type, and a caller-owned scalar is an External payload recovered by its own type. Use TypedTensor<T, R> directly when the scalar type or rank should be represented in Rust’s type system.

Examples

use tenferro_tensor::{DType, Tensor};

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert_eq!(tensor.dtype(), DType::F64);

Implementations

impl Tensor

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

Compute the linear physical-buffer offset for a logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3], vec![0.0_f64; 6]).unwrap();
assert_eq!(t.linear_offset(&[1, 2])?, 5);

Errors

Returns crate::Error::Validation containing tenferro_tensor_core::ValidationError::RankMismatch when indices has a rank different from the tensor, tenferro_tensor_core::ValidationError::InvalidArgument when an index is outside its axis extent, or tenferro_tensor_core::ValidationError::IntegerOverflow when checked offset arithmetic overflows.

pub fn linear_offset2(&self, i: usize, j: usize) -> Result<usize, Error>

Compute the linear physical-buffer offset for a rank-2 logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3], vec![0.0_f64; 6]).unwrap();
assert_eq!(t.linear_offset2(1, 2)?, 5);

Errors

Returns crate::Error::Validation containing tenferro_tensor_core::ValidationError::RankMismatch when the tensor rank is not two, tenferro_tensor_core::ValidationError::InvalidArgument when i or j is outside its axis extent, or tenferro_tensor_core::ValidationError::IntegerOverflow when checked offset arithmetic overflows.

pub fn linear_offset3( &self, i: usize, j: usize, k: usize, ) -> Result<usize, Error>

Compute the linear physical-buffer offset for a rank-3 logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3, 2], vec![0.0_f64; 12]).unwrap();
assert_eq!(t.linear_offset3(1, 2, 1)?, 11);

Errors

Returns crate::Error::Validation containing tenferro_tensor_core::ValidationError::RankMismatch when the tensor rank is not three, tenferro_tensor_core::ValidationError::InvalidArgument when i, j, or k is outside its axis extent, or tenferro_tensor_core::ValidationError::IntegerOverflow when checked offset arithmetic overflows.

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

where T: TensorScalar,

Borrow a single typed element by multi-index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(t.get::<f64>(&[1])?, &2.0);
assert!(t.get::<f32>(&[1]).is_err());

Errors

Returns crate::Error::Validation containing tenferro_tensor_core::ValidationError::RankMismatch or tenferro_tensor_core::ValidationError::InvalidArgument for an invalid index, tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype, or crate::Error::RuntimeState for a device-backed tensor.

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

where T: TensorScalar,

Mutably borrow a single typed element by multi-index.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
*t.get_mut::<f64>(&[0])? = 2.0;
assert_eq!(t.as_slice::<f64>()?, &[2.0]);

Errors

Returns crate::Error::Validation containing tenferro_tensor_core::ValidationError::RankMismatch or tenferro_tensor_core::ValidationError::InvalidArgument for an invalid index, tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype, or crate::Error::RuntimeState for a device-backed tensor.

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

where T: TensorScalar,

Try to borrow a single typed element by multi-index without release-mode bounds checks.

Debug builds still validate the rank and bounds. Dtype and backend host-access failures are still reported as errors.

Safety

indices must have the same rank as this tensor and every index must be in bounds.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(unsafe { *t.get_unchecked::<f64>(&[1])? }, 2.0);

Errors

Returns crate::Error::RuntimeState for a device-backed tensor and tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype.

Panics

May panic if the unsafe rank/bounds precondition is violated and the checked linear-offset calculation overflows.

pub unsafe fn get_unchecked_mut<T>( &mut self, indices: &[usize], ) -> Result<&mut T, Error>

where T: TensorScalar,

Try to mutably borrow a single typed element by multi-index without release-mode bounds checks.

Debug builds still validate the rank and bounds. Dtype and backend host-access failures are still reported as errors.

Safety

indices must have the same rank as this tensor and every index must be in bounds.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
unsafe {
    *t.get_unchecked_mut::<f64>(&[0])? = 2.0;
}
assert_eq!(t.as_slice::<f64>()?, &[2.0]);

Errors

Returns crate::Error::RuntimeState for a device-backed tensor and tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype.

Panics

May panic if the unsafe rank/bounds precondition is violated and the checked linear-offset calculation overflows.

pub fn as_slice_mut<T>(&mut self) -> Result<&mut [T], Error>

where T: TensorScalar,

Mutably borrow the host data as a typed slice.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
t.as_slice_mut::<f64>()?[0] = 3.0;
assert_eq!(t.as_slice::<f64>()?, &[3.0, 2.0]);
assert!(t.as_slice_mut::<f32>().is_err());

Errors

Returns tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype, or crate::Error::RuntimeState when the tensor is backed by a device buffer.

pub fn iter<T>(&self) -> Result<Iter<'_, T>, Error>

where T: TensorScalar,

Iterate over the contiguous host buffer in physical memory order.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let sum: f64 = t.iter::<f64>()?.copied().sum();
assert_eq!(sum, 3.0);
assert!(t.iter::<f32>().is_err());

Errors

Returns tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype, or crate::Error::RuntimeState when the tensor is backed by a device buffer.

pub fn iter_mut<T>(&mut self) -> Result<IterMut<'_, T>, Error>

where T: TensorScalar,

Mutably iterate over the contiguous host buffer in physical memory order.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
for value in t.iter_mut::<f64>()? {
    *value += 1.0;
}
assert_eq!(t.as_slice::<f64>()?, &[2.0, 3.0]);
assert!(t.iter_mut::<f32>().is_err());

Errors

Returns tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype, or crate::Error::RuntimeState when the tensor is backed by a device buffer.

impl Tensor

pub fn index_select( &self, axis: isize, positions: &[usize], session: &mut dyn BackendSession, ) -> Result<Tensor, Error>

Select entries from one axis using host-known positions.

Examples

use tenferro_tensor::{BackendSession, Tensor};

fn select_last_axis(
    session: &mut dyn BackendSession,
    x: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    x.index_select(-1, &[2, 0], session)
}

Errors

Returns crate::Error::Validation with a typed shape, axis, or argument source when the inputs cannot be packed without violating their metadata.

pub fn stack( tensors: &[&Tensor], dim: isize, session: &mut dyn BackendSession, ) -> Result<Tensor, Error>

Stack tensors along a newly inserted axis.

Examples

use tenferro_tensor::{BackendSession, Tensor};

fn stack_scalars(
    session: &mut dyn BackendSession,
    a: &Tensor,
    b: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    Tensor::stack(&[a, b], -1, session)
}

Errors

Returns crate::Error::Validation with a typed shape, axis, or argument source when the inputs cannot be packed without violating their metadata.

impl Tensor

pub fn external(payload: ErasedHostTensor) -> Tensor

Carry an externally defined scalar as a caller-owned payload.

The payload keeps its own element type and is recovered by that type, so no bytes are reinterpreted. Placement defaults to unpinned host memory, which is where a caller-owned payload lives.

Examples

use tenferro_tensor::{DType, Tensor};
use tenferro_tensor_core::{ErasedHostTensor, HostTensor};

let payload = ErasedHostTensor::new(HostTensor::from_vec_col_major(vec![1], vec![1.0_f64])?);
let element = payload.element_type_id();
let tensor = Tensor::external(payload);
assert_eq!(tensor.dtype(), DType::External(element));
assert_eq!(tensor.shape(), &[1]);

pub fn from_typed<T>(typed: TypedTensor<T>) -> Tensor

where T: TensorScalar,

Build a tensor from a typed one, without naming its variant.

A call site that constructs a tensor from a typed tensor should use this rather than a variant, so that changing how the erased representation is stored changes this function and not its 1290 call sites. The variants remain until the removal’s last step, so both forms currently produce the same value.

Examples

use tenferro_tensor::Tensor;

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
let typed = tensor.into_typed::<f64>()?;
let rebuilt = Tensor::from_typed(typed);
assert_eq!(rebuilt.as_typed::<f64>().unwrap().shape(), &[2]);

pub fn external_payload(&self) -> Option<&ErasedHostTensor>

Borrow the erased payload of an externally defined tensor.

This is the counterpart of Tensor::external for dispatch: a table that matches on Tensor::dtype reaches the externally defined tag and needs the payload that tag stands for, just as the typed tags reach theirs through Tensor::as_typed. Every other tag returns None.

Examples

use tenferro_tensor::Tensor;
use tenferro_tensor_core::{ErasedHostTensor, HostTensor};

let payload = ErasedHostTensor::new(HostTensor::from_vec_col_major(vec![1], vec![1.0_f64])?);
let tensor = Tensor::external(payload);
assert!(tensor.external_payload().is_some());

pub fn external_with_placement( payload: ErasedHostTensor, placement: Placement, ) -> Tensor

Carry an externally defined payload with an explicit placement.

Tensor::external defaults the placement to unpinned host memory, which is where a caller-owned payload normally lives; this entry point is for a caller that knows the placement it wants.

Examples

use tenferro_tensor::{Placement, Tensor};
use tenferro_tensor_core::{ErasedHostTensor, HostTensor};

let payload = ErasedHostTensor::new(HostTensor::from_vec_col_major(vec![1], vec![1.0_f64])?);
let tensor = Tensor::external_with_placement(payload, Placement::default());
assert!(tensor.external_payload().is_some());

pub fn external_payload_mut(&mut self) -> Option<&mut ErasedHostTensor>

Mutably borrow the erased payload of an externally defined tensor.

The counterpart of Tensor::external_payload for callers that update the payload in place, such as a mutation test that checks the copy boundary.

Examples

use tenferro_tensor::Tensor;
use tenferro_tensor_core::{ErasedHostTensor, HostTensor};

let mut tensor = Tensor::external(ErasedHostTensor::new(
    HostTensor::from_vec_col_major(vec![1], vec![1.0_f64])?,
));
assert!(tensor.external_payload_mut().is_some());

impl Tensor

pub fn as_real_view(&self) -> Result<TensorView<'_>, Error>

Borrow a complex tensor as its sealed interleaved real representation.

Errors

Returns crate::Error::Unsupported for a non-complex dtype and ValidationError::ViewOutOfBounds or ValidationError::InvalidArgument for invalid layout metadata.

pub fn as_real_view_mut(&mut self) -> Result<TensorViewMut<'_>, Error>

Borrow a complex tensor mutably as its sealed interleaved real representation.

Errors

Returns crate::Error::Unsupported for a non-complex dtype and ValidationError::ViewOutOfBounds or ValidationError::InvalidArgument for invalid layout metadata.

pub fn into_real(self) -> Result<Tensor, ReinterpretError<Tensor>>

Consume a complex tensor and reinterpret its owner as real without copying.

Errors

Returns ReinterpretError::error containing ValidationError::InvalidArgument or ValidationError::ViewOutOfBounds while retaining the unchanged owner.

pub fn as_complex_view(&self) -> Result<TensorView<'_>, Error>

Borrow an interleaved real tensor as its sealed complex representation.

Errors

Returns crate::Error::Unsupported for a non-real dtype and ValidationError::ViewOutOfBounds or ValidationError::InvalidArgument for invalid layout metadata.

pub fn as_complex_view_mut(&mut self) -> Result<TensorViewMut<'_>, Error>

Borrow an interleaved real tensor mutably as its sealed complex representation.

Errors

Returns crate::Error::Unsupported for a non-real dtype and ValidationError::ViewOutOfBounds or ValidationError::InvalidArgument for invalid layout metadata.

pub fn into_complex(self) -> Result<Tensor, ReinterpretError<Tensor>>

Consume a real tensor and reinterpret its owner as complex without copying.

Errors

Returns ReinterpretError::error containing ValidationError::InvalidArgument or ValidationError::ViewOutOfBounds while retaining the unchanged owner.

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

Make an explicit owning copy of this dtype-erased tensor.

Errors

Returns crate::Error::RuntimeState or crate::Error::Unsupported when the selected backend/storage owner cannot be duplicated.

pub fn from_vec_col_major<T>( shape: impl IntoShapeVec, data: Vec<T>, ) -> Result<Tensor, Error>

where T: TensorScalar,

Create a tensor from a shape and column-major flat data.

This is the Tensor-level equivalent of TypedTensor::<T>::from_vec_col_major.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 2], vec![1.0_f64, 3.0, 2.0, 4.0]).unwrap();
assert_eq!(t.shape(), &[2, 2]);
assert_eq!(t.as_slice::<f64>().unwrap(), &[1.0, 3.0, 2.0, 4.0]);

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::ShapeDataLengthMismatch when the shape product differs from data.len(), or tenferro_tensor_core::ValidationError::IntegerOverflow when shape arithmetic overflows.

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

Tensor shape.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let t = Tensor::from_typed(TypedTensor::from_vec_col_major(vec![2], vec![1.0, 2.0]).unwrap());
assert_eq!(t.shape(), &[2]);

pub fn dtype(&self) -> DType

Tensor dtype tag.

Examples

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

let t = Tensor::from_typed(TypedTensor::from_vec_col_major(vec![], vec![1.0]).unwrap());
assert_eq!(t.dtype(), DType::F64);

pub fn placement(&self) -> &Placement

Return placement metadata for this dtype-erased tensor.

Examples

use tenferro_tensor::{MemoryKind, Tensor};

let t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
assert_eq!(t.placement().memory_kind, MemoryKind::UnpinnedHost);

pub fn is_backend_buffer(&self) -> bool

Return whether this tensor is backed by backend-native storage.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
assert!(!t.is_backend_buffer());

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;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert_eq!(t.layout_linear_offset(&[1])?, 1);

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 tensor is compact column-major.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert!(t.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 tensor’s layout metadata.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert!(t.layout_summary().contains("shape=[2]"));

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

Assert this tensor is compact column-major.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
t.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 tensor is not compact column-major.

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

where T: TensorScalar,

Try to borrow the host data as a typed slice.

Returns an error if the tensor dtype does not match T.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let t = Tensor::from_typed(TypedTensor::from_vec_col_major(vec![3], vec![1.0, 2.0, 3.0]).unwrap());
assert_eq!(t.as_slice::<f64>().unwrap(), [1.0, 2.0, 3.0].as_slice());
assert!(t.as_slice::<f32>().is_err());

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype, or crate::Error::RuntimeState when the matching tensor uses backend storage that has not been downloaded.

pub fn as_typed<T>(&self) -> Option<&TypedTensor<T>>

where T: TensorScalar,

Borrow the typed tensor when the requested scalar matches this tensor’s dtype.

This is the accessor tag-based dispatch needs: it recovers the typed tensor — and with it the device buffer — from a value whose element type is only known at run time, so a caller can dispatch on Tensor::dtype instead of matching every variant. An externally defined scalar is not a typed tensor, so it returns None rather than guessing a representation.

Examples

use tenferro_tensor::Tensor;

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert!(tensor.as_typed::<f64>().is_some());
assert!(tensor.as_typed::<f32>().is_none());
assert_eq!(tensor.as_typed::<f64>().unwrap().shape(), &[2]);

pub fn as_typed_mut<T>(&mut self) -> Option<&mut TypedTensor<T>>

where T: TensorScalar,

Mutably borrow the typed tensor when the requested scalar matches this tensor’s dtype.

This is the mutable half of Tensor::as_typed, for the tables whose arm calls a method that needs &mut, such as marking a freshly allocated output with its placement. An externally defined scalar is not a typed tensor, so it returns None for the same reason.

Examples

use tenferro_tensor::Tensor;

let mut tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert!(tensor.as_typed_mut::<f64>().is_some());
assert!(tensor.as_typed_mut::<f32>().is_none());

pub fn into_typed<T>(self) -> Result<TypedTensor<T>, Error>

where T: TensorScalar,

Consume this tensor and return the owned typed tensor when the dtype matches.

This is the consuming counterpart of Tensor::as_typed, for the tables whose arm hands the typed tensor to a function that takes it by value — reusing its buffer rather than copying it.

Examples

use tenferro_tensor::Tensor;

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert!(tensor.into_typed::<f64>().is_ok());

let tensor = Tensor::from_vec_col_major(vec![2], vec![1.0_f32, 2.0])?;
assert!(tensor.into_typed::<f64>().is_err());

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::DTypeMismatch when T is not this tensor’s dtype. A matching tensor is handed over as it is, including one whose storage lives in a backend buffer.

pub fn into_vec_col_major<T>(self) -> Result<(Vec<usize>, Vec<T>), Error>

where T: TensorScalar,

Consume this tensor and return its owned column-major buffer when the dtype matches.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
assert_eq!(t.into_vec_col_major::<f64>().unwrap().1, vec![2.0]);

Errors

Returns crate::Error::Validation with tenferro_tensor_core::ValidationError::DTypeMismatch when T does not match the tensor dtype, or crate::Error::RuntimeState when the matching tensor uses backend storage that has not been downloaded.

Trait Implementations

impl Debug for Tensor

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

Formats the value using the given formatter.

impl From<TypedTensor<Complex<f32>>> for Tensor

Wrap a Complex32 TypedTensor into the corresponding Tensor variant.

Examples

use num_complex::Complex32;
use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(
    vec![1],
    vec![Complex32::new(1.0, 2.0)],
).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[1]);

fn from(t: TypedTensor<Complex<f32>>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<Complex<f64>>> for Tensor

Wrap a Complex64 TypedTensor into the corresponding Tensor variant.

Examples

use num_complex::Complex64;
use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(
    vec![1],
    vec![Complex64::new(1.0, 2.0)],
).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[1]);

fn from(t: TypedTensor<Complex<f64>>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<bool>> for Tensor

Wrap a bool TypedTensor into the corresponding Tensor variant.

Examples

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

let typed = TypedTensor::from_vec_col_major(vec![2], vec![true, false]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::Bool);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<bool>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<f32>> for Tensor

Wrap an f32 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1.0_f32, 2.0]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<f32>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<f64>> for Tensor

Wrap an f64 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<f64>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<i32>> for Tensor

Wrap an i32 TypedTensor into the corresponding Tensor variant.

Examples

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

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1_i32, 2]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::I32);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<i32>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<i64>> for Tensor

Wrap an i64 TypedTensor into the corresponding Tensor variant.

Examples

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

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1_i64, 2]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::I64);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<i64>) -> Tensor

Converts to this type from the input type.

impl TensorSessionOpsExt for Tensor

fn add(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise addition with NumPy-style broadcasting inside a session.

fn mul(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise multiplication with NumPy-style broadcasting inside a session.

fn exp(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise exponential inside a session.

fn reduce_sum( &self, axes: &[usize], session: &mut dyn BackendSession, ) -> Result<Tensor>

Sum over one or more axes inside a session.

fn convert(&self, to: DType, session: &mut dyn BackendSession) -> Result<Tensor>

Convert to a different dtype using the checked conversion lattice inside a session.

fn cast(&self, to: DType, session: &mut dyn BackendSession) -> Result<Tensor>

Cast to a different dtype using explicit lossy projection inside a session.

fn sub(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise subtraction with NumPy-style broadcasting inside a session.

fn div(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise division with NumPy-style broadcasting inside a session.

fn rem(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise remainder with NumPy-style broadcasting inside a session.

fn pow(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise power with NumPy-style broadcasting inside a session.

fn maximum( &self, rhs: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Elementwise maximum with NumPy-style broadcasting inside a session.

fn minimum( &self, rhs: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Elementwise minimum with NumPy-style broadcasting inside a session.

fn neg(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise negation inside a session.

fn abs(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise absolute value inside a session.

fn sign(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise sign inside a session.

fn conj(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise complex conjugate inside a session.

fn log(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise natural logarithm inside a session.

fn expm1(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise exp(x) - 1 inside a session.

fn log1p(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise log(1 + x) inside a session.

fn sin(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise sine inside a session.

fn cos(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise cosine inside a session.

fn tanh(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise hyperbolic tangent inside a session.

fn sqrt(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise square root inside a session.

fn rsqrt(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise reciprocal square root inside a session.

fn compare( &self, rhs: &Tensor, dir: CompareDir, session: &mut dyn BackendSession, ) -> Result<Tensor>

Elementwise comparison with NumPy-style broadcasting inside a session.

fn where_select( &self, on_true: &Tensor, on_false: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Select values from on_true or on_false using this tensor as condition inside a session.

fn clamp( &self, lower: &Tensor, upper: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Clamp values elementwise between lower and upper bounds inside a session.

fn matmul( &self, rhs: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Rank-2 matrix multiplication inside a session.

fn reshape( &self, shape: &[usize], session: &mut dyn BackendSession, ) -> Result<Tensor>

Reshape without changing element order inside a session.

fn transpose( &self, perm: &[usize], session: &mut dyn BackendSession, ) -> Result<Tensor>

Permute axes inside a session.