Namespace sequant

the main namespace of the SeQuant framework

Detailed Description

Create SeQuant expression from string input.

: Bimal Gaudel version: 21 July, 2021

Namespaces

• Namespace sequant::@13

• Namespace sequant::@143

• Namespace sequant::@16

• Namespace sequant::@17

• Namespace sequant::@19

• Namespace sequant::@4

• Namespace sequant::@47

• Namespace sequant::antisymm

• Namespace sequant::bitset

• Namespace sequant::container

• Namespace sequant::cse

• Namespace sequant::detail

• Namespace sequant::details

• Namespace sequant::hash

• Namespace sequant::impl

• Namespace sequant::log

• Namespace sequant::mbpt

• Namespace sequant::meta

• Namespace sequant::opt

• Namespace sequant::parse

• Namespace sequant::space_tags

• Namespace sequant::tensor_network

Classes

• Template Struct Annot

• Struct assume_real_orbitals

• Struct assume_strict_column_permutability

• Struct AuxGroup

• Struct BraGroup

• Template Struct CacheManager::access_by

• Struct CanonicalizeOptions

• Template Struct CanonicalTensorCompare

• Struct ColumnGroup

• Template Struct compare_first_less

• Template Struct Complex

• Struct Context::Defaults

• Struct Context::Options

• Struct default_idxptr_slottype_lesscompare

• Template Struct ErrorHandler

• Struct EvalOpSetter

• Struct ExpandVisitor

• Struct Expr::cursor

• 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 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

• Template Struct IndexGroups

• Struct IndexSlotCounters

• Struct IndexSpace::Attr

• Struct IndexSpace::AttrCompare

• Struct IndexSpace::bad_key

• Struct IndexSpace::KeyCompare

• Template Struct is_tensor

• Struct IsComplete

• Struct IsHole

• Struct IsParticle

• Struct IsReferenceOccupied

• Struct IsVacuumOccupied

• Struct KetGroup

• Struct Logger

• Struct Memory

• Struct Op::TypeCompare

• Struct Op::TypeEquality

• Template Struct PairComparator

• Struct ParseError

• Struct proportional_to

• Struct RapidSimplifyVisitor

• Struct ResultExpr::ResultCmp

• Struct SimplifyOptions

• Template Struct Singleton::is_default_constructible_helper

• Struct IsComplete

• Struct IsHole

• Struct IsParticle

• Struct IsReferenceOccupied

• Struct IsVacuumOccupied

• Struct StrategyPair

• Struct Sum::move_only_tag

• Struct Tensor::reserved_tag

• Template Struct TensorBlockComparator

• Struct TensorBlockCompare

• Struct TensorBlockIndexComparer

• Struct TensorIndexComparer

• Struct TensorNetworkV1::BlissGraphOptions

• Struct Edge::Terminal

• Struct TensorNetworkV1::FullLabelCompare

• Struct TensorNetworkV1::GraphData

• Struct TensorNetworkV1::SlotCanonicalizationMetadata

• Struct TensorNetworkV2::CreateGraphOptions

• Struct TensorNetworkV2::Graph

• Struct TensorNetworkV2::SlotCanonicalizationMetadata

• Struct TensorNetworkV3::CreateGraphOptions

• Struct TensorNetworkV3::Graph

• Struct TensorNetworkV3::SlotCanonicalizationMetadata

• Template Struct TensorOfTensorIndices

• Struct TextGeneratorContext

• Struct TransformSumExprOptions

• Template Struct WickTheorem::access_by

• Struct WickTheorem::NontensorWickState

• Class AbstractTensor

• Class antisymm_element

• Class antisymmetrize

• Class AsyCost

• Class AsyCost::AsyCostEntry

• Class bad_any_comparable_cast

• Class CacheManager

• Class CacheManager::entry

• Class Constant

• Class Context

• Class CProduct

• Class DefaultTensorCanonicalizer

• Class EvalExpr

• Class EvalExprBTAS

• Class EvalExprTA

• Class Exception

• Class ExportContext

• Class ExportExpr

• Class Expr

• Template Class ExpressionGroup

• Class ExprPtr

• Class ExprRange

• Template Class flattened_rangenest

• Template Class FullBinaryNode

• Template Class GenerationOptimizer

• Class GenerationOptimizer::AbstractOperation

• 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 IndexFactory

• Class IndexSpace

• Class IndexSpaceRegistry

• Class ItfContext

• Template Class ItfGenerator

• Template Class JuliaITensorGenerator

• Class JuliaITensorGeneratorContext

• Template Class JuliaTensorKitGenerator

• Class JuliaTensorKitGeneratorContext

• Template Class JuliaTensorOperationsGenerator

• Class JuliaTensorOperationsGeneratorContext

• Class Labeled

• Class MutatableLabeled

• Class NCProduct

• Template Class NormalOperator

• Template Class NormalOperatorSequence

• Class NullTensorCanonicalizer

• Class NumPyEinsumGenerator

• Class NumPyEinsumGeneratorContext

• Template Class Op

• Template Class Operator

• Class Product

• Template Class PythonEinsumGeneratorBase

• Class PythonEinsumGeneratorContext

• Class PyTorchEinsumGenerator

• Class PyTorchEinsumGeneratorContext

• Class QuantumNumbersAttr

• Class ReorderingContext

• Class Result

• Class ResultExpr

• Template Class ResultScalar

• Template Class ResultTensorBTAS

• Template Class ResultTensorOfTensorTA

• Template Class ResultTensorTA

• Template Class Singleton

• Class Sum

• Template Class SwapCountable

• Template Class SwapCountableRef

• Class Taggable

• Class Tensor

• Class TensorBlockCanonicalizer

• Class TensorCanonicalizer

• Class TensorNetworkV1

• Class TensorNetworkV1::Edge

• Class TensorNetworkV2

• Class TensorNetworkV2::Edge

• Class TensorNetworkV2::Vertex

• Class TensorNetworkV3

• Class TensorNetworkV3::Edge

• Class TensorNetworkV3::Vertex

• Template Class TextGenerator

• Template Class TimerPool

• Class TypeAttr

• Class UsageSet

• Class Variable

• Template Class VertexPainter

• Template Class VertexPainter< TensorNetworkV1 >

• Template Class VertexPainter< TensorNetworkV2 >

• Class VertexPainterImpl

• Template Class WickTheorem

• Class WickTheorem::Stats

Enums

• Enum Action

• Enum BraKetPos

• Enum BraKetSlotTypesetting

• Enum BraKetSymmetry

• Enum BraKetTypesetting

• Enum CanonicalizationMethod

• Enum ColumnSymmetry

• Enum ComputeSelection

• Enum DeclarationScope

• Enum EvalOp

• Enum IndexSlotType

• Enum IndexSpaceMetric

• Enum LoadStrategy

• Enum MemoryLayout

• Enum OrderType

• Enum PrunableScalars

• Enum ResultType

• Enum SlotType

• Enum SPBasis

• Enum Statistics

• Enum Symmetry

• Enum TensorIndexSlotType

• Enum Trace

• Enum TreeTraversal

• Enum Usage

• Enum Vacuum

• Enum VertexType

• Enum ZeroStrategy

Functions

• Function sequant::abort_msg

• Template Function sequant::abs

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

• Function sequant::adjoint(const ExprPtr&)

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

• Function sequant::adjoint(Action)

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

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

• 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::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(Constant const&)

• Function sequant::binarize(Variable const&)

• Function sequant::binarize(Tensor const&)

• Function sequant::binarize(Sum const&)

• Function sequant::binarize(Product const&)

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

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

• Function sequant::biorthogonal_transform(ResultExpr&, double)

• Function sequant::biorthogonal_transform(container::svector<ResultExpr>&, double)

• Function sequant::biorthogonal_transform(const ExprPtr&, const container::svector<container::svector<sequant::Index>>&, double)

• Function sequant::biorthogonal_transform_copy(const ResultExpr&, double)

• Function sequant::biorthogonal_transform_copy(const container::svector<ResultExpr>&, double)

• Function sequant::bra_net_rank

• Function sequant::bra_rank

• Function sequant::braket

• Function sequant::braket_symmetry

• Function sequant::braketaux

• Template Function sequant::bubble_sort

• Function sequant::cache_manager

• Function sequant::canonicalize(ExprPtr&, CanonicalizeOptions)

• Function sequant::canonicalize(ExprPtr&&, CanonicalizeOptions)

• Function sequant::canonicalize(ResultExpr&, CanonicalizeOptions)

• Function sequant::canonicalize(ResultExpr&&, CanonicalizeOptions)

• Function sequant::cbegin

• Function sequant::cend

• Template Function sequant::clone

• Template Function sequant::collect_tensor_factors

• Function sequant::color

• Function sequant::column_symmetry

• Function sequant::compute_biorth_coeffs

• Template Function sequant::conj

• Template Function sequant::count_cycles

• Template Function sequant::counted_swap

• Function sequant::create_expr_for

• Template Function sequant::csv_labels

• Function sequant::default_context_manipulation_threadsafe

• 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::DEFINE_STRONG_TYPE_FOR_RANGE_AND_RANGESIZE(cre)

• Function sequant::DEFINE_STRONG_TYPE_FOR_RANGE_AND_RANGESIZE(ann)

• Function sequant::denominator

• Function sequant::deparse(const ResultExpr&, bool)

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

• Function sequant::deparse(const Expr&, bool)

• Function sequant::deparse(const Product&, bool)

• Function sequant::deparse(const Sum&, bool)

• Function sequant::deparse(const Tensor&, bool)

• Function sequant::deparse(const AbstractTensor&, bool)

• Template Function sequant::deparse(const NormalOperator<S>&)

• Function sequant::deparse(const Variable&)

• Function sequant::deparse(const Constant&)

• Function sequant::deparse(const Index&)

• Function sequant::deparse< Statistics::BoseEinstein >

• Function sequant::deparse< Statistics::FermiDirac >

• Template Function sequant::diactrics_to_latex(const std::basic_string_view<Char, Traits>&)

• Template Function sequant::diactrics_to_latex(const std::basic_string<Char, Traits, Alloc>&)

• Function sequant::diff

• Template Function sequant::diff_indices

• Function sequant::diff_spaces

• Template Function sequant::do_parse

• Template Function sequant::eliminate_common_subexpressions

• Function sequant::end(const ExprPtr&)

• Function sequant::end(ExprPtr&)

• Template Function sequant::eval_result

• Template Function sequant::evaluate(Node const&, F const&, CacheManager&)

• Template Function sequant::evaluate(Node const&, auto const&, F const&, CacheManager&)

• Template Function sequant::evaluate(Nodes const&, auto const&, F const&, CacheManager&)

• Template Function sequant::evaluate(Nodes const&, F const&, CacheManager&)

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

• Template Function sequant::evaluate_antisymm

• Template Function sequant::evaluate_biorthogonal_nns_project

• Template Function sequant::evaluate_symm

• Template Function sequant::ex

• Function sequant::expand(ResultExpr&)

• Function sequant::expand(ExprPtr&&)

• Function sequant::expand(ExprPtr&)

• Function sequant::expand(ResultExpr&&)

• Template Function sequant::export_expression

• Template Function sequant::export_group

• Template Function sequant::export_groups

• 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

• 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

• Function sequant::get_complete_space

• Function sequant::get_default_context

• Function sequant::get_hole_space

• Template Function sequant::get_ket_idx

• 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 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::greek_characters_to_latex(const std::basic_string_view<Char, Traits>&)

• Template Function sequant::greek_characters_to_latex(const std::basic_string<Char, Traits, Alloc>&)

• Function sequant::has_tensor

• Function sequant::hash_value(const IndexSpace&)

• Function sequant::hash_value(const ExprPtr&)

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

• Function sequant::hash_value(const Index&)

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

• Function sequant::hash_version

• 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&)

• Template Function sequant::inits

• Template Function sequant::is_annihilator

• Function sequant::is_cnumber

• Template Function sequant::is_creator

• 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_valid(const ExprPtr&, std::string *)

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

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

• Function sequant::ket_net_rank

• Function sequant::ket_rank

• Function sequant::kronecker_label

• Function sequant::label

• Template Function sequant::linearize_eval_node

• Function sequant::log_ta_tensor_host_memory_use

• Template Function sequant::make_indices

• Function sequant::make_kronecker

• Function sequant::make_overlap

• Function sequant::max_cache

• Template Function sequant::max_space_size_idx

• Function sequant::min_storage

• Template Function sequant::next_permutation_parity

• Function sequant::non_canon_simplify(ExprPtr&)

• Function sequant::non_canon_simplify(ResultExpr&)

• Function sequant::non_canon_simplify(ResultExpr&&)

• Template Function sequant::norm_squared

• Template Function sequant::normalize

• Function sequant::num_indices

• Function sequant::num_slots

• Function sequant::num_threads

• Function sequant::numerator

• Function sequant::operator!

• 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 Complex<T>&, const T&)

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

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

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

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

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

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

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

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

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

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

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

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

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

• Function sequant::operator&=

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

• Template Function sequant::operator*(const U&, const Complex<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>&)

• 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>&)

• 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 U&, const Complex<T>&)

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

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

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

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

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

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

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

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

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

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

• Function sequant::operator<=

• Function sequant::operator<=>

• 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 Complex<T>&, const T&)

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

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

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

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

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

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

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

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

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

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

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

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

• Function sequant::operator>

• Function sequant::operator>=

• Function sequant::operator^

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

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

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

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

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

• Function sequant::operator|=

• Function sequant::operator~

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

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

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

• Function sequant::ordinal_compare

• Function sequant::overlap_label

• Template Function sequant::parallel_do

• Function sequant::parse_expr(std::wstring_view, std::optional<Symmetry>, std::optional<BraKetSymmetry>, std::optional<ColumnSymmetry>)

• Function sequant::parse_expr(std::string_view, std::optional<Symmetry>, std::optional<BraKetSymmetry>, std::optional<ColumnSymmetry>)

• Function sequant::parse_result_expr(std::wstring_view, std::optional<Symmetry>, std::optional<BraKetSymmetry>, std::optional<ColumnSymmetry>)

• Function sequant::parse_result_expr(std::string_view, std::optional<Symmetry>, std::optional<BraKetSymmetry>, std::optional<ColumnSymmetry>)

• Function sequant::peak_cache

• Template Function sequant::permutation_parity

• Function sequant::permutational_overlap_matrix

• Template Function sequant::permute

• Function sequant::permute_bra

• Function sequant::permute_braket

• Function sequant::permute_ket

• Function sequant::pop_tensor

• Function sequant::pow2

• Template Function sequant::printf

• Function sequant::profile

• Template Function sequant::qpannihilator_space

• Template Function sequant::qpcreator_space

• Function sequant::rank_transformation_perms

• Function sequant::rapid_simplify(ExprPtr&, SimplifyOptions)

• Function sequant::rapid_simplify(ResultExpr&, SimplifyOptions)

• Function sequant::rapid_simplify(ResultExpr&&, SimplifyOptions)

• Template Function sequant::relevant_space

• Function sequant::remove_tensor

• 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

• Template Function sequant::reset_ts_swap_counter

• Template Function sequant::retrieve

• 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::simplify(ExprPtr&, SimplifyOptions)

• Function sequant::simplify(ExprPtr&&, SimplifyOptions)

• Function sequant::simplify(ResultExpr&, SimplifyOptions)

• Function sequant::simplify(ResultExpr&&, SimplifyOptions)

• Function sequant::size(const Expr&)

• Function sequant::size(const ExprPtr&)

• Function sequant::slots

• Function sequant::sort_pairings

• Template Function sequant::sort_then_replace_by_ordinals

• Template Function sequant::sort_via_ordinals

• Template Function sequant::subsequence

• Function sequant::subset_indices

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

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

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

• Function sequant::symmetry

• Function sequant::tensors_commute

• Template Function sequant::to_basic_string_view

• Template Function sequant::to_bitset

• Function sequant::to_default_symms

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

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

• Function sequant::to_expr

• Function sequant::to_label_annotation

• Function sequant::to_latex()

• Template Function sequant::to_latex(const NormalOperator<S>&)

• Template Function sequant::to_latex(const NormalOperatorSequence<S>&)

• Function sequant::to_latex(const ExprPtr&)

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

• Function sequant::to_latex(const rational&)

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

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

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

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

• Template Function sequant::to_latex(const std::complex<T>&)

• 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>&)

• Template Function sequant::to_string(S&&)

• Function sequant::to_string(std::string&&)

• 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 Complex<T>&)

• Function sequant::to_string(Vacuum)

• Function sequant::to_wolfram(const ExprPtr&)

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

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

• Template Function sequant::to_wolfram(const std::complex<T>&)

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

• Function sequant::to_wolfram(const rational&)

• Function sequant::to_wolfram(const Symmetry&)

• Function sequant::to_wolfram(BraKetPos)

• Function sequant::to_wolfram(Action)

• 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)

• Template Function sequant::to_wstring(S&&)

• Function sequant::to_wstring(std::wstring&&)

• Function sequant::to_wstring(Symmetry)

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

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

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

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

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

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

• Template Function sequant::tot_indices

• Function sequant::toUtf16

• Function sequant::toUtf8

• Function sequant::transform_expr

• Function sequant::transform_indices

• Template Function sequant::transform_node

• Template Function sequant::transform_reduce

• Template Function sequant::transform_sum_expr

• Template Function sequant::ts_swap_counter_is_even

• Template Function sequant::utf_to_latex(const std::basic_string_view<Char, Traits>&)

• Template Function sequant::utf_to_latex(const std::basic_string<Char, Traits, Alloc>&)

• 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::CProductPtr

• Typedef sequant::EvalExprNode

• Typedef sequant::EvalNode

• Typedef sequant::EvalSequence

• Typedef sequant::ExportNode

• Typedef sequant::expr_range

• 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::IndexList

• Typedef sequant::IndexPair

• Typedef sequant::intmax_t

• Typedef sequant::NCProductPtr

• Typedef sequant::ParticlePairings

• Typedef sequant::ProductPtr

• Typedef sequant::ProtoBundle

• Typedef sequant::PythonEinsumGenerator

• Typedef sequant::ratio

• Typedef sequant::rational

• Typedef sequant::ResultPtr

• Typedef sequant::suitable_call_operator

• Typedef sequant::SumPtr

• Typedef sequant::TensorBlockEqualComparator

• Typedef sequant::TensorBlockLessThanComparator

• Typedef sequant::TensorNetwork

• Typedef sequant::TensorPtr

• Typedef sequant::VariablePtr

• Typedef sequant::WstrList

Variables

• Variable sequant::adjoint_label

• 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_product_v

• Variable sequant::is_a_sum_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_product_v

• Variable sequant::space_tags::is_reference_occupied

• Variable sequant::is_sum_v

• Variable sequant::is_tensor_v

• Variable sequant::is_tuple_like_v

• Variable sequant::space_tags::is_vacuum_occupied

• Variable sequant::is_variable_v