Class Index¶

Defined in File index.hpp

Nested Relationships¶

Nested Types¶

Inheritance Relationships¶

Base Type¶

public sequant::Taggable (Class Taggable)

Class Documentation¶

class Index : public sequant::Taggable ¶

Index = label + IndexSpace.

Note

Unlike SeQuant1’s ParticleIndex, this Index supports dependencies between indices to be able to express e.g. hierarchical partitioning of index spaces or hierarchical nesting of spaces

Note

Index label can be plain (label) or composite (label_ordinal) where label is a string of characters excluding ‘_’, and ordinal is an integer less than the value returned by min_tmp_label() .

Note

Index and other SeQuant classes currently use wide characters to represent labels and other strings; this goes against some popular recommendations to use narrow strings (bytestrings) everywhere. The rationale for such choice makes “character”-centric operations easy without the need to grok Unicode and to introduce extra dependencies such as [https://github.com/unicode-org/icu](ICU). Many functions accept bytestrings as input, but they are recoded to wide (but UTF-8 encoded) strings. For optimal efficiency and simplicity users are recommended to use wide strings until further notice.

Public Types

using index_vector = container::vector<Index>¶: protoindices cannot be represented by small_vector because it does not accept incomplete types, see https://www.boost.org/doc/libs/master/doc/html/container/main_features.html#container.main_features.containers_of_incomplete_types N.B. hard-coding alignment should lift this restriction but it seems that alignof is still invoked (for no good reason)

Public Functions

Index() = default¶

template<typename String, typename = std::enable_if_t<meta::is_basic_string_convertible_v<std::remove_reference_t<String>>>> inline Index(String &&label, const IndexSpace &space, IndexList proto_indices, bool symmetric_proto_indices = true)¶

Parameters:

label – the label, does not need to be unique
space – (a const ref to) the IndexSpace object that specifies to this space this object belongs
proto_indices – labels of proto indices (all must be unique, i.e. duplicates are not allowed)
symmetric_proto_indices – if true, proto_indices can be permuted at will and will always be sorted

template<typename String, typename = std::enable_if_t<meta::is_basic_string_convertible_v<std::remove_reference_t<String>>>> inline Index(String &&label, const IndexSpace &space, container::vector<Index> proto_indices, bool symmetric_proto_indices = true)¶

Parameters:

label – the label, does not need to be unique
space – (a const ref to) the IndexSpace object that specifies to this space this object belongs
proto_indices – labels of proto indices (all must be unique, i.e. duplicates are not allowed)
symmetric_proto_indices – if true, proto_indices can be permuted at will and will always be sorted

template<typename String, typename = std::enable_if_t<meta::is_basic_string_convertible_v<std::remove_reference_t<String>>>> inline Index(String &&label)¶

See also

Index::color()

Returns:: the color of the protoindices

inline auto color() const¶

Color of an Index = hashed IndexSpace + IndexSpace objects of the protoindices

Returns:: the color of this object

template<template<typename, typename, typename ...Args> class Map, typename ...Args> inline bool transform(const Map<Index, Index, Args...> &index_map)¶

index replacement replaces this object with its image in the Index map. If this object was not found in the map, tries replacing its subindices.

Parameters:

index_map – maps Index to Index

Returns:

false if no replacements were made

Pre:

 this->tag().has_value() == false || (this->tag().has_value()
== true && this->tag().value<int>() == 0) 

Post:

if return value is true:

 this->tag().has_value() == true &&
this->tag().value<int>() == 0 

Public Static Functions

static inline Index make_tmp_index(const IndexSpace &space)¶

creates a globally-unique temporary index in space space . The label of the resulting index = IndexSpace::base_key(space) + ‘_’ + temporary counter. Each call increments the current tmp counter (see next_tmp_index() ) . To make neater temporary indices unique in a given scope (e.g. a single term in an expression) use IndexFactory.

Parameters:: space – an IndexSpace object
Returns:: a unique temporary index in space space

template<typename IndexRange, typename = std::enable_if_t<meta::is_range_v<std::remove_reference_t<IndexRange>>>> static inline Index make_tmp_index(const IndexSpace &space, IndexRange &&proto_indices, bool symmetric_proto_indices = true)¶

creates a globaly-unique temporary index in space space . The label of the resulting index = IndexSpace::base_key(space) + ‘_’ + temporary counter. Each call increments the current tmp counter (see next_tmp_index() ) . To make neater temporary indices unique in a given scope (e.g. a single term in an expression) use IndexFactory.

Parameters:

space – an IndexSpace object
proto_indices – list of proto indices (all must be unique, i.e. duplicates are not allowed)
symmetric_proto_indices – if true, proto_indices can be permuted at will and will always be sorted

Returns:

a unique temporary index in space space

static inline std::pair<std::wstring_view, std::wstring_view> make_split_label(std::wstring_view label)¶

Parameters:: label – an Index label (e.g., returned by Index::label())
Returns:: label split into base and ordinal parts; the ordinal part is empty, if missing

static inline std::wstring make_merged_label(std::wstring_view base_label, std::wstring_view ordinal_label)¶

Parameters:

base_label – base part of an Index label
ordinal_label – ordinal part of an Index label

Returns:

base_label and ordinal_label merged

template<typename WS1, typename WS2, typename = std::enable_if_t<(meta::is_wstring_or_view_v<std::decay_t<WS1>> && meta::is_wstring_convertible_v<std::decay_t<WS2>>)>> static inline std::wstring make_label_plus_suffix(WS1 &&label, WS2 &&suffix)¶

makes a new label by appending a suffix to the label

Appends suffix to label itself (if plain) or to its core (if composite)

Parameters:

label – the label to append the suffix to
suffix – a string to append to the label

Returns:

this->label() with suffix appended

makes a new label by removing a substring from the label

Removes substr from label itself (if plain) or from its core (if composite)

Parameters:

label – the label to remove the substring from
substr – a string to remove from the label

Returns:

this->label() with substr removed

template<typename Range> static inline auto proto_indices_color(const Range &protoindex_range)¶