Struct Index 

pub struct Index<Id, Tags = TagSet> {
    pub id: Id,
    pub dim: usize,
    pub plev: i64,
    pub tags: Tags,
}

Index with generic identity type Id and tag type Tags.

• Id = DynId for ITensors-like runtime identity
• Id = ZST marker type for compile-time-known identity
• Tags = TagSet for tags (default, Arc-wrapped for cheap cloning)

Note: This default implementation does not include symmetry (quantum numbers). For QSpace-compatible indices with non-Abelian symmetries, use a separate concrete type.

Memory Layout

With default types (DynId, TagSet):

• Size: 32 bytes (8 + 8 + 8 + 8)
• Tags are shared via Arc, so cloning is cheap (reference count increment only)

Equality: Two Index values are considered equal if and only if their id and tags fields and plev match (matching ITensors.jl semantics where equality = id + plev + tags).

Example

use tensor4all_core::index::{Index, DynId, TagSet};

// Create shared tags once
let site_tags = TagSet::from_str("Site").unwrap();

// Share the same tags across many indices (cheap clone)
let i1 = Index::<DynId>::new_dyn_with_tags(2, site_tags.clone());
let i2 = Index::<DynId>::new_dyn_with_tags(2, site_tags.clone());
// i1.tags and i2.tags point to the same Arc

Fields

id: Id

The unique identifier for this index.

dim: usize

The dimension (size) of this index.

plev: i64

The prime level of this index.

tags: Tags

The tag set associated with this index.

Implementations

impl<Id, Tags> Index<Id, Tags>

where Tags: Default,

pub fn new(id: Id, dim: usize) -> Self

Create a new index with the given identity and dimension.

pub fn new_with_tags(id: Id, dim: usize, tags: Tags) -> Self

Create a new index with the given identity, dimension, and tags.

pub fn size(&self) -> usize

Get the dimension (size) of the index.

pub fn tags(&self) -> &Tags

Get a reference to the tags.

impl<Id, Tags> Index<Id, Tags>

where Tags: Default,

pub fn new_with_size(id: Id, size: usize) -> Self

Create a new index from dimension (convenience constructor).

pub fn new_with_size_and_tags(id: Id, size: usize, tags: Tags) -> Self

Create a new index from dimension and tags.

impl Index<DynId, TagSet>

pub fn new_dyn(size: usize) -> Self

Create a new index with a generated dynamic ID and no tags.

This is the most common way to create indices. Each call generates a unique random ID, so two calls to new_dyn with the same dimension produce non-equal indices.

Examples

use tensor4all_core::{DynIndex, IndexLike};

let i = DynIndex::new_dyn(4);
let j = DynIndex::new_dyn(4);

assert_eq!(i.dim(), 4);
assert_ne!(i, j);  // different IDs
assert!(i.is_contractable(&i));  // same index is contractable with itself
assert!(!i.is_contractable(&j)); // different IDs

pub fn new_dyn_with_tags(size: usize, tags: TagSet) -> Self

Create a new index with a generated dynamic ID and shared tags.

This is the most efficient way to create many indices with the same tags. The Arc is cloned (reference count increment only), not the underlying data.

Example

use tensor4all_core::index::{Index, DynId, TagSet};

let site_tags = TagSet::from_str("Site").unwrap();
let i1 = Index::<DynId>::new_dyn_with_tags(2, site_tags.clone());
let i2 = Index::<DynId>::new_dyn_with_tags(2, site_tags.clone());

pub fn new_dyn_with_tag(size: usize, tag: &str) -> Result<Self, TagSetError>

Create a new index with a generated dynamic ID and a single tag.

This creates a new TagSet with the given tag. For sharing the same tag across many indices, create the TagSet once and use new_dyn_with_tags instead.

Examples

use tensor4all_core::DynIndex;
use tensor4all_core::TagSetLike;

let site = DynIndex::new_dyn_with_tag(2, "Site").unwrap();
assert!(site.tags().has_tag("Site"));

pub fn new_link(size: usize) -> Result<Self, TagSetError>

Create a new bond index with “Link” tag (for SVD, QR, etc.).

This is a convenience method for creating bond indices commonly used in tensor decompositions like SVD and QR factorization.

Examples

use tensor4all_core::DynIndex;
use tensor4all_core::TagSetLike;

let link = DynIndex::new_link(4).unwrap();
assert!(link.tags().has_tag("Link"));

impl Index<DynId>

pub fn new_bond(dim: usize) -> Result<Self>

Create a new bond index with a fresh identity and the specified dimension.

This is used by factorization operations (SVD, QR) to create new internal bond indices connecting the factors.

Arguments

• dim - The dimension of the new index

Returns

A new index with a unique identity and the specified dimension.

Examples

use tensor4all_core::{DynIndex, IndexLike};

let bond = DynIndex::new_bond(8).unwrap();
assert_eq!(bond.dim(), 8);

pub fn prime(&self) -> Self

Return a copy of this index with its prime level incremented by one.

Primed indices are commonly used to distinguish bra and ket indices in MPO operations (e.g., i for input, i' for output).

Examples

use tensor4all_core::{DynIndex, IndexLike};

let i = DynIndex::new_dyn(4);
assert_eq!(i.plev(), 0);

let i_prime = i.prime();
assert_eq!(i_prime.plev(), 1);

// Primed and unprimed indices have the same ID but are not equal
assert!(i.same_id(&i_prime));
assert_ne!(i, i_prime);

// Primed indices are not contractable with unprimed ones
assert!(!i.is_contractable(&i_prime));

pub fn noprime(&self) -> Self

Return a copy of this index with its prime level reset to zero.

Examples

use tensor4all_core::{DynIndex, IndexLike};

let i = DynIndex::new_dyn(4);
let i2 = i.prime().prime();
assert_eq!(i2.plev(), 2);

let i0 = i2.noprime();
assert_eq!(i0.plev(), 0);
assert_eq!(i0, i);

pub fn set_plev(&self, plev: i64) -> Self

Return a copy of this index with its prime level set explicitly.

Examples

use tensor4all_core::{DynIndex, IndexLike};

let i = DynIndex::new_dyn(4);
let i3 = i.set_plev(3);
assert_eq!(i3.plev(), 3);

Trait Implementations

impl<Id: Clone, Tags: Clone> Clone for Index<Id, Tags>

fn clone(&self) -> Index<Id, Tags>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Id: Debug, Tags: Debug> Debug for Index<Id, Tags>

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

Formats the value using the given formatter.

impl<Id: Hash, Tags: Hash> Hash for Index<Id, Tags>

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<Id: PartialEq, Tags: PartialEq> PartialEq for Index<Id, Tags>

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<Id: Copy, Tags: Copy> Copy for Index<Id, Tags>

impl<Id: Eq, Tags: Eq> Eq for Index<Id, Tags>