Struct Tensor 

pub struct Tensor { /* private fields */ }

Abstract representation of a tensor. Can be a composite tensor (that is, a tensor network) or a leaf tensor.

Implementations

impl Tensor

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

Constructs a Tensor using with the given edge ids and a mapping of edge ids to corresponding bond dimension.

Examples

let bond_dims = FxHashMap::from_iter([(1, 2), (2, 4), (3, 6)]);
let tensor = Tensor::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 Tensor with the given edge ids and the same bond dimension for all edges.

Examples

let tensor = Tensor::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 new_composite(tensors: Vec<Self>) -> Self

Creates a new composite tensor with the given nested tensors.

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

Returns edge ids of Tensor object.

Examples

let tensor = Tensor::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 tensors(&self) -> &Vec<Self>

Returns the nested tensors of a composite tensor.

Examples

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

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 = Tensor::new_from_map(vec![0, 1], &bond_dims);
let mut v2 = Tensor::new_from_map(vec![1, 2], &bond_dims);
let mut v3 = Tensor::new_from_map(vec![2, 3], &bond_dims);
let mut v4 = Tensor::new_from_map(vec![3, 4], &bond_dims);
let tn1 = Tensor::new_composite(vec![v1, v2]);
let tn2 = Tensor::new_composite(vec![v3.clone(), v4]);
let nested_tn = Tensor::new_composite(vec![tn1, tn2]);

assert_eq!(nested_tn.nested_tensor(&[1, 0]).legs(), v3.legs());

pub fn total_num_tensors(&self) -> usize

Returns the total number of leaf tensors in the hierarchy.

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

Get ith Tensor.

Examples

let bond_dims = FxHashMap::from_iter([(0, 17), (1, 19), (2, 8)]);
let v1 = Tensor::new_from_map(vec![0, 1], &bond_dims);
let v2 = Tensor::new_from_map(vec![1, 2], &bond_dims);
let tn = Tensor::new_composite(vec![v1.clone(), v2]);
assert_eq!(tn.tensor(0).legs(), v1.legs());

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 = Tensor::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 = Tensor::new_from_map(vec![1, 2, 3], &bond_dims);
assert_eq!(tensor.size(), 600.0);

pub fn is_leaf(&self) -> bool

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

Examples

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

pub fn is_composite(&self) -> bool

Returns true if Tensor is composite.

Examples

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

pub fn is_empty(&self) -> bool

Returns true if Tensor is empty. This means, it doesn’t have any subtensors, has no legs and is doesn’t have any data (e.g., is not a scalar).

Examples

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

pub fn into_tensor_data(self) -> TensorData

Consumes the Tensor and returns its TensorData.

Examples

let tensor = Tensor::new_from_const(vec![1, 2], 2);
let tensordata = tensor.into_tensor_data();
assert_eq!(tensordata, TensorData::Uncontracted);

pub fn push_tensor(&mut self, tensor: Self)

Pushes additional tensor into this tensor, which must be a composite tensor.

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

Pushes additional tensors into this tensor, which must be a composite tensor.

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 = Tensor::new_from_const(vec![0, 1], 2);
let tensordata = TensorData::Gate((String::from("x"), vec![], false));
tensor.set_tensor_data(tensordata);

pub fn is_connected(&self) -> bool

Returns whether all tensors inside this tensor are connected. This only checks the top-level, not recursing into composite 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 = Tensor::new_from_map(vec![0, 1], &bond_dims);
let v2 = Tensor::new_from_map(vec![1, 2], &bond_dims);
let mut tn = Tensor::new_composite(vec![v1, v2]);
assert!(tn.is_connected());

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

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

Returns 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 = Tensor::new_from_map(vec![1, 2, 3], &bond_dims);
let tensor2 = Tensor::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 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 = Tensor::new_from_map(vec![1, 2, 3], &bond_dims);
let tensor2 = Tensor::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 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 = Tensor::new_from_map(vec![1, 2, 3], &bond_dims);
let tensor2 = Tensor::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 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 = Tensor::new_from_map(vec![1, 2, 3], &bond_dims);
let tensor2 = Tensor::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]);

pub fn external_tensor(&self) -> Tensor

Get output legs after tensor contraction

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

type Output = Tensor

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor) -> Tensor

Performs the & operation.

impl BitOr for &Tensor

type Output = Tensor

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor) -> Tensor

Performs the | operation.

impl BitXor for &Tensor

type Output = Tensor

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor) -> Tensor

Performs the ^ operation.

impl BitXorAssign<&Tensor> for Tensor

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

Performs the ^= operation.

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 Default for Tensor

fn default() -> Tensor

Returns the “default value” for a type.

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

fn eq(&self, other: &Self) -> 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 Sub for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor) -> Tensor

Performs the - operation.