| ►Nstd | STL namespace |
| Chash< syten::HalfInteger< Base > > | Specialisation for HalfInteger<> |
| Chash< syten::Rep > | Specialisation for Rep |
| Chash< syten::Sector > | Specialisation for Sector |
| ►Nsyten | Syten namespace |
| ►NArrayImpl | Implementation namespace for our Array |
| CArray | A thin wrapper around std::array with some extra bells and whistles |
| ►NBinaryTree | Binary tree implementation |
| CNode | A node in a binary tree, containing a value of type T and possibly leaves |
| CTree | The binary tree structure, versioned via boost_version_Tree |
| NCaching | Only contains the Caching::threshold variable |
| ►NCuda | Support functions (memory allocation etc.) for CUDA-based GPUs |
| CCudaAllocator | Cuda allocator class, uses the buddy system |
| CCudaConstSpan | CudaConstSpan is a non-owning constant reference to a continuous array of objects in CUDA storage |
| CCudaDynArray | The CUDA-equivalent of DynArray |
| CCudaMutSpan | CudaMutSpan is a non-owning reference to a continuous array of objects in CUDA storage which can be mutated through the span |
| CCudaPtr | Implementation for syten::CudaPtr |
| CCudaStream | Implementation for syten::CudaStream |
| CHandle | Represents a cublasHandle_t object which may or may not be in use |
| CHandleBox | RAII wrapper around a handle, putting it out of use on destruction |
| ►NCudaDenseTensorImpl | Implementation namespace for CUDA dense tensors |
| CCudaDenseTensor | A dense tensor using CUDA for storage and computing if SYTEN_USE_CUDA is defined |
| NDelinearise | Delinearisation decomposition |
| ►NDenseEigensolver | Implementation of dense eigensolvers |
| CDenseEigensolver | Dense nonsymmetric eigensolver, nonfunctional template base |
| CDenseEigensolver< double > | Dense nonsymmetric eigensolver, specialisation for doubles |
| CDenseEigensolver< float > | Dense nonsymmetric eigensolver, specialisation for floats |
| CDenseEigensolver< std::complex< double > > | Dense nonsymmetric eigensolver, specialisation for complex doubles |
| CDenseEigensolver< std::complex< float > > | Dense nonsymmetric eigensolver, specialisation for complex floats |
| CDenseEigensolverBase | Dense nonsymmetric eigensolver, nonfunctional templated inheritance base |
| CDenseSymEigensolver | Dense symmetric eigensolver, nonfunctional template base |
| CDenseSymEigensolver< double > | Dense symmetric eigensolver, specialisation for doubles |
| CDenseSymEigensolver< float > | Dense symmetric eigensolver, specialisation for floats |
| CDenseSymEigensolver< std::complex< double > > | Dense symmetric eigensolver, specialisation for complex doubles |
| CDenseSymEigensolver< std::complex< float > > | Dense symmetric eigensolver, specialisation for complex floats |
| CDenseSymEigensolverBase | Dense symmetric eigensolver, nonfunctional templated inheritance base |
| NDenseImpl | Namespace for helper functions for dense tensors |
| ►NDenseProduct | Contains helper functions related to the product of two dense tensors, see syten::prodD() for the main entry point |
| CTemporaryTransposeStorage | Temporary transpose storage class, used during tensor-tensor products |
| NDeparallelise | Deparallelisers |
| ►NDMRG | General DMRG-related classes for both MPS and BTT |
| CDMRGConfig | Configuration for an entire DMRG run |
| CDMRGStage | Configuration for a single DMRG stage |
| CGSEConf | Configuration for subspace expansion |
| NEigen | Eigendecomposition |
| NEnvVars | Namespace for generic static variables initialised from environment variables |
| ►NEternalMalloc | Implementation namespace for le_malloc() and le_free() |
| CMtxWrapper | To serve and protect |
| CRegion | Struct representing one region of the eternal malloc pool |
| CRegionsInitialiser | Https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Nifty_Counter has a detailed explanation |
| ►NExcp | Namespace for exceptions otherwise polluting the global syten:: namespace |
| CInsufficientMaxDeg | Exception thrown if the compile-time value of SYTEN_MAX_DEG is insufficient |
| CInsufficientMaxSym | Exception thrown if the compile-time value of SYTEN_MAX_SYM is insufficient |
| CNoSuchFile | Thrown if a file to be opened does not exist |
| COutdatedFile | Thrown if a file with a version different from the version of the toolkit is read |
| CReadParseError | Thrown if an error occurs during the parsing with write() |
| CUnexpectedFile | Throw this exception if the UUID of a file does not match your expectations |
| CUnnormalisableZero | |
| ►NGenerators | Generators namespace |
| NBosonic | Specialised generators for bosonic systems |
| NSOn | Most general (real) unitary generators |
| ►NGenericDenseTensorImpl | Implementation for the generic dense tensor |
| CGenericDenseTensor | Implementation for syten::GenericDenseTensor |
| NGradientOpt | Namespace for gradient-based optimisers |
| ►NIdentityDenseTensorImpl | Implementation for identity dense tensors |
| CIdentityDenseTensor | Implementation for syten::IdentityDenseTensor |
| ►NIPEPS | IPEPS-related functionality and tools |
| ►NLat | Lattice generators for iPEPS lattices |
| NNil | Generators with no symmetries |
| NSU2 | Generators with a single SU(2) symmetry |
| NSU2U1 | Generators with one SU(2) and one U(1) symmetry |
| NU1 | Generators with a single U(1) symmetry |
| NU1U1 | Generators with two U(1) symmetries |
| NZ2 | Generators with a single Z_2 symmetry |
| CAOneOp | A one-site operator acting on a single defined site |
| CATwoOp | Two-site gate acting on two defined sites |
| CFullCTM | Represents the full CTM surrounding the entire unit cell |
| CHorz2CTM | A horizontal two-site environment consisting of six tensors surrounding those on two neighbouring sites |
| CLattice | An IPEPS lattice |
| COneOp | A local operator acting on an undefined site |
| CProdOp | Represents a product of two-site gates acting on different sites, e.g |
| ►CState | Represents an IPEPS state on a square lattice |
| CDLEntry | An element of the double layer, containing one splitting and one fusing tensor |
| CSumOp | Represents a sum of two-site gates acting on different sites, e.g |
| CVert2CTM | A vertical two-site environment consisting of six tensors surrounding those on two neighbouring sites |
| ►NIPEPSv2 | Namespace for the second-generation iPEPS code (iPEPSv2) |
| CA12Op | IPEPSv2 operator representing a linear combination of an applied one-site operator and an applied two-site operator |
| CAOneOp | IPEPSv2 single-site operator on a specific site |
| CATwoOp | IPEPSv2 two-site operator on two specific sites |
| ►CCornerTransferMatrix | IPEPSv2 corner transfer matrix representation |
| CGrowthResult | Helper struct representing the result of a growth step |
| CFullUpdateReturn | Helper struct containing the return value of a (fast) full update step |
| CLattice | IPEPSv2 lattice, storing one-site operators as well as sum and product operators and generating applied operators on-the-fly |
| COneOp | IPEPSv2 single-site operator not applied to any specific site |
| CProdOp | IPEPSv2 operator representing a product of one- and two-site operators |
| CState | IPEPSv2 State structure |
| CSumOp | IPEPSv2 operator representing a sum of one- and two-site operators |
| CUpdateStage | Configuration for an iPEPSv2 update stage |
| Nk_to_y | Functions which, when given a momentum on the ring k, give the coordinate y at which we want to place this momentum |
| ►NKrylov | Krylov subspace methods |
| ►NClassicImpl | Contains the classic Krylov implementation and helper functions |
| CClassic | The ClassicKrylov struct encapsulates the Lanczos algorithm. Template Parameters are: |
| CEigenSolver | The EigenSolver struct solves matrices for their eigenvalues and eigenvectors |
| CExponentialSolver | The ExponentialSolver struct solves exp(prefactor*mat)*vec |
| CKrylovError | Thrown on serious errors encountered in Krylov which do not allow returning an even approximate result |
| CNoOrthoMat | The NoOrthoMat struct the default behaviour of Lanczos: do not orthonormalize at all |
| ►COrthoMat | The OrthoMat struct implements an orthonormalization that is not 'in place' of the krylov vectors, but affects the Hamiltonian matrix <f|H|f> and thus optimizes for the number of additions see arxiv:1203.2523v3 |
| CInnerProductHelper | The InnerProductHelper struct provides access to the orthonormalized vectors (in a sense) |
| CReorthoMat | The ReorthoMat struct provides orthonormalization in case the overlaps grow over SYTEN_SMALL_THRESHOLD |
| CStandardMat | The StandardMat struct provides orthogonalisation via the standard orthogonalise() functionality specialisable for each class |
| ►NEvolution | Implementation of time evolution with recycling etc. using Krylov subspaces |
| CAlwaysHeuristic | Heuristic which always recycles |
| CConcaveHeuristic | Concavity assumption: Number of vectors needed for the next step is at most as large as the number of vectors needed for the previous step |
| CConf | The Conf struct stores info on how to evolve the state |
| CEvolver | Base class from which different heuristics inherit |
| CExtrapolatingHeuristic | The ExtrapolatingHeuristic class tries to extrapolate the number of timesteps that can be taken with one more Krylov vector and the runtime for adding this vector, and compares both to building a new Krylov space from scratch |
| ►CGreedyHeuristic | Heuristic which takes into account the time to build a new Krylov vector compared to the time to build an entire new subspace |
| CElement | Element of the computational history |
| CNearlyAlwaysRecycleHeuristic | Recycles unless we reached the maximal Krylov subspace |
| ►NOrthoPolicies | Orthonormalisation policies used by StandardKrylov and TensorNetworksKrylov |
| CAllButLast | Orthogonalises only against the first N-2 vectors of the set of size N, i.e |
| CArithmetic | Arithmetic orthonormalisation |
| CCombined | Uses two different implementations to first orthonormalise against the last two vectors of the orthogonalisation set and then against all vectors of that set |
| CComplete | Completely orthogonalises the space using the specified OrthoImpl class method |
| CLastTwo | Orthogonalises only against the last two vectors of the orthogonalisation set |
| CNone | Does nothing when called to orthonormalise or orthogonalise() |
| CTwoSiteVariational | Two-site variational orthonormalisation |
| CVariational | Variational orthonormalisation |
| ►NSolverPolicies | Solver policies to be used by StandardKrylov and TensorNetworksKrylov |
| CEigen | Policy class to solve a Krylov subspace problem to get the lowest-eigenvalue eigenvector |
| CExponential | Policy class to solve the Krylov problem and calculate \(
\mathrm{exp}(t H) |\psi\rangle \) given a Krylov space, a timestep t and if necessary an initial norm |
| CExponentialFineOverlap | Exponential solver which also calculates a fine grid of overlaps for every time step taken |
| CStandardImmediateSolve | Tag struct to signal to the Standard solver SolverPolicy sp_result() function that it will only be called once |
| ►NTensorNetworksImpl | Implementation helpers for Krylov::TensorNetworks class |
| CApplyThenOrtho | Application policy which first applies the operator to the state using its operator() and then does orthogonalisation using the supplied orthonormalisation policy |
| CHEffDenseExpectation | Policy class which takes the full matrix and the set of Krylov vectors and calculates the dense effective projected matrix |
| CHEffTridiagExpectation | Policy class which takes the full matrix and the set of Krylov vectors and calculates the tridiagonal effective projected matrix |
| CVarApplyOrtho | Application policy which uses apply_op_orthogonalise_fit() to apply the operator and orthogonalise immediately |
| CKrylovEvolver | Helper class to model a Krylov time evolution |
| CNaiveExponential | The plain exponential via application of the operator to the vector |
| COperatorWrapper | The OperatorWrapper class wraps a MPS/BTT operator, providing an interface complying to the exponentialLanczos template |
| CStandard | The "Standard" Krylov method using the same solver and orthonormalisation policies as TensorNetworksKrylov but with the original Lanczos order |
| CStateWrapper | The StateWrapper class wraps a MPS/BTT-state to provide an interface complying to exponentialLanczos template |
| CTensorNetworks | Krylov implementation optimised for tensor network applications where calculating \( x^T \cdot A \cdot y \) does not require a matrix-vector application |
| NLog | Global variables for the logging subsystem |
| ►NLZ4 | Namespace for implementation of LZ4 Boost iostream filter |
| CComp_SymFilter | Compressing symmetric filter, used by boost::iostreams::symmetric_filter<> |
| CCompressionFailure | Exception thrown if compression failed for some reason |
| ►CCompressor | Boost iostream filter which compresses with the LZ4 algorithm |
| Ccategory | |
| CDecomp_SymFilter | Decompressing symmetric filter, used by boost::iostreams::symmetric_filter<> |
| CDecompressionFailure | Exception thrown if decompression failed for some reason |
| ►CDecompressor | Boost iostream filter which compresses with the LZ4 algorithm |
| Ccategory | |
| CInvalidRange | Exception thrown if the range supplied by boost for input/output buffers is invalid |
| CNotLZ4Stream | Exception thrown if the magic number of a compressed block does not match LZ4::magic |
| ►NMemoryUsage | Memory usage reporting with allocSize(), totalSize() and stackSize() |
| CAllocSize | AllocSize default implementation: Returns zero always |
| CAllocSize< std::array< T, num >, MemorySize > | AllocSize() specialisation for std::array |
| CAllocSize< std::map< Key, Value >, MemorySize > | AllocSize() specialisation for std::map |
| CAllocSize< std::pair< T, U >, MemorySize > | AllocSize() specialisation for std::pair |
| CAllocSize< std::string, MemorySize > | AllocSize() specialisation for std::string |
| CAllocSize< std::unordered_map< Key, Value >, MemorySize > | AllocSize() specialisation for std::map |
| CAllocSize< std::variant< Types... >, MemorySize > | AllocSize() specialisation for std::variant |
| CAllocSize< std::vector< T >, MemorySize > | AllocSize() specialisation for std::vector |
| CAllocSize< T, decltype(std::declval< T >().allocSize())> | AllocSize specialisation if the member function T::allocSize() exists |
| CMemorySize | A certain number of bytes, a simple wrapper around std::size_t |
| CStackSize | StackSize default implementation: Returns sizeof(T) |
| CStackSize< T, decltype(std::declval< T >().stackSize())> | StackSize specialisation if the member function T::stackSize() exists |
| CTotalSize | TotalSize default implementation: Returns stackSize(obj) + allocSize(obj) |
| CTotalSize< T, decltype(std::declval< T >().totalSize())> | TotalSize specialisation if the member function T::totalSize() exists |
| Nmpi | MPI related namespace |
| ►NMPS | The namespace containing all MPS-related tools, classes and objects |
| ►NBasisTransformation | Namespace for all basis transformation related things |
| CModeTransformation | The object that handles the transformation |
| ►NDMRG | MP-DMRG specific data structures and classes |
| CLBOPDMRG | One run of a MP-DMRG algorithm, parallelised if requested |
| CLBOWorker | One worker in a MP-DMRG calculation |
| CPDMRG | One run of a MP-DMRG algorithm, parallelised if requested |
| CWorker | One worker in a MP-DMRG calculation |
| ►NLat | Contains all lattice generators |
| ►NGCE | Contains finite-temperature grand canonical ensemble lattices |
| NU1 | Contains all finite-temperature grand canonical ensemble lattice with a single \( U(1) \) symmetry |
| NU1U1 | Two individual spin symmetries |
| NNil | Contains all generators of lattices with no symmetries |
| NSU2 | Contains all generators of lattices with a single \( SU(2) \) symmetry |
| NSU2Fermion | Contains all generators of lattices with \( \textrm{SU(2)} \) symmetries for Fermions |
| NSU2U1 | Contains all generators of lattices with \( \textrm{SU(2)} \times \textrm{U(1)} \) symmetries |
| NSU2U1Z | Contains all generators of lattices with \( \mathrm{SU}(2)
\times \mathrm{U}(1) \times \mathrm{\mathbb{Z}}_k \) symmetries |
| NSU3 | Contains all generators of lattices with a single \( SU(3) \) symmetry |
| NU1 | Contains all generators of lattices with a single \( U(1) \) symmetry |
| NU1U1 | Contains all generators of lattices with \( U(1) \times U(1) \) symmetries |
| NU1U1U1 | Three \( U(1) \) symmetries |
| NU1U1U1U1 | Four \( U(1) \) symmetries |
| NU1U1Z | Contains all generators of lattices with \( \mathrm{U}(1)
\times \mathrm{U}(1) \times \mathrm{\mathbb{Z}}_k \) symmetries |
| ►NOperatorApplicators | OperatorApplicator structs for TDVP and DMRG |
| CBond | Contraction scheme of bond for TDVP |
| CLMWR | Optimal contraction sequence for d != 1 |
| CLMWWR | Sequential multiplication of the MPO tensors |
| CLWMR | Pre-computes the (LW) contraction and then only multiplies in M and R on each Lanczos step |
| ►NParseOperator | Support classes and functions related to matrix product operator parsing |
| CInvalidExpression | Thrown when an invalid expression is encountered during MPS::Operator parsing |
| CNotDefinition | Thrown when parse() gets a string that is not an operator definition of the form A:O |
| CStackElement | One element of the parsing stack |
| NRandomState | Generators for random states |
| ►NRDMs | A namespace containing reduced density matrices |
| COneParticleRDM | The helper class for the construction of the one particle reduced density matrix |
| COrbRDM | The helper class for construction of the one orbital reduced density matrix |
| CRDM | An abstract RDM, all RDMs inherit from here |
| CTwoParticleRDM | The helper class for th construction of the two particle reduced density matrix |
| ►NSnapshots | A namespace containing methods for taking snapshot |
| ►CWorkspace | Workspace object for taking snapshots from matrix-product State |
| CSSM | Structure representing single-site measurement subspace-projector and eigenvalue as well as probability to measure outcome |
| ►NSymConv | Namespace containing all symmetry related casts |
| ►NSU2 | The original state has SU(2) symmetry |
| CConverter_SU2U1 | Converter class |
| ►NTDVP | TDVP Implementation |
| CLBOWorker | Worker for LBO-TDVP |
| CPTDVP | Parallel TDVP run, containing TDVP workers executing the actual calculations |
| CWorker | TDVP worker |
| ►NTEBD | TEBD implementation, primarily by Felix |
| CConf | Programm configuration |
| CMergeConfig | Config for merging two bases |
| CNode | Node that is responsible for one sublattice or single bond (which is a sublattice with length 1) |
| CTpoWrapper | TEBD parallel operator wrapper |
| CTpsWrapper | TEBD parallel state wrapper |
| ►CLattice | Stores a physical lattice and associated operators and bases |
| CSSO | The representation of a single-site operator |
| CUndefinedOperator | Thrown when an undefined operator is requested via MPS::Operator::get() |
| ►CLBOState | Matrix-product state with local basis optimisation (see Florian Dorfner's thesis) |
| CLocal | Flagged enum denoting which of the current site tensors is of relevance |
| COperator | Matrix Product Operator |
| CQcLatticeGenerator | |
| CSState | The "smart" MPS needs to store both the local bases and the bond bases |
| CState | Matrix Product State with automatic caching |
| ►NOffsetDenseTensorImpl | Implementation for offset dense tensors |
| COffsetDenseTensor | Implementation for syten::OffsetDenseTensor |
| NPyten | Contains the initialisation functions for Python bindings |
| ►NQR | QR Decompositions |
| CDenseQR | Dense QR decomposition, nonfunctional template base |
| CDenseQR< double > | Dense QR decomposition, specialisation for doubles |
| CDenseQR< float > | Dense QR decomposition, specialisation for floats |
| CDenseQR< std::complex< double > > | Dense QR decomposition, specialisation for complex doubles |
| CDenseQR< std::complex< float > > | Dense QR decomposition, specialisation for complex floats |
| CDenseQRBase | Dense QR decomposition, nonfunctional templated inheritance base |
| NRandom | The random number generation engine generation subsystem |
| ►NRepRegister | All representation-related registers |
| ►NDecomp | All decomposition-related functions and registers |
| CRepRepOrdinal | Struct used as key in decomposition cache |
| NSignals | Signal catching support |
| ►NSpanImpl | Implementation namespace for MutSpan and ConstSpan |
| CConstSpan | ConstSpan is a non-owning constant reference to a continuous array of objects |
| CMutSpan | MutSpan is a non-owning reference to a continuous array of objects which can be mutated through the span |
| ►NSQL | Contains functions dealing with square lattices |
| ►NHelpers | Contains helper functions for square lattices |
| CInvalidCoordinate | Thrown if an invalid coordinate is passed into a mapping function |
| NLat | Contains lattice generators for square lattices |
| ►NSTensorImpl | Contains all ‘smart’ tensor related classes and functions |
| ►NAutodiff | Contains classes and functions to deal with autodifferentiation of STensor objects |
| CComputeNode | Describes an individual function call as part of a computation |
| CSBasis | A smart basis class |
| CSBasisId | Identifier for a unique basis including its prime level |
| ►CSTensor | Implementation for syten::STensor |
| CAutodiffRenewReturn | Simple helper struct returned by STensor::get_and_renew_autodiff() and STensorProxy::get_and_renew_autodiff() |
| CSTensorProxy | The STensorProxy class is essentially a constant reference to another, pre-existing tensor |
| ►NSVD | Singular Value Decomposition |
| CDenseSVD | Dense singular value decomposition, nonfunctional template base |
| CDenseSVD< double > | Dense singular value decomposition, specialisation for doubles |
| CDenseSVD< float > | Dense singular value decomposition, specialisation for doubles |
| CDenseSVD< std::complex< double > > | Dense singular value decomposition, specialisation for complex doubles |
| CDenseSVD< std::complex< float > > | Dense singular value decomposition, specialisation for doubles |
| CDenseSVDBase | Dense singular value decomposition, nonfunctional templated inheritance base |
| CPick_U_SV | |
| CPick_US_V_ | |
| ►NT3N | Namespace for T3N |
| ►NDMRG | DMRG specific data structures and classes |
| CContractions | Data type used to store contractions of the Hamiltonian with the state |
| CPosition | Since these usually belong together |
| CRun | One run of T3N-DMRG |
| ►NLat | Contains all lattice generators |
| NSU2 | Contains all generators of lattices with a single \( SU(2) \) symmetry |
| ►NSU2U1 | All SU(2) x U(1) lattice generators |
| CFermiHubbardReps | Helper struct containing all Fermi Hubbard information |
| NSU2U1Z | Contains all generators of lattices with \( \mathrm{SU}(2)
\times \mathrm{U}(1) \times \mathrm{\mathbb{Z}}_k \) symmetries |
| NU1 | Contains all generators w/ a \( U(1) \) symmetry |
| NU1U1U1 | Three \( U(1) \) symmetries |
| NU1U1Z | Contains all generators of lattices with \( \mathrm{U}(1)
\times \mathrm{U}(1) \times \mathrm{\mathbb{Z}}_k \) symmetries |
| NRandomState | Generators for random states |
| ►NRDMs | A namespace containing reduced density matrices |
| COneParticleRDM | The helper class for the construction of the one particle reduced density matrix |
| COrbRDM | The helper class for construction of the one orbital reduced density matrix |
| CRDM | An abstract RDM, all RDMs inherit from here |
| ►NTDVP | T3N TDVP Implementation |
| CWorker | TDVP worker |
| CLattice | T3N lattice |
| CMutualInformation | |
| COperator | A T3N operator |
| CQcLatticeGenerator | |
| CState | |
| CT3NTensor | Wrapper class for STensor & SBasis |
| ►CVarationalTrunc | Helper to variationally truncate a T3NS |
| CPosition | Positions of different objects |
| NTensorBlocks | Functions to sort the blocks of a tensor according to various criteria |
| NTensorProd | Implementation helpers for tensor products |
| NTest | Helper functions for executables in test/ |
| NThreading | Threading-control variables and functions |
| CAsyncCached | An asynchronous caching data wrapper |
| CBasis | Basis on a specific tensor leg, essentially a list of symmetry sectors and associated reduced tensor sizes |
| CBasisMap | A data type similar to Basis which is suitable to quickly check the existence of sectors |
| CBitset | Bitset class directly convertible to boolean |
| CCached | Caching/cached type |
| CConvertingIterator | The ConvertingIterator is an iterator wrapper that converts its pointee to the desired type |
| CCtorTester | A test object to check that no unnecessary copy operations have taken place |
| CDenseIter | Iterator over a single dense tensor-like object |
| CDenseIterDual | Iterator over a dense tensor-like object with a secondary index running |
| CDenseIterRestricted | Restricted iterator |
| CDenseTensor | Dense tensor class |
| CDynArray | "Light" version of std::vector that supports malloc() allocation |
| CEternalAllocator | STL-compatible allocator using le_malloc() |
| CFmt | Used by the logging infrastructure to indicate that the first argument is a format string and a newline should be added automatically |
| CFmtNN | Used by the logging infrastructure to indicate that the first argument is a format string and no newline should be added automatically |
| CHalfInteger | Half-Integers |
| CHighPrec | High-precision data type to be used for Clebsch-Gordan coefficients etc |
| CHistory | A set of history records |
| CHistoryElement | A single history record |
| CIdentityType | Identity type template to hinder type deduction |
| CInsertBase | Helper class |
| CInsertColumns | Helper class, basically empty, useful if one wants to also implement InsertRows |
| CInsertColumns< double > | Specialisation |
| CInsertColumns< float > | Specialisation |
| CInsertColumns< std::complex< double > > | Specialisation |
| CInsertColumns< std::complex< float > > | Specialisation |
| Cis_number | Is_number<T>::value is true if T is a scalar type |
| Cis_number< HalfInteger< Base > > | |
| Cis_number< HighPrec > | Explicit instantiation that a HighPrec is a numeric type |
| CIterativeConfig | Configuration for an iterative eigensolver or exponential algorithm |
| CIterativeExit | Exit description for an iterative algorithm |
| CLapackException | Thrown if a LAPACKE function returns non-zero |
| CLimVec | ‘Limited’ vector, wrapper around std::array<> which keeps track of its current size |
| Cload | Helper class to load an object from a file, uses a struct to imitate return-value-based function overloading |
| CloadCache | Shortcut to load("file",true), delete supplied input file |
| CloadCheckpoint | Loads file and deletes it from disk afterwards |
| CloadInput | Shortcut to load("file",false), don't delete input file |
| CMaximum | Type implicitly convertible to the maximum of all types for which a specialisation of std::numeric_limits has been defined |
| CMemorySampler | Stores memory sampling info, exists once as a static global object |
| CNoNew | Used by the logging infrastructure to indicate that no newline should be printed after the output from the stream |
| CNoPrefix | Used by the logging infrastructure to indicate that no prefix should be printed in front of the line |
| CNOut | The NOut struct is an ostream that does not output anything |
| CPair | A proxy class for std::pair, intended to behave exactly the same but with ADL-supported operator overloading |
| CRep | Single irrep of a (physical) symmetry group |
| Crequires_inmemory_rump_during_cache | Specialise this class template for any types which require special treatment during caching |
| Crequires_inmemory_rump_during_cache< STensorImpl::STensor > | |
| CScalarBase | ScalarBase<>::type is the base type of a complex type and the type itself if the type is a real scalar |
| CSourceLocation | Dummy struct to stand in until the compiler supports the proper source location |
| CSparseCoordComparator | Comparator for the flatmap used by the Sparse tensor to compare elements |
| ►CSparseTensor | Sparse tensor of specified rank and scalar type |
| CFullData | Struct holding the data for a full, non-singleton sparse tensors |
| CTensor | A single tensor, composed of a set of symmetry-protected blocks |
| ►CTensor< 0 > | Dummy specialisation for zero-rank tensors |
| CUndefined | Exception to be thrown if this class is used improperly in place of a normal-rank tensor |
| CTensorBlock | Represents one symmetry-protected block of a full tensor |
| CTensorInfoStorageSum | Data structure holding summarised storage information for a single tensor |
| CTimeOnlyString | Shift a default-constructed object of this type into a stream to call shiftTime(,true) on the stream, resulting in output HH:MM:SS |
| CTimer | A simple timing class, shift into an ostream for results |
| CTimeString | Shift a default-constructed object of this type into a stream to call shiftTime() on the stream, resulting in output yyyy.mm.ddTHH:MM:SS.uuu <CPU Time> |
| CTruncation | Truncation specification |
| CVec | A thin wrapper around std::vector with some extra bells and whistles (and without others) |
| CVerbose | A proxy class to increase verbosity in the output |
| CYesNo | A base template for all sorts of typefull boolean flags, to be used more in the future |
1.9.4