Skip to main content

Tensor

tenferro_ad

Enum Tensor 

Source 
pub enum Tensor {
    F32(TypedTensor<f32>),
    F64(TypedTensor<f64>),
    I32(TypedTensor<i32>),
    I64(TypedTensor<i64>),
    Bool(TypedTensor<bool>),
    C32(TypedTensor<Complex<f32>>),
    C64(TypedTensor<Complex<f64>>),
}
Expand description

Dynamic tensor enum over the supported scalar types.

The enum keeps dtype dynamic and rank dynamic. Use TypedTensor<T, R> directly when the scalar type or rank should be represented in Rust’s type system.

§Examples

use tenferro_tensor::{Tensor, TypedTensor};

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

let erased = Tensor::from_vec_col_major(vec![1, 2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(erased.shape().len(), 2);

Variants§

§

F32(TypedTensor<f32>)

§

F64(TypedTensor<f64>)

§

I32(TypedTensor<i32>)

§

I64(TypedTensor<i64>)

§

Bool(TypedTensor<bool>)

§

C32(TypedTensor<Complex<f32>>)

§

C64(TypedTensor<Complex<f64>>)

Implementations§

Source§

impl Tensor

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source§

impl Tensor

Source

pub fn index_select( &self, axis: isize, positions: &[usize], ctx: &mut impl TensorBackend, ) -> Result<Tensor, Error>

Select entries from one axis using host-known positions.

§Examples
use tenferro_tensor::{Tensor, TensorBackend};

fn select_last_axis<B: TensorBackend>(
    backend: &mut B,
    x: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    x.index_select(-1, &[2, 0], backend)
}
§Errors

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

Source

pub fn stack( tensors: &[&Tensor], dim: isize, ctx: &mut impl TensorBackend, ) -> Result<Tensor, Error>

Stack tensors along a newly inserted axis.

§Examples
use tenferro_tensor::{Tensor, TensorBackend};

fn stack_scalars<B: TensorBackend>(
    backend: &mut B,
    a: &Tensor,
    b: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    Tensor::stack(&[a, b], -1, backend)
}
§Errors

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

Source§

impl Tensor

Source

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.

Source

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

Tensor shape.

§Examples
use tenferro_tensor::{Tensor, TypedTensor};

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

pub fn dtype(&self) -> DType

Tensor dtype tag.

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

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

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

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

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.

Source

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.

Source

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

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.

Source

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::F64(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.

Source

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§

Source§

impl Clone for Tensor

Source§

fn clone(&self) -> Tensor

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for Tensor

Source§

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

Formats the value using the given formatter. Read more
Source§

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

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

Converts to this type from the input type.
Source§

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

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

Converts to this type from the input type.
Source§

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

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

Converts to this type from the input type.
Source§

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

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

Converts to this type from the input type.
Source§

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

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

Converts to this type from the input type.
Source§

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

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

Converts to this type from the input type.
Source§

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

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

Converts to this type from the input type.
§

impl TensorOpsExt for Tensor

§

fn convert<B>(&self, to: DType, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Convert to a different dtype using the checked conversion lattice. Read more
§

fn cast<B>(&self, to: DType, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Cast to a different dtype using explicit lossy projection. Read more
§

fn add<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise addition with NumPy-style broadcasting. Read more
§

fn sub<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise subtraction with NumPy-style broadcasting. Read more
§

fn mul<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise multiplication with NumPy-style broadcasting. Read more
§

fn div<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise division with NumPy-style broadcasting. Read more
§

fn rem<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise remainder with NumPy-style broadcasting. Read more
§

fn pow<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise power with NumPy-style broadcasting. Read more
§

fn maximum<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise maximum with NumPy-style broadcasting. Read more
§

fn minimum<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise minimum with NumPy-style broadcasting. Read more
§

fn neg<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise negation. Read more
§

fn abs<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise absolute value. Read more
§

fn sign<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise sign. Read more
§

fn conj<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise complex conjugate. Read more
§

fn exp<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise exponential. Read more
§

fn log<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise natural logarithm. Read more
§

fn sin<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise sine. Read more
§

fn cos<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise cosine. Read more
§

fn tanh<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise hyperbolic tangent. Read more
§

fn sqrt<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise square root. Read more
§

fn rsqrt<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise reciprocal square root. Read more
§

fn expm1<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise exp(x) - 1. Read more
§

fn log1p<B>(&self, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise log(1 + x). Read more
§

fn compare<B>( &self, rhs: &Tensor, dir: CompareDir, backend: &mut B, ) -> Result<Tensor, Error>
where B: TensorBackend,

Elementwise comparison with NumPy-style broadcasting. Read more
§

fn where_select<B>( &self, on_true: &Tensor, on_false: &Tensor, backend: &mut B, ) -> Result<Tensor, Error>
where B: TensorBackend,

Select values from on_true or on_false using this tensor as condition. Read more
§

fn clamp<B>( &self, lower: &Tensor, upper: &Tensor, backend: &mut B, ) -> Result<Tensor, Error>
where B: TensorBackend,

Clamp values elementwise between lower and upper bounds. Read more
§

fn matmul<B>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Rank-2 matrix multiplication. Read more
§

fn reshape<B>(&self, shape: &[usize], backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Reshape without changing element order. Read more
§

fn transpose<B>(&self, perm: &[usize], backend: &mut B) -> Result<Tensor, Error>
where B: TensorBackend,

Permute axes. Read more
§

fn reduce_sum<B>( &self, axes: &[usize], backend: &mut B, ) -> Result<Tensor, Error>
where B: TensorBackend,

Sum over one or more axes. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> ByRef<T> for T

§

fn by_ref(&self) -> &T

Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T, U> Imply<T> for U
where T: ?Sized, U: ?Sized,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSendSync for T
where T: Send + Sync,

§

impl<T> MaybeSync for T
where T: Sync,