Struct LeafTensor 

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

A single leaf tensor.

Implementations

impl LeafTensor

pub fn new_from_map( legs: Vec<EdgeIndex>, bond_dims_map: &FxHashMap<EdgeIndex, u64>, ) -> Self

Constructs a leaf tensor with the given edge ids and a mapping of edge ids to corresponding bond dimensions.

Examples

let bond_dims = FxHashMap::from_iter([(1, 2), (2, 4), (3, 6)]);
let tensor = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims);
assert_eq!(tensor.legs(), &[1, 2, 3]);
assert_eq!(tensor.bond_dims(), &[2, 4, 6]);

pub fn new_from_const(legs: Vec<EdgeIndex>, bond_dim: u64) -> Self

Constructs a leaf tensor with the given edge ids and the same bond dimension for all edges.

Examples

let tensor = LeafTensor::new_from_const(vec![1, 2, 3], 2);
assert_eq!(tensor.legs(), &[1, 2, 3]);
assert_eq!(tensor.bond_dims(), &[2, 2, 2]);

pub fn as_tensor(&self) -> &Tensor

Returns a reference to this leaf tensor as a Tensor.

pub fn shallow_clone(&self) -> Self

Returns a new leaf tensor with the same legs and bond dimensions as this tensor, but without any data.

pub fn legs(&self) -> &Vec<EdgeIndex>

Returns edge ids of the tensor.

Examples

let tensor = LeafTensor::new_from_const(vec![1, 2, 3], 3);
assert_eq!(tensor.legs(), &[1, 2, 3]);

pub fn edges(&self) -> impl Iterator<Item = (EdgeIndex, u64)> + '_

Returns an iterator of tuples of leg ids and their corresponding bond size.

pub fn bond_dims(&self) -> &Vec<u64>

Getter for bond dimensions.

pub fn shape(&self) -> Result<Vec<usize>, TryFromIntError>

Returns the shape of tensor. This is the same as the bond dimensions, but as usize. The conversion can fail, hence a Result is returned.

pub fn dims(&self) -> usize

Returns the number of dimensions.

Examples

let bond_dims = FxHashMap::from_iter([(1, 4), (2, 6), (3, 2)]);
let tensor = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims);
assert_eq!(tensor.dims(), 3);

pub fn size(&self) -> f64

Returns the number of elements. This is a f64 to avoid overflow in large tensors.

Examples

let bond_dims = FxHashMap::from_iter([(1, 5), (2, 15), (3, 8)]);
let tensor = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims);
assert_eq!(tensor.size(), 600.0);

pub fn into_legs(self) -> Vec<EdgeIndex>

Converts this tensor into the leg ids and bond dimensions it is made of.

pub fn into_data(self) -> TensorData

Converts this tensor into the data it contains.

pub fn into_inner(self) -> (Vec<EdgeIndex>, Vec<u64>, TensorData)

Converts this tensor into the leg ids, bond dimensions and data it is made of.

pub fn tensor_data(&self) -> &TensorData

Getter for tensor data.

pub fn set_tensor_data(&mut self, tensordata: TensorData)

Setter for tensor data.

Examples

let mut tensor = LeafTensor::new_from_const(vec![0, 1], 2);
let tensordata = TensorData::Gate((String::from("x"), vec![], false));
tensor.set_tensor_data(tensordata);

pub fn difference(&self, other: &Self) -> Self

Returns the tensor with legs in self that are not in other.

Examples

let bond_dims = FxHashMap::from_iter([(1, 2), (2, 4), (3, 6), (4, 3), (5, 9)]);
let tensor1 = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims);
let tensor2 = LeafTensor::new_from_map(vec![4, 2, 5], &bond_dims);
let diff_tensor = &tensor1 - &tensor2;
assert_eq!(diff_tensor.legs(), &[1, 3]);
assert_eq!(diff_tensor.bond_dims(), &[2, 6]);

pub fn union(&self, other: &Self) -> Self

Returns the tensor with union of legs in both self and other.

Examples

let bond_dims = FxHashMap::from_iter([(1, 2), (2, 4), (3, 6), (4, 3), (5, 9)]);
let tensor1 = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims);
let tensor2 = LeafTensor::new_from_map(vec![4, 2, 5], &bond_dims);
let union_tensor = &tensor1 | &tensor2;
assert_eq!(union_tensor.legs(), &[1, 2, 3, 4, 5]);
assert_eq!(union_tensor.bond_dims(), &[2, 4, 6, 3, 9]);

pub fn intersection(&self, other: &Self) -> Self

Returns the tensor with intersection of legs in self and other.

Examples

let bond_dims = FxHashMap::from_iter([(1, 2), (2, 4), (3, 6), (4, 3), (5, 9)]);
let tensor1 = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims);
let tensor2 = LeafTensor::new_from_map(vec![4, 2, 5], &bond_dims);
let intersection_tensor = &tensor1 & &tensor2;
assert_eq!(intersection_tensor.legs(), &[2]);
assert_eq!(intersection_tensor.bond_dims(), &[4]);

pub fn symmetric_difference(&self, other: &Self) -> Self

Returns the tensor with symmetrical difference of legs in self and other.

Examples

let bond_dims = FxHashMap::from_iter([(1, 2), (2, 4), (3, 6), (4, 3), (5, 9)]);
let tensor1 = LeafTensor::new_from_map(vec![1, 2, 3], &bond_dims);
let tensor2 = LeafTensor::new_from_map(vec![4, 2, 5], &bond_dims);
let sym_dif_tensor = &tensor1 ^ &tensor2;
assert_eq!(sym_dif_tensor.legs(), &[1, 3, 4, 5]);
assert_eq!(sym_dif_tensor.bond_dims(), &[2, 6, 3, 9]);

Trait Implementations

impl AbsDiffEq for LeafTensor

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 BitAnd for &LeafTensor

type Output = LeafTensor

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitOr for &LeafTensor

type Output = LeafTensor

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitXor for &LeafTensor

type Output = LeafTensor

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXorAssign<&LeafTensor> for LeafTensor

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl Clone for LeafTensor

fn clone(&self) -> LeafTensor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LeafTensor

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

Formats the value using the given formatter.

impl Default for LeafTensor

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LeafTensor

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LeafTensor> for Tensor

fn from(value: LeafTensor) -> Self

Converts to this type from the input type.

impl PartialEq for LeafTensor

fn eq(&self, other: &LeafTensor) -> 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 LeafTensor

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for &LeafTensor

type Output = LeafTensor

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl TransparentWrapper<TensorRepr> for LeafTensor

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 LeafTensor