Struct Tensor 

pub struct Tensor(/* private fields */);

An abstract tensor. This can either be a CompositeTensor or a LeafTensor.

Implementations

impl Tensor

pub fn kind(&self) -> TensorType

Returns the kind of this tensor.

pub fn is_leaf(&self) -> bool

Returns true if the tensor is a leaf tensor, without any nested tensors.

Examples

let bond_dims = FxHashMap::from_iter([(1, 2), (2, 4), (3, 6)]);
let leaf: Tensor = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims).into();
assert_eq!(leaf.is_leaf(), true);
let comp: Tensor = CompositeTensor::new(vec![leaf]).into();
assert_eq!(comp.is_leaf(), false);

pub fn as_leaf(&self) -> Option<&LeafTensor>

Returns a reference to this tensor as a LeafTensor if it is one.

pub fn into_leaf(self) -> Option<LeafTensor>

Returns this tensor as a LeafTensor if it is one.

pub fn is_composite(&self) -> bool

Returns true if the tensor is composite.

Examples

let bond_dims = FxHashMap::from_iter([(1, 2), (2, 4), (3, 6)]);
let leaf: Tensor = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims).into();
assert_eq!(leaf.is_composite(), false);
let comp: Tensor = CompositeTensor::new(vec![leaf]).into();
assert_eq!(comp.is_composite(), true);

pub fn as_composite(&self) -> Option<&CompositeTensor>

Returns a reference to this tensor as a CompositeTensor if it is one.

pub fn into_composite(self) -> Option<CompositeTensor>

Returns this tensor as a CompositeTensor if it is one.

Trait Implementations

impl AbsDiffEq for Tensor

type Epsilon = f64

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of [AbsDiffEq::abs_diff_eq].

impl Clone for Tensor

fn clone(&self) -> Tensor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tensor

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tensor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<CompositeTensor> for Tensor

fn from(value: CompositeTensor) -> Self

Converts to this type from the input type.

impl From<LeafTensor> for Tensor

fn from(value: LeafTensor) -> Self

Converts to this type from the input type.

impl PartialEq for Tensor

fn eq(&self, other: &Tensor) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Tensor

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TransparentWrapper<TensorRepr> for Tensor

fn wrap(s: Inner) -> Self

where Self: Sized,

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

where Self: Sized,

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

where Self: Sized,

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

where Self: Sized,

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

where Self: Sized,

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

where Self: Sized,

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl StructuralPartialEq for Tensor