Struct CompositeTensor 

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

A composite tensor that has other tensors as children, similar to a tensor network.

Implementations

impl CompositeTensor

pub fn new<T>(tensors: T) -> Self

where T: TensorList,

Creates a new composite tensor with the given nested tensors.

pub fn as_tensor(&self) -> &Tensor

Returns a reference to this composite tensor as a Tensor.

pub fn tensors(&self) -> &Vec<Tensor>

Returns the children tensors.

Examples

let bond_dims = FxHashMap::from_iter([(0, 17), (1, 19), (2, 8)]);
let v1 = LeafTensor::new_from_map(vec![0, 1], &bond_dims);
let v2 = LeafTensor::new_from_map(vec![1, 2], &bond_dims);
let tn = CompositeTensor::new(vec![v1.clone(), v2.clone()]);
for (tensor, ref_tensor) in std::iter::zip(tn.tensors(), vec![v1, v2]){
   assert_abs_diff_eq!(tensor, ref_tensor.as_tensor());
}

pub fn tensor(&self, i: TensorIndex) -> &Tensor

Get the ith tensor.

Examples

let bond_dims = FxHashMap::from_iter([(0, 17), (1, 19), (2, 8)]);
let v1 = LeafTensor::new_from_map(vec![0, 1], &bond_dims);
let v2 = LeafTensor::new_from_map(vec![1, 2], &bond_dims);
let tn = CompositeTensor::new(vec![v1.clone(), v2]);
assert_abs_diff_eq!(tn.tensor(0), v1.as_tensor());

pub fn into_tensors(self) -> Vec<Tensor>

Converts this tensor into the vec of its children.

pub fn is_empty(&self) -> bool

Returns true if the tensor is empty. This means, it doesn’t have any children.

Examples

let tensor = CompositeTensor::default();
assert_eq!(tensor.is_empty(), true);

pub fn len(&self) -> usize

Returns the number of direct children of this tensor.

Examples

let tensor = CompositeTensor::default();
assert_eq!(tensor.len(), 0);

pub fn nested_tensor(&self, nested_indices: &[usize]) -> &Tensor

Gets a nested Tensor based on the nested_indices which specify the index of the tensor at each level of the hierarchy.

Examples

let bond_dims = FxHashMap::from_iter([(0, 17), (1, 19), (2, 8), (3, 2), (4, 1)]);
let mut v1 = LeafTensor::new_from_map(vec![0, 1], &bond_dims);
let mut v2 = LeafTensor::new_from_map(vec![1, 2], &bond_dims);
let mut v3 = LeafTensor::new_from_map(vec![2, 3], &bond_dims);
let mut v4 = LeafTensor::new_from_map(vec![3, 4], &bond_dims);
let tn1 = CompositeTensor::new(vec![v1, v2]);
let tn2 = CompositeTensor::new(vec![v3.clone(), v4]);
let nested_tn = CompositeTensor::new(vec![tn1, tn2]);

let found = nested_tn.nested_tensor(&[1, 0]);
assert!(found.is_leaf());
let found = found.as_leaf().unwrap();
assert_eq!(found.legs(), v3.legs());

pub fn total_num_tensors(&self) -> usize

Returns the total number of leaf tensors in the hierarchy.

pub fn push_tensor<T>(&mut self, tensor: T)

where T: Into<Tensor>,

Pushes additional tensor into this composite tensor.

pub fn push_tensors<T>(&mut self, tensors: T)

where T: TensorList,

Pushes additional tensors into this composite tensor.

pub fn reserve(&mut self, additional: usize)

Reserves space for at least additional more tensors to be pushed to this composite tensor without reallocation.

pub fn is_connected(&self) -> bool

Returns whether all tensors inside this tensor are connected. This currently requires all children to be leaf tensors.

Examples

// Create a tensor network with two connected tensors
let bond_dims = FxHashMap::from_iter([(0, 17), (1, 19), (2, 8), (3, 5)]);
let v1 = LeafTensor::new_from_map(vec![0, 1], &bond_dims);
let v2 = LeafTensor::new_from_map(vec![1, 2], &bond_dims);
let mut tn = CompositeTensor::new(vec![v1, v2]);
assert!(tn.is_connected());

// Introduce a new tensor that is not connected
let v3 = LeafTensor::new_from_map(vec![3], &bond_dims);
tn.push_tensor(v3);
assert!(!tn.is_connected());

pub fn external_tensor(&self) -> LeafTensor

Get output legs after tensor contraction.

Trait Implementations

impl AbsDiffEq for CompositeTensor

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 CompositeTensor

fn clone(&self) -> CompositeTensor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompositeTensor

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

Formats the value using the given formatter.

impl Default for CompositeTensor

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompositeTensor

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 PartialEq for CompositeTensor

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

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 CompositeTensor

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 CompositeTensor