Struct NamedStructure 

pub struct NamedStructure<Name = String, Args = usize, R: RepName = LibraryRep, Aind = AbstractIndex> {
    pub structure: OrderedStructure<R, Aind>,
    pub global_name: Option<Name>,
    pub additional_args: Option<Args>,
}

A named structure is a structure with a global name, and a list of slots

It is useful when you want to shadow tensors, to nest tensor network contraction operations.

Fields

structure: OrderedStructure<R, Aind>

global_name: Option<Name>

additional_args: Option<Args>

Implementations

impl<Name, Args, R: RepName, Aind: AbsInd> NamedStructure<Name, Args, R, Aind>

pub fn from_iter<I, T>( iter: T, name: Name, args: Option<Args>, ) -> PermutedStructure<Self>

where R: From<I>, I: RepName, T: IntoIterator<Item = Slot<I, Aind>>,

Trait Implementations

impl<Name: Clone, Args: Clone, R: Clone + RepName, Aind: Clone> Clone for NamedStructure<Name, Args, R, Aind>

fn clone(&self) -> NamedStructure<Name, Args, R, Aind>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug, A: ArgDisplay, R: RepName, Aind: AbsInd> Debug for NamedStructure<N, A, R, Aind>

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

Formats the value using the given formatter.

impl<Name, Args, R, Aind, __Context> Decode<__Context> for NamedStructure<Name, Args, R, Aind>

where __Context: HasStateMap, Name: Decode<__Context>, Args: Decode<__Context>, R: Decode<__Context> + RepName, Aind: Decode<__Context>,

fn decode<D: Decoder<Context = __Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<Name: Default, Args: Default, R: Default + RepName, Aind: Default> Default for NamedStructure<Name, Args, R, Aind>

fn default() -> NamedStructure<Name, Args, R, Aind>

Returns the “default value” for a type.

impl<N: Display, A: ArgDisplay, R: RepName, Aind: AbsInd> Display for NamedStructure<N, A, R, Aind>

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

Formats the value using the given formatter.

impl<Name, Args, R, Aind> Encode for NamedStructure<Name, Args, R, Aind>

where Name: Encode, Args: Encode, R: Encode + RepName, Aind: Encode,

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl<N, A, R: RepName<Dual = R>> From<NamedStructure<N, A, R>> for SmartShadowStructure<N, A, R>

fn from(value: NamedStructure<N, A, R>) -> Self

Converts to this type from the input type.

impl<N, A, R: RepName, Aind> From<NamedStructure<N, A, R, Aind>> for IndexLess<R, Aind>

fn from(structure: NamedStructure<N, A, R, Aind>) -> Self

Converts to this type from the input type.

impl<N, A, R: RepName, Aind> From<NamedStructure<N, A, R, Aind>> for IndexlessNamedStructure<N, A, R, Aind>

fn from(value: NamedStructure<N, A, R, Aind>) -> Self

Converts to this type from the input type.

impl<N, A, R: RepName, Aind> From<NamedStructure<N, A, R, Aind>> for OrderedStructure<R, Aind>

fn from(structure: NamedStructure<N, A, R, Aind>) -> Self

Converts to this type from the input type.

impl<N, A, R: RepName, Aind: AbsInd> From<OrderedStructure<R, Aind>> for NamedStructure<N, A, R, Aind>

fn from(value: OrderedStructure<R, Aind>) -> Self

Converts to this type from the input type.

impl<N, A, R: RepName, Aind: AbsInd> HasName for NamedStructure<N, A, R, Aind>

where N: Clone, A: Clone,

A trait for a structure that has a name

type Name = N

type Args = A

fn name(&self) -> Option<Self::Name>

fn set_name(&mut self, name: Self::Name)

fn args(&self) -> Option<Self::Args>

fn expanded_coef(&self, id: FlatIndex) -> ExpandedCoefficent<Self::Args>

where Self: TensorStructure, Self::Name: IntoSymbol, Self::Args: IntoArgs,

fn expanded_coef_perm( &self, id: FlatIndex, permutation: &Permutation, ) -> ExpandedCoefficent<Self::Args>

where Self: TensorStructure, Self::Name: IntoSymbol, Self::Args: IntoArgs,

fn flat_coef(&self, id: FlatIndex) -> FlatCoefficent<Self::Args>

where Self: TensorStructure, Self::Name: IntoSymbol, Self::Args: IntoArgs,

impl<Name: Hash, Args: Hash, R: Hash + RepName, Aind: Hash> Hash for NamedStructure<Name, Args, R, Aind>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Name: PartialEq, Args: PartialEq, R: PartialEq + RepName, Aind: PartialEq> PartialEq for NamedStructure<Name, Args, R, Aind>

fn eq(&self, other: &NamedStructure<Name, Args, R, Aind>) -> 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<N: IdentityName, A, R: RepName<Dual = R>, Aind: AbsInd + DummyAind> PermuteTensor for NamedStructure<N, A, R, Aind>

type Id = NamedStructure<N, A, R, Aind>

type IdSlot = Slot<R, Aind>

type Permuted = (NamedStructure<N, A, LibraryRep, Aind>, Vec<NamedStructure<N, A, LibraryRep, Aind>>)

fn id(i: Self::IdSlot, j: Self::IdSlot) -> Self::Id

fn permute_inds(self, permutation: &Permutation) -> Self::Permuted

fn permute_reps(self, rep_perm: &Permutation) -> Self::Permuted

impl<N, A, R: RepName, Aind: AbsInd> ScalarStructure for NamedStructure<N, A, R, Aind>

where N: Clone, A: Clone,

fn scalar_structure() -> Self

impl<N, A, R: RepName<Dual = R>, Aind: AbsInd> StructureContract for NamedStructure<N, A, R, Aind>

fn trace_out(&mut self)

fn trace(&mut self, i: usize, j: usize)

fn merge( &self, other: &Self, ) -> Result<(Self, BitVec, BitVec, MergeInfo), StructureError>

Merges the two structures, yielding a new ordered structure.

impl<N, A, R: RepName<Dual = R>, Aind: AbsInd> TensorStructure for NamedStructure<N, A, R, Aind>

type Slot = Slot<R, Aind>

type Indexed = NamedStructure<N, A, R, Aind>

fn is_fully_self_dual(&self) -> bool

fn reindex( self, indices: &[Aind], ) -> Result<PermutedStructure<Self::Indexed>, StructureError>

fn dual(self) -> Self

fn external_reps_iter( &self, ) -> impl Iterator<Item = Representation<<Self::Slot as IsAbstractSlot>::R>>

fn external_indices_iter(&self) -> impl Iterator<Item = Aind>

fn external_dims_iter(&self) -> impl Iterator<Item = Dimension>

fn external_structure_iter(&self) -> impl Iterator<Item = Self::Slot>

fn order(&self) -> usize

fn get_slot(&self, i: usize) -> Option<Self::Slot>

fn get_rep( &self, i: usize, ) -> Option<Representation<<Self::Slot as IsAbstractSlot>::R>>

fn get_aind(&self, i: usize) -> Option<Aind>

fn get_dim(&self, i: usize) -> Option<Dimension>

fn string_rep(&self) -> String

fn external_structure(&self) -> Vec<Self::Slot>

returns the list of slots that are the external indices of the tensor

fn to_shell(self) -> TensorShell<Self>

where Self: Sized,

fn contains_matching(&self, slot: &Self::Slot) -> bool

fn external_reps( &self, ) -> Vec<Representation<<Self::Slot as IsAbstractSlot>::R>>

fn external_indices(&self) -> Vec<<Self::Slot as IsAbstractSlot>::Aind>

fn same_content(&self, other: &Self) -> bool

checks if the tensor has the same exact structure as another tensor

fn match_index(&self, other: &Self) -> Option<(bool, usize, usize)>

Given two TensorStructures, returns the index of the first matching slot in each external index list, along with a boolean indicating if there is a single match

fn match_indices( &self, other: &Self, ) -> Option<(Permutation, Vec<bool>, Vec<bool>)>

Given two TensorStructures, returns the index of the first matching slot in each external index list

fn traces(&self) -> Vec<[usize; 2]>

Identify the repeated slots in the external index list

fn shape(&self) -> Vec<Dimension>

yields the (outwards facing) shape of the tensor as a list of dimensions

fn reps(&self) -> Vec<Representation<<Self::Slot as IsAbstractSlot>::R>>

fn same_external(&self, other: &Self) -> bool

checks if externally, the two tensors are the same

fn find_permutation(&self, other: &Self) -> Result<Permutation>

find the permutation of the external indices that would make the two tensors the same. Applying the permutation to other should make it the same as self

fn strides_column_major(&self) -> Result<Vec<usize>>

yields the strides of the tensor in column major order

fn strides_row_major(&self) -> Result<Vec<usize>>

yields the strides of the tensor in row major order

fn strides(&self) -> Result<Vec<usize>>

By default, the strides are row major

fn verify_indices<C: AsRef<[ConcreteIndex]>>(&self, indices: C) -> Result<()>

Verifies that the list of indices provided are valid for the tensor

fn flat_index<C: AsRef<[ConcreteIndex]>>(&self, indices: C) -> Result<FlatIndex>

yields the flat index of the tensor given a list of indices

fn expanded_index(&self, flat_index: FlatIndex) -> Result<ExpandedIndex>

yields the expanded index of the tensor given a flat index

fn co_expanded_index( &self, flat_index: FlatIndex, ) -> Result<DualConciousExpandedIndex>

fn index_iter(&self) -> TensorStructureIndexIterator<'_, Self>

where Self: Sized,

yields an iterator over the indices of the tensor

fn is_scalar(&self) -> bool

if the tensor has no (external) indices, it is a scalar

fn size(&self) -> Result<usize>

yields the size of the tensor, i.e. the product of the dimensions. This is the length of the vector of the data in a dense tensor

impl<Name: Eq, Args: Eq, R: Eq + RepName, Aind: Eq> Eq for NamedStructure<Name, Args, R, Aind>

impl<Name, Args, R: RepName, Aind> StructuralPartialEq for NamedStructure<Name, Args, R, Aind>