Namespace sequant

the main namespace of the SeQuant framework

Namespaces

• Namespace sequant::@005172234170367332144356206300313002316331115131

• Namespace sequant::@027300134233112254207152135230136051140022346036

• Namespace sequant::@031271022253267006125005255144005140351051134266

• Namespace sequant::@102200126142332062021155145225071116066014016061

• Namespace sequant::@146336365230010011315173325146204262024270202022

• Namespace sequant::@164257136232242133030131112363314224354132237123

• Namespace sequant::@217015305055177000044177273215032167254071315354

• Namespace sequant::@273015240273147065312306066062207156113322311254

• Namespace sequant::@301064135276175355261164241271372241023045211300

• Namespace sequant::@306023254001036336020273075121112140142026364156

• Namespace sequant::@313344125275330076255236022211047156026302256004

• Namespace sequant::@320130257232121321140316125166320344111077043017

• Namespace sequant::@351265300341247374234232273270135162143035207326

• Namespace sequant::@370010360137320114115311001110147153052316053340

• Namespace sequant::bits

• Namespace sequant::bitset

• Namespace sequant::container

• Namespace sequant::density

• Namespace sequant::detail

• Namespace sequant::eval

• Namespace sequant::expr_type_rank

• Namespace sequant::hash

• Namespace sequant::impl

• Namespace sequant::io

• Namespace sequant::log

• Namespace sequant::mbpt

• Namespace sequant::meta

• Namespace sequant::opt

• Namespace sequant::point_groups

• Namespace sequant::reserved

• Namespace sequant::space_tags

• Namespace sequant::tensor_network

Classes

• Struct accept_any_index

• Template Struct Annot

• Struct AnyIrrep::Concept

• Template Struct AnyIrrep::Model

• Struct AnyIrrepContext::Concept

• Template Struct AnyIrrepContext::Model

• Struct AnyIrrepSet::Concept

• Template Struct AnyIrrepSet::Model

• Struct AuxGroup

• Struct BackendArrayOps

• Struct BatchContextEntry

• Struct BatchPolicy

• Struct BinarizationOptions

• Struct BraGroup

• Template Struct CacheManager::access_by

• Struct CacheManager::AccessResult

• Struct CacheManager::all_non_persistent

• Struct CacheManager::BuildRecord

• Struct CacheManager::BuildTally

• Struct CanonicalizeOptions

• Template Struct CanonicalTensorCompare

• Struct ColumnGroup

• Template Struct Complex

• Struct ContainsRule

• Struct Context::CachedVersion

• Struct Context::CanonicalizationConfig

• Struct Context::Defaults

• Struct Context::Options

• Struct CostParams

• Struct CSEOptions

• Struct DagScopeLevel

• Struct default_idxptr_slottype_lesscompare

• Template Struct DeprecatedMember

• Struct EvalOpSetter

• Struct ExpandVisitor

• Template Struct Expr::is_shared_ptr_of_expr

• Template Struct Expr::is_shared_ptr_of_expr< ExprPtr, void >

• Template Struct Expr::is_shared_ptr_of_expr_or_derived

• Template Struct Expr::is_shared_ptr_of_expr_or_derived< ExprPtr, void >

• Struct ExpressionFilter::Rule

• Struct ExprMatcherOptions

• Struct ExprRange::cursor

• Struct ExprWithHash

• Struct flattened_rangenest::cursor

• Struct Flops

• Struct FlopsWithSymm

• Struct Index::FullLabelCompare

• Struct Index::IndexFactoryTag

• Struct Index::LabelCompare

• Struct Index::TypeCompare

• Struct Index::TypeEquality

• Struct IndexBasis::bad_key

• Struct IndexBasisRegistry::not_a_space

• Struct IndexBasisSpec

• Struct IndexBasisSpec::Label

• Struct IndexCountRule

• Template Struct IndexGroups

• Struct IndexSlotCounters

• Struct IndexSpace::Attr

• Struct IndexSpace::AttrCompare

• Struct IndexSpace::bad_key

• Struct IndexSpace::KeyCompare

• Struct IndexSpaceCount

• Struct IndexSpaceCountRule

• Struct IndexSpaceSpec

• Template Struct IndexSpecificTensorBlockComparator

• Template Struct InlinedSystem

• Struct IrrepContextSpec

• Struct IrrepContextSpec::Table

• Template Struct IrrepNodeTraits

• Template Struct IrrepNodeTraits< Expr >

• Template Struct IrrepNodeTraits< FullBinaryNode< T > >

• Struct IsComplete

• Struct IsHole

• Struct IsParticle

• Struct IsReferenceOccupied

• Struct IsVacuumOccupied

• Struct KetGroup

• Struct LabelRule

• Struct LexicographicCompareOptions

• Struct Logger

• Struct LoopKey

• Template Struct LTRUncontractedIndices

• Struct make_no_scope_guard

• Struct Memory

• Struct ModeToLevel

• Struct never_volatile

• Struct no_scope_guard

• Struct NoConcreteGroup

• Struct NodeBatchAnnotation

• Struct Op::TypeCompare

• Struct Op::TypeEquality

• Struct OptimizeOptions

• Struct OptimizeResult

• Template Struct PairComparator

• Struct proportional_to

• Struct RadicalForm

• Struct RapidSimplifyVisitor

• Struct ResultExpr::ResultCmp

• Struct RooflineParams

• Struct SlotTypes

• Struct IsComplete

• Struct IsHole

• Struct IsParticle

• Struct IsReferenceOccupied

• Struct IsVacuumOccupied

• Struct StrategyPair

• Struct Sum::move_only_tag

• Struct Tensor::Defaults

• Struct Tensor::reserved_tag

• Struct Tensor::ResolvedSymmetries

• Template Struct TensorBlockComparator

• Struct TensorBlockCompare

• Struct TensorBlockIndexComparer

• Struct TensorIndexComparer

• Struct TensorNetworkV3::CreateGraphOptions

• Struct TensorNetworkV3::Graph

• Struct TensorNetworkV3::SlotCanonicalizationMetadata

• Template Struct TensorOfTensorIndices

• Struct TensorSymmetries

• Struct TransformSumExprOptions

• Template Struct TreeNodeEqualityComparator

• Template Struct TreeNodeHasher

• Template Struct WickTheorem::access_by

• Struct WickTheorem::NontensorWickState

• Struct WickTheorem::TopologicalPartitions

• Struct zero_footprint

• Class AbstractTensor

• Class AnyIrrep

• Class AnyIrrepContext

• Class AnyIrrepSet

• Class AsyCost

• Class AsyCost::AsyCostEntry

• Class bad_any_comparable_cast

• Template Class CacheManager

• Class CacheManager::entry

• Class Constant

• Class Context

• Class ConversionException

• Class CProduct

• Class DefaultTensorCanonicalizer

• Class EvalExpr

• Class Exception

• Class ExportContext

• Class ExportExpr

• Class Expr

• Class ExpressionFilter

• Template Class ExpressionGroup

• Class ExprMatcher

• Class ExprPtr

• Class ExprRange

• Template Class flattened_rangenest

• Template Class ForwardingGenerator

• Template Class FullBinaryNode

• Template Class GenerationOptimizer

• Class GenerationOptimizer::AbstractOperation

• Class GenerationOptimizer::BroadcastAddOperation

• Class GenerationOptimizer::ComputeOperation

• Class GenerationOptimizer::CreateOperation

• Class GenerationOptimizer::DestroyOperation

• Class GenerationOptimizer::LoadAndZeroOperation

• Class GenerationOptimizer::LoadOperation

• Class GenerationOptimizer::PersistOperation

• Class GenerationOptimizer::UnloadOperation

• Class GenerationOptimizer::ZeroOperation

• Template Class Generator

• Class HashingAccumulator

• Template Class HugenholtzVertex

• Class Index

• Class IndexBasis

• Class IndexBasisRegistry

• Class IndexBasisRegistry::SpacesView

• Class SpacesView::iterator

• Class IndexFactory

• Class IndexSpace

• Template Class IrrepContext

• Template Class IrrepSet

• Class ItfContext

• Template Class ItfGenerator

• Template Class JuliaITensorGenerator

• Class JuliaITensorGeneratorContext

• Template Class JuliaTensorKitGenerator

• Class JuliaTensorKitGeneratorContext

• Template Class JuliaTensorOperationsGenerator

• Class JuliaTensorOperationsGeneratorContext

• Class Labeled

• Class LexicographicExprCompare

• Class MemoryStack

• Class MutatableLabeled

• Class NCProduct

• Class Nonconstructible

• Template Class NormalOperator

• Template Class NormalOperatorSequence

• Class NullTensorCanonicalizer

• Class NumPyEinsumGenerator

• Class NumPyEinsumGeneratorContext

• Template Class Op

• Template Class Operator

• Class ParallelExceptions

• Class Power

• Class Product

• Template Class PythonEinsumGeneratorBase

• Class PythonEinsumGeneratorContext

• Class PyTorchEinsumGenerator

• Class PyTorchEinsumGeneratorContext

• Class QuantumNumbersAttr

• Class ReorderingContext

• Class Result

• Class ResultExpr

• Template Class ResultScalar

• Template Class Singleton

• Class SlottedIndex

• Template Class StackCheckingGenerator

• Class Sum

• Template Class SwapCountable

• Template Class SwapCountableRef

• Class TableAlgebra

• Class Taggable

• Class Tensor

• Class TensorBlockCanonicalizer

• Class TensorCanonicalizer

• Class TensorNetworkV3

• Class TensorNetworkV3::Edge

• Class TensorNetworkV3::Vertex

• Class TensorPower

• Template Class TextGenerator

• Class TextGeneratorContext

• Template Class TimerPool

• Class TreeIndex

• Class TypeAttr

• Class UsageSet

• Class Variable

• Class VertexPainter

• Template Class WickTheorem

• Class WickTheorem::Stats

• Template Class Z2Algebra

• Template Class Z2Irrep

Enums

• Enum Action

• Enum AssertBehavior

• Enum AssertStrictBraKetSymmetry

• Enum BatchModeType

• Enum BatchScheduler

• Enum BraKetPos

• Enum BraKetSlotTypesetting

• Enum BraKetSymmetry

• Enum BraKetTypesetting

• Enum CanonicalizationMethod

• Enum ColumnSymmetry

• Enum ComputeSelection

• Enum DeclarationScope

• Enum DeNest

• Enum EvalOp

• Enum Field

• Enum Hermiticity

• Enum IndexBasisMetric

• Enum IndexBasisMetric

• Enum IndexSlotType

• Enum IrrepNodeKind

• Enum IrrepOrigin

• Enum LoadStrategy

• Enum ObjectiveFunction

• Enum OrderType

• Enum PrunableScalars

• Enum ReorderSum

• Enum ResultType

• Enum SlotType

• Enum SPBasis

• Enum Statistics

• Enum Symmetry

• Enum TensorComparison

• Enum Trace

• Enum TreeTraversal

• Enum Usage

• Enum Vacuum

• Enum VertexType

• Enum ZeroStrategy

Functions

• Function sequant::abort_msg

• Template Function sequant::abs

• Function sequant::adjoint(const ExprPtr&)

• Template Function sequant::adjoint(T&&, std::void_t<decltype(std::declval<T&>().adjoint())> *)

• Function sequant::adjoint(Action)

• Function sequant::adjoint(mbpt::qns_t)

• Function sequant::all_indices(IndexSet&, ExprPtr const&)

• Function sequant::all_indices(ExprPtr const&)

• Template Function sequant::apply_canon_phase

• Template Function sequant::apply_index_replacements(AbstractTensor&, const ReplacementMap&, const bool)

• Template Function sequant::apply_index_replacements(ArrayLike&, const ReplacementMap&, const bool)

• Template Function sequant::apply_one_op

• Template Function sequant::apply_one_op_traced

• Function sequant::as_index_group_view

• Function sequant::as_view_of_index_groups

• Function sequant::assert_behavior

• Function sequant::assert_enabled

• Function sequant::assert_failed

• Template Function sequant::asy_cost

• Function sequant::aux_rank

• Function sequant::bann(Index)

• Template Function sequant::bann(Index, std::initializer_list<I>)

• Template Function sequant::bannx

• Function sequant::base_field()

• Template Function sequant::base_field(BraRange, KetRange)

• Template Function sequant::batch_axis(meta::eval_node auto const&, IndexPredicate const&)

• Function sequant::batch_axis(meta::eval_node auto const&)

• Template Function sequant::batch_loop_regions

• Function sequant::bcre(Index)

• Template Function sequant::bcre(Index, std::initializer_list<I>)

• Template Function sequant::bcrex

• Function sequant::begin(const ExprPtr&)

• Function sequant::begin(ExprPtr&)

• Function sequant::binarize(Power const&)

• Function sequant::binarize(Tensor const&)

• Function sequant::binarize(TensorPower const&, IndexSet const&, const BinarizationOptions&, std::size_t&, detail::InlineContext *)

• Function sequant::binarize(Sum const&, IndexSet const&, const BinarizationOptions&, std::size_t&, detail::InlineContext *)

• Function sequant::binarize(Product const&, IndexSet const&, const BinarizationOptions&, std::size_t&, detail::InlineContext *)

• Template Function sequant::binarize(ExprPtr const&, IndexSet const&, const BinarizationOptions&)

• Template Function sequant::binarize(ResultExpr const&, const BinarizationOptions&)

• Template Function sequant::binarize(std::span<const ResultExpr>, const BinarizationOptions&)

• Function sequant::binarize(Constant const&)

• Function sequant::binarize(Variable const&)

• Function sequant::bra_net_rank

• Function sequant::bra_rank

• Function sequant::braket

• Function sequant::braket_symmetry

• Function sequant::braketaux

• Template Function sequant::bubble_sort

• Template Function sequant::bubble_sort_parity

• Template Function sequant::cache_manager(meta::eval_node_range auto const&, size_t)

• Template Function sequant::cache_manager(Nodes&&, size_t)

• Template Function sequant::cache_manager(meta::eval_node_range auto const&, auto&&, size_t, FootprintOf, double)

• Template Function sequant::cache_manager(Nodes&&, auto&&, size_t, FootprintOf, double)

• Template Function sequant::can_contract

• Template Function sequant::canonical_children(TreeNode const&)

• Template Function sequant::canonical_children(TreeNode const&&)

• Template Function sequant::canonical_operand_cmp

• Function sequant::canonicalize(ExprPtr&)

• Function sequant::canonicalize(ExprPtr&&)

• Function sequant::canonicalize(ResultExpr&)

• Function sequant::canonicalize(ResultExpr&&)

• Function sequant::canonicalize_tensor_leaf

• Template Function sequant::carried_atoms

• Function sequant::cbegin

• Function sequant::cend

• Template Function sequant::clone

• Template Function sequant::collect_tensor_factors

• Function sequant::color

• Function sequant::column_symmetry

• Template Function sequant::conj

• Template Function sequant::conjugate

• Function sequant::contracted_indices

• Function sequant::coprime_base

• Template Function sequant::count_cycles

• Template Function sequant::counted_swap

• Function sequant::cross_type_less

• Function sequant::csv_labels

• Function sequant::current_context_version

• Function sequant::current_contexts_version

• Function sequant::default_context_manipulation_threadsafe

• Function sequant::default_registry_resolved

• Function sequant::DEFINE_STRONG_TYPE_FOR_RANGE_AND_RANGESIZE(cre)

• Function sequant::DEFINE_STRONG_TYPE_FOR_RANGE_AND_RANGESIZE(ann)

• Function sequant::DEFINE_STRONG_TYPE_FOR_RANGE_AND_RANGESIZE(bra)

• Function sequant::DEFINE_STRONG_TYPE_FOR_RANGE_AND_RANGESIZE(ket)

• Function sequant::DEFINE_STRONG_TYPE_FOR_RANGE_AND_RANGESIZE(aux)

• Function sequant::denominator

• Template Function sequant::deserialize(std::string_view, const io::serialization::DeserializationOptions&)

• Template Function sequant::deserialize(std::wstring_view, const io::serialization::DeserializationOptions&)

• Function sequant::diff

• Template Function sequant::diff_indices

• Function sequant::diff_spaces

• Function sequant::different_instances

• Function sequant::end(const ExprPtr&)

• Function sequant::end(ExprPtr&)

• Function sequant::enforce_failed

• Template Function sequant::eval_result

• Template Function sequant::evaluate(Nodes const&, BatchPolicy const&, auto const&, F const&, CacheManager<N, FHC>&, std::initializer_list<std::wstring>, ScopeGuardFactory)

• Template Function sequant::evaluate(Node const&, F const&, CacheManager<N, FHC>&)

• Template Function sequant::evaluate(Node const&, auto const&, F const&, CacheManager<N, FHC>&)

• Template Function sequant::evaluate(Nodes const&, auto const&, F const&, CacheManager<N, FHC>&)

• Template Function sequant::evaluate(Nodes const&, F const&, CacheManager<N, FHC>&)

• Template Function sequant::evaluate(Args&&…)

• Template Function sequant::evaluate_antisymm

• Template Function sequant::evaluate_impl(Node const&, F const&, CacheManager<N, FHC>&)

• Template Function sequant::evaluate_impl(Args&&…)

• Template Function sequant::evaluate_multiroot

• Template Function sequant::evaluate_symm

• Template Function sequant::ex

• Function sequant::expand(ExprPtr&)

• Function sequant::expand(ExprPtr&&)

• Function sequant::expand(ResultExpr&)

• Function sequant::expand(ResultExpr&&)

• Template Function sequant::export_expression

• Template Function sequant::export_group

• Template Function sequant::export_groups

• Function sequant::expr_type_id_less

• Template Function sequant::external_indices(const Expr&)

• Template Function sequant::external_indices(const ExprPtr&)

• Function sequant::factorial

• Function sequant::fann(Index)

• Template Function sequant::fann(Index, std::initializer_list<I>)

• Template Function sequant::fannx

• Function sequant::fcre(Index)

• Template Function sequant::fcre(Index, std::initializer_list<I>)

• Template Function sequant::fcrex

• Template Function sequant::fetch_and_increment

• Template Function sequant::fetch_leaf_traced

• Template Function sequant::find_leaf_carrying

• Template Function sequant::find_position

• Function sequant::flatten(ExprPtr&)

• Function sequant::flatten(ExprPtr&&)

• Function sequant::flatten(ResultExpr&)

• Function sequant::flatten(ResultExpr&&)

• Template Function sequant::fold_left_to_node

• Template Function sequant::for_each

• Template Function sequant::get_bra_idx(Group&&)

• Template Function sequant::get_bra_idx(Group&&)

• Function sequant::get_complete_space

• Function sequant::get_default_context

• Function sequant::get_default_context_snapshot

• Function sequant::get_default_index_basis_registry

• Function sequant::get_default_index_space_registry

• Function sequant::get_hole_space

• Template Function sequant::get_ket_idx(Group&&)

• Template Function sequant::get_ket_idx(Group&&)

• Function sequant::get_particle_space

• Template Function sequant::get_uncontracted_indices

• Template Function sequant::get_unique_indices(const ExprPtr&)

• Template Function sequant::get_unique_indices(const Constant&)

• Template Function sequant::get_unique_indices(const Variable&)

• Template Function sequant::get_unique_indices(const Power&)

• Template Function sequant::get_unique_indices(const TensorPower&)

• Template Function sequant::get_unique_indices(const Tensor&)

• Template Function sequant::get_unique_indices(const Sum&)

• Template Function sequant::get_unique_indices(const Product&)

• Template Function sequant::get_unique_indices(const Expr&)

• Template Function sequant::get_used_indices(const Expr&)

• Template Function sequant::get_used_indices(const ExprPtr&)

• Template Function sequant::get_used_indices_with_counts(const Expr&)

• Template Function sequant::get_used_indices_with_counts(const ExprPtr&)

• Function sequant::git_description

• Function sequant::git_revision

• Template Function sequant::has_duplicates

• Function sequant::has_symmetrizer

• Function sequant::has_tensor

• Template Function sequant::hash_value(const Op<S>&)

• Function sequant::hash_value(const IndexSpace&)

• Function sequant::hash_value(const ExprPtr&)

• Template Function sequant::hash_value(const T&)

• Template Function sequant::hash_value(const T&)

• Function sequant::hash_value(const Index&)

• Function sequant::hash_version

• Function sequant::hermiticity

• Template Function sequant::home_scope

• Template Function sequant::imed_hashes

• Function sequant::includes(IndexSpace::Type, IndexSpace::Type)

• Function sequant::includes(IndexSpace::QuantumNumbers, IndexSpace::QuantumNumbers)

• Function sequant::includes(const IndexSpace&, const IndexSpace&)

• Function sequant::includes(const IndexBasis&, const IndexBasis&)

• Function sequant::index_position

• Template Function sequant::inits

• Function sequant::instance_qualified_label

• Function sequant::iroot

• Template Function sequant::irrep_to_string

• Template Function sequant::irreps_of(const Expr&, const Ctx&)

• Template Function sequant::irreps_of(const ResultExpr&, const Ctx&)

• Template Function sequant::irreps_of(const FullBinaryNode<T>&, const Ctx&, OnNode&&)

• Function sequant::is_adjoint_label

• Template Function sequant::is_annihilator

• Function sequant::is_cnumber

• Template Function sequant::is_creator

• Function sequant::is_kronecker_equivalent

• Template Function sequant::is_pure_qpannihilator

• Template Function sequant::is_pure_qpcreator

• Template Function sequant::is_qpannihilator

• Template Function sequant::is_qpcreator

• Function sequant::is_unary

• Function sequant::is_valid(const ExprPtr&, std::string *)

• Function sequant::is_valid(const Expr&, std::string *)

• Function sequant::is_valid(const ResultExpr&, std::string *)

• Template Function sequant::join_strings

• Function sequant::ket_net_rank

• Function sequant::ket_rank

• Function sequant::label

• Template Function sequant::left_to_right_binarization_indices

• Template Function sequant::lexicographic_compare(const Op<S>&, const Op<S>&)

• Function sequant::lexicographic_compare()

• Template Function sequant::linearize_eval_node

• Function sequant::make_antisymmetrizer()

• Function sequant::make_antisymmetrizer()

• Template Function sequant::make_batched_custom_evaluator

• Template Function sequant::make_evaluator

• Template Function sequant::make_extent_array_ops

• Function sequant::make_identity

• Template Function sequant::make_indices

• Template Function sequant::make_irrep

• Function sequant::make_irrep_context

• Function sequant::make_kronecker

• Function sequant::make_overlap

• Function sequant::make_symmetrizer()

• Function sequant::make_symmetrizer()

• Template Function sequant::make_ta_array_ops

• Template Function sequant::max_extent_basis

• Function sequant::min_storage

• Function sequant::mode_to_level_from_signature

• Template Function sequant::next_permutation_parity

• Function sequant::non_canon_simplify(ResultExpr&)

• Function sequant::non_canon_simplify(ResultExpr&&)

• Function sequant::non_canon_simplify(ExprPtr&)

• Template Function sequant::norm_squared

• Template Function sequant::normalize

• Function sequant::normalize_irrep_spec

• Template Function sequant::note_fresh_build

• Function sequant::num_indices

• Function sequant::num_slots

• Function sequant::num_threads

• Function sequant::numerator

• Template Function sequant::open_atoms

• Function sequant::operator!

• Template Function sequant::operator!=(const Op<S>&, const Op<S>&)

• Template Function sequant::operator!=(const Complex<T>&, const Complex<T>&)

• Template Function sequant::operator!=(const X&, const Complex<T>&)

• Function sequant::operator!=(const Context&, const Context&)

• Function sequant::operator!=(AsyCost const&, AsyCost const&)

• Template Function sequant::operator!=(const Complex<T>&, const X&)

• Template Function sequant::operator!=(const Complex<T>&, const T&)

• Template Function sequant::operator!=(const T&, const Complex<T>&)

• Function sequant::operator!=(UsageSet, Usage)

• Function sequant::operator!=(Usage, UsageSet)

• Function sequant::operator&(CanonicalizationMethod, CanonicalizationMethod)

• Function sequant::operator&(ComputeSelection, ComputeSelection)

• Function sequant::operator&(ZeroStrategy, ZeroStrategy)

• Function sequant::operator&(TreeTraversal, TreeTraversal)

• Function sequant::operator&(UsageSet, Usage)

• Function sequant::operator&(Usage, UsageSet)

• Function sequant::operator&(PrunableScalars, PrunableScalars)

• Function sequant::operator&=

• Template Function sequant::operator*(T&&, const ExprPtr&)

• Template Function sequant::operator*(const ExprPtr&, T&&)

• Function sequant::operator*(const ExprPtr&, const ExprPtr&)

• Template Function sequant::operator*(const ExprPtr&, T&&)

• Template Function sequant::operator*(T&&, const ExprPtr&)

• Function sequant::operator*(AsyCost const&, rational)

• Function sequant::operator*(rational, AsyCost const&)

• Template Function sequant::operator*(const Complex<T>&, const Complex<T>&)

• Template Function sequant::operator*(const U&, const Complex<T>&)

• Template Function sequant::operator*(const Complex<T>&, const U&)

• Template Function sequant::operator+(T&&, const ExprPtr&)

• Template Function sequant::operator+(const ExprPtr&, T&&)

• Function sequant::operator+(const ExprPtr&, const ExprPtr&)

• Template Function sequant::operator+(const ExprPtr&, T&&)

• Template Function sequant::operator+(T&&, const ExprPtr&)

• Function sequant::operator+(AsyCost const&, AsyCost const&)

• Template Function sequant::operator+(const Complex<T>&)

• Template Function sequant::operator+(const Complex<T>&, const Complex<T>&)

• Template Function sequant::operator-(T&&, const ExprPtr&)

• Template Function sequant::operator-(const ExprPtr&, T&&)

• Function sequant::operator-(const ExprPtr&, const ExprPtr&)

• Template Function sequant::operator-(const ExprPtr&, T&&)

• Template Function sequant::operator-(T&&, const ExprPtr&)

• Function sequant::operator-(AsyCost const&, AsyCost const&)

• Template Function sequant::operator-(const Complex<T>&)

• Template Function sequant::operator-(const Complex<T>&, const Complex<T>&)

• Template Function sequant::operator/(const ExprPtr&, T&&)

• Function sequant::operator/(const ExprPtr&, const Constant&)

• Template Function sequant::operator/(const U&, const Complex<T>&)

• Function sequant::operator/(AsyCost const&, rational)

• Template Function sequant::operator/(const Complex<T>&, const Complex<T>&)

• Template Function sequant::operator<(const Op<S1>&, const Op<S2>&)

• Function sequant::operator<(AsyCost const&, AsyCost const&)

• Template Function sequant::operator<(const SwapCountable<T>&, const SwapCountable<T>&)

• Template Function sequant::operator<(const SwapCountableRef<T>&, const SwapCountableRef<T>&)

• Template Function sequant::operator<<(std::basic_ostream<Char, Traits>&, const ExprPtr&)

• Template Function sequant::operator<<(std::basic_ostream<Char, Traits>&, const ResultExpr&)

• Template Function sequant::operator<<(std::basic_ostream<Char, Traits>&, const Expr&)

• Template Function sequant::operator<<(std::basic_ostream<CharT, Traits>&, SlotType)

• Function sequant::operator<=

• Function sequant::operator<=>(const IndexSpace&, const IndexSpace&)

• Function sequant::operator<=>(const ExprMatcher&, const Expr&)

• Function sequant::operator<=>(const ExprMatcher&, const ExprPtr&)

• Function sequant::operator<=>(const Expr&, const ExprMatcher&)

• Function sequant::operator<=>(const ExprPtr&, const ExprMatcher&)

• Function sequant::operator==(const ExprPtr&, const ExprPtr&)

• Function sequant::operator==(const Expr&, const Expr&)

• Template Function sequant::operator==(const Op<S>&, const Op<S>&)

• Template Function sequant::operator==(const Operator<S>&, const Operator<S>&)

• Template Function sequant::operator==(const NormalOperator<S>&, const NormalOperator<S>&)

• Function sequant::operator==(const AnyIrrep&, const AnyIrrep&)

• Function sequant::operator==(const AnyIrrepSet&, const AnyIrrepSet&)

• Template Function sequant::operator==(const Complex<T>&, const Complex<T>&)

• Template Function sequant::operator==(const Complex<T>&, const X&)

• Template Function sequant::operator==(const X&, const Complex<T>&)

• Template Function sequant::operator==(const T&, const Complex<T>&)

• Function sequant::operator==(const Context&, const Context&)

• Function sequant::operator==(const ExprMatcher&, const Expr&)

• Function sequant::operator==(AsyCost const&, AsyCost const&)

• Function sequant::operator==(const ExprMatcher&, const ExprPtr&)

• Function sequant::operator==(const Expr&, const ExprMatcher&)

• Function sequant::operator==(const ExprPtr&, const ExprMatcher&)

• Function sequant::operator==(IndexSpace const&, IndexSpace const&)

• Template Function sequant::operator==(const Complex<T>&, const T&)

• Template Function sequant::operator==(FullBinaryNode<T> const&, FullBinaryNode<U> const&)

• Function sequant::operator==(UsageSet, Usage)

• Function sequant::operator==(Usage, UsageSet)

• Function sequant::operator>

• Function sequant::operator>=

• Function sequant::operator^

• Function sequant::operator|(CanonicalizationMethod, CanonicalizationMethod)

• Function sequant::operator|(ComputeSelection, ComputeSelection)

• Function sequant::operator|(SlotType, SlotType)

• Function sequant::operator|(ZeroStrategy, ZeroStrategy)

• Function sequant::operator|(TreeTraversal, TreeTraversal)

• Function sequant::operator|(PrunableScalars, PrunableScalars)

• Function sequant::operator|=

• Function sequant::operator~

• Function sequant::optimize(ExprPtr const&, OptimizeOptions)

• Function sequant::optimize(ResultExpr&, OptimizeOptions)

• Function sequant::optimize(ResultExpr&&, OptimizeOptions)

• Function sequant::optimize(ExprPtr const&, bool)

• Function sequant::optimize(ResultExpr&, bool)

• Function sequant::optimize(ResultExpr&&, bool)

• Function sequant::optimize_result

• Function sequant::ordinal_compare

• Template Function sequant::parallel_do

• Function sequant::peak_cache

• Template Function sequant::permutation_parity

• Template Function sequant::permute

• Function sequant::permute_bra

• Function sequant::permute_braket

• Function sequant::permute_ket

• Function sequant::pin_default_contexts

• Function sequant::pop_symmetrizer(ExprPtr&)

• Function sequant::pop_symmetrizer(ResultExpr&)

• Function sequant::pop_tensor

• Function sequant::pow

• Function sequant::pow2

• Function sequant::power_exponent

• Template Function sequant::printf

• Template Function sequant::product

• Function sequant::profile

• Function sequant::prune_to_matches

• Function sequant::push_symmetrizer

• Template Function sequant::qpannihilator_space

• Template Function sequant::qpcreator_space

• Function sequant::rapid_simplify(ExprPtr&)

• Function sequant::rapid_simplify(ResultExpr&)

• Function sequant::rapid_simplify(ResultExpr&&)

• Template Function sequant::recycle_intermediate_names

• Template Function sequant::relevant_basis

• Function sequant::remove_tensor

• Function sequant::replace(ExprPtr&, const ExprMatcher&, const Expr&)

• Function sequant::replace(ResultExpr&, const ExprMatcher&, const Expr&)

• Template Function sequant::replace(ExprPtr&, const ExprPtr&, const ExprPtr&, EqualityComparator)

• Template Function sequant::replace(ResultExpr&, const ExprPtr&, const ExprPtr&, EqualityComparator)

• Function sequant::reset_default_context

• Function sequant::reset_tags()

• Function sequant::reset_tags()

• Template Function sequant::reset_ts_swap_counter

• Template Function sequant::resolve_by_block

• Template Function sequant::resolve_by_label

• Template Function sequant::resolve_by_pattern

• Function sequant::result_symmetrization(const Tensor&, std::wstring_view)

• Function sequant::result_symmetrization(const ResultExpr&, std::wstring_view)

• Template Function sequant::retrieve_space

• Function sequant::same_instance

• Template Function sequant::select_impl

• Template Function sequant::serialize

• Function sequant::set_default_context()

• Function sequant::set_default_context()

• Function sequant::set_default_context()

• Function sequant::set_locale

• Function sequant::set_num_threads

• Function sequant::set_scoped_default_context()

• Function sequant::set_scoped_default_context()

• Function sequant::set_scoped_default_context()

• Function sequant::set_scoped_modified_default_context

• Template Function sequant::signatures_consistent

• Function sequant::simplest_radical_form

• Function sequant::simplify(ExprPtr&)

• Function sequant::simplify(ExprPtr&&)

• Function sequant::simplify(ResultExpr&)

• Function sequant::simplify(ResultExpr&&)

• Function sequant::size(const Expr&)

• Function sequant::size(const ExprPtr&)

• Template Function sequant::slicing_signature

• Function sequant::slots

• Template Function sequant::sort_expr(Expr&, const Compare&)

• Template Function sequant::sort_expr(ResultExpr&, const Compare&)

• Template Function sequant::sort_then_replace_by_ordinals

• Template Function sequant::sort_via_ordinals

• Template Function sequant::stamp_occurrence_homes

• Template Function sequant::string_to(std::string_view, int)

• Template Function sequant::string_to(std::wstring_view, int)

• Template Function sequant::string_to(std::string_view, std::chars_format)

• Template Function sequant::string_to(std::wstring_view, std::chars_format)

• Function sequant::strip_adjoint_label

• Template Function sequant::strongly_connected_components_indexed

• Function sequant::subset_target_indices

• Template Function sequant::subtree_any

• Template Function sequant::sum_in_place_traced

• Function sequant::swap(Index&, Index&)

• Template Function sequant::swap(SwapCountable<T>&, SwapCountable<T>&)

• Template Function sequant::swap(const SwapCountableRef<T>&, const SwapCountableRef<T>&)

• Function sequant::symmetry

• Function sequant::tensors_commute

• Function sequant::throw_failure

• Template Function sequant::to_basic_string_view

• Template Function sequant::to_bitset

• Function sequant::to_braket_symmetry

• Template Function sequant::to_export_tree(const ExprPtr&, bool)

• Template Function sequant::to_export_tree(const ResultExpr&, bool)

• Template Function sequant::to_expr(meta::eval_node auto const&, LeafMap&&)

• Function sequant::to_expr(meta::eval_node auto const&)

• Function sequant::to_hermiticity

• Template Function sequant::to_latex(T&&)

• Template Function sequant::to_latex(const mbpt::Operator<mbpt::qns_t, S>&)

• Function sequant::to_latex_align

• Function sequant::to_latex_tensor

• Template Function sequant::to_ratio

• Template Function sequant::to_rational(T, T, std::size_t)

• Template Function sequant::to_rational(T)

• Function sequant::to_string(const rational&)

• Template Function sequant::to_string(const boost::multiprecision::number<Backend>&)

• Function sequant::to_string(IndexSpace::Type)

• Function sequant::to_string(IndexSpace::QuantumNumbers)

• Function sequant::to_string(IndexSpace::Attr)

• Function sequant::to_string(const IndexSpace&)

• Template Function sequant::to_string(const IrrepSet<Irrep>&)

• Template Function sequant::to_string(const Complex<T>&)

• Function sequant::to_string(Vacuum)

• Function sequant::to_wstring(CanonicalizationMethod)

• Function sequant::to_wstring(const rational&)

• Template Function sequant::to_wstring(const boost::multiprecision::number<Backend>&)

• Function sequant::to_wstring(meta::integral auto)

• Function sequant::to_wstring(std::floating_point auto)

• Function sequant::to_wstring(Symmetry)

• Function sequant::toggle_adjoint_label

• Function sequant::toplevel_diff(const Constant&, const Constant&)

• Function sequant::toplevel_diff(const Variable&, const Variable&)

• Function sequant::toplevel_diff(const Index&, const Index&)

• Function sequant::toplevel_diff(const Tensor&, const Tensor&)

• Function sequant::toplevel_diff(const TensorPower&, const TensorPower&)

• Function sequant::toplevel_diff(const Sum&, const Sum&)

• Function sequant::toplevel_diff(const Product&, const Product&)

• Template Function sequant::topological_order

• Template Function sequant::topological_order_indexed

• Template Function sequant::tot_indices

• Function sequant::toUtf16(std::string_view)

• Function sequant::toUtf16(std::wstring_view)

• Function sequant::toUtf16(char)

• Function sequant::toUtf16(wchar_t)

• Function sequant::toUtf8(const std::wstring_view)

• Function sequant::toUtf8(std::string_view)

• Function sequant::toUtf8(char)

• Function sequant::toUtf8(wchar_t)

• Function sequant::transform_expr(const ExprPtr&, const container::map<Index, Index>&, Constant::scalar_type)

• Function sequant::transform_expr(const Expr&, const container::map<Index, Index>&, Constant::scalar_type)

• Function sequant::transform_indices

• Template Function sequant::transform_node

• Template Function sequant::transform_reduce

• Template Function sequant::transform_sum_expr

• Template Function sequant::try_custom_eval

• Template Function sequant::ts_swap_counter_is_even

• Template Function sequant::type_name_of

• Function sequant::value_key

• Template Function sequant::value_key_of

• Template Function sequant::visit_leaf_expr

• Template Function sequant::wprintf

• Template Function sequant::write_log

Typedefs

• Typedef sequant::AbstractTensorPtr

• Typedef sequant::bitset_t

• Typedef sequant::BNOperator

• Typedef sequant::BNOperatorSeq

• Typedef sequant::BOp

• Typedef sequant::BOperator

• Typedef sequant::BWickTheorem

• Typedef sequant::ConstantPtr

• Typedef sequant::ConstExprIterator

• Typedef sequant::CProductPtr

• Typedef sequant::EmptyInitializerList

• Typedef sequant::EvalExprNode

• Typedef sequant::EvalNode

• Typedef sequant::EvalSequence

• Typedef sequant::ExportNode

• Typedef sequant::expr_range

• Typedef sequant::ExprIterator

• Typedef sequant::ExprPtrList

• Typedef sequant::ExprPtrVector

• Typedef sequant::FNOperator

• Typedef sequant::FNOperatorSeq

• Typedef sequant::FOp

• Typedef sequant::FOperator

• Typedef sequant::FWickTheorem

• Typedef sequant::get_support

• Typedef sequant::index_to_extent_t

• Typedef sequant::IndexList

• Typedef sequant::IndexSet

• Typedef sequant::IndexSpecificTensorBlockEqualComparator

• Typedef sequant::IndexSpecificTensorBlockLessThanComparator

• Typedef sequant::IndexVec

• Typedef sequant::intmax_t

• Typedef sequant::LoopId

• Typedef sequant::NCProductPtr

• Typedef sequant::PeakSink

• Typedef sequant::PowerPtr

• Typedef sequant::ProductPtr

• Typedef sequant::ProtoBundle

• Typedef sequant::PythonEinsumGenerator

• Typedef sequant::ratio

• Typedef sequant::rational

• Typedef sequant::ResultPtr

• Typedef sequant::SubexpressionHashCollector

• Typedef sequant::SubexpressionNames

• Typedef sequant::SubexpressionUsageCounts

• Typedef sequant::suitable_call_operator

• Typedef sequant::SumPtr

• Typedef sequant::tensor_index_comparer_t

• Typedef sequant::tensor_index_pair_comparer_t

• Typedef sequant::tensor_index_pair_t

• Typedef sequant::TensorBlockEqualComparator

• Typedef sequant::TensorBlockLessThanComparator

• Typedef sequant::TensorNetwork

• Typedef sequant::TensorPowerPtr

• Typedef sequant::TensorPtr

• Typedef sequant::VariablePtr

• Typedef sequant::WstrList

Variables

• Variable sequant::adjoint_label

• Variable sequant::antisymmetrizer_symmetries

• Variable sequant::AnySlotType

• Variable sequant::default_max_folded_bits

• Variable sequant::expr_ptr_comparer

• Variable sequant::has_boost_hash_value_v

• Variable sequant::has_hash_value_member_fn_v

• Variable sequant::has_hash_value_v

• Variable sequant::is_a_constant_v

• Variable sequant::is_a_power_v

• Variable sequant::is_a_product_v

• Variable sequant::is_a_sum_v

• Variable sequant::is_a_tensor_power_v

• Variable sequant::is_a_variable_v

• Variable sequant::is_an_expr_v

• Variable sequant::space_tags::is_complete

• Variable sequant::is_constant_v

• Variable sequant::is_expr_v

• Variable sequant::space_tags::is_hole

• Variable sequant::space_tags::is_particle

• Variable sequant::is_power_v

• Variable sequant::is_product_v

• Variable sequant::space_tags::is_reference_occupied

• Variable sequant::is_sum_v

• Variable sequant::is_tensor_power_v

• Variable sequant::is_tuple_like_v

• Variable sequant::space_tags::is_vacuum_occupied

• Variable sequant::is_variable_v

• Variable sequant::symmetrizer_symmetries