Here is a list of all namespaces with brief descriptions:

[detail level 1234]

Nam
►NCLI
►Ndetail
CAppFriend	This class is simply to allow tests access to App's protected functions
Celement_type	Not a pointer
Celement_type< T, typename std::enable_if< is_copyable_ptr< T >::value >::type >
Celement_value_type
CExistingDirectoryValidator	Check for an existing directory (returns error message if check fails)
CExistingFileValidator	Check for an existing file (returns error message if check fails)
CExistingPathValidator	Check for an existing path
Chas_find
CIPV4Validator	Validate the given string is a legal ipv4 address
Cis_complex	Check for complex
Cis_direct_constructible
Cis_istreamable	Check for input streamability
Cis_mutable_container
Cis_mutable_container< T, conditional_t< false, void_t< typename T::value_type, decltype(std::declval< T >().end()), decltype(std::declval< T >().clear()), decltype(std::declval< T >().insert(std::declval< decltype(std::declval< T >().end())>(), std::declval< const typename T::value_type & >()))>, void > >
Cis_ostreamable
Cis_readable_container
Cis_readable_container< T, conditional_t< false, void_t< decltype(std::declval< T >().end()), decltype(std::declval< T >().begin())>, void > >
Cis_tuple_like
Cis_wrapper
Cis_wrapper< T, conditional_t< false, void_t< typename T::value_type >, void > >
CNonexistentPathValidator	Check for an non-existing path
Cpair_adaptor	Adaptor for set-like structure: This just wraps a normal container in a few utilities that do almost nothing
Cpair_adaptor< T, conditional_t< false, void_t< typename T::value_type::first_type, typename T::value_type::second_type >, void > >
Csubtype_count	Set of overloads to get the type size of an object
Csubtype_count_min	Forward declare the subtype_count_min structure
Ctype_count	This will only trigger for actual void type
Ctype_count< T, typename std::enable_if< is_complex< T >::value >::type >	Type size for complex since it sometimes looks like a wrapper
Ctype_count< T, typename std::enable_if< is_mutable_container< T >::value >::type >	Type size of types that are wrappers,except complex and tuples(which can also be wrappers sometimes)
Ctype_count< T, typename std::enable_if< is_wrapper< T >::value &&!is_complex< T >::value &&!is_tuple_like< T >::value &&!is_mutable_container< T >::value >::type >	Type size of types that are wrappers,except containers complex and tuples(which can also be wrappers sometimes)
Ctype_count< T, typename std::enable_if<!is_wrapper< T >::value &&!is_tuple_like< T >::value &&!is_complex< T >::value &&!std::is_void< T >::value >::type >	Type size for regular object types that do not look like a tuple
Ctype_count_base	This will only trigger for actual void type
Ctype_count_base< T, typename std::enable_if< is_mutable_container< T >::value >::type >	Type count base for containers is the type_count_base of the individual element
Ctype_count_base< T, typename std::enable_if< is_tuple_like< T >::value &&!is_mutable_container< T >::value >::type >	Base tuple size
Ctype_count_base< T, typename std::enable_if<!is_tuple_like< T >::value &&!is_mutable_container< T >::value &&!std::is_void< T >::value >::type >	Type size for regular object types that do not look like a tuple
Cwrapped_type	Template to get the underlying value type if it exists or use a default
Cwrapped_type< T, def, typename std::enable_if< is_wrapper< T >::value >::type >	Type size for regular object types that do not look like a tuple
Nenums
NFailureMessage
CApp	Creates a command line program, with very few defaults
CArgumentMismatch	Thrown when the wrong number of arguments has been received
CAsNumberWithUnit
CAsSizeValue
CBadNameString	Thrown on construction of a bad name
CBound	Produce a bounded range (factory). Min and max are inclusive
CCallForAllHelp	Usually something like –help-all on command line
CCallForHelp	-h or –help on command line
CCallForVersion	-v or –version on command line
CCheckedTransformer	Translate named items to other or a value set
CConfig	This class provides a converter for configuration files
CConfigBase	This converter works with INI/TOML files; to write INI files use ConfigINI
CConfigError	Thrown when extra values are found in an INI file
CConfigINI	ConfigINI generates a "standard" INI compliant output
CConfigItem	Holds values to load into Options
CConstructionError	Construction errors (not in parsing)
CConversionError	Thrown when conversion call back fails, such as when an int fails to coerce to a string
CCustomValidator	Class wrapping some of the accessors of Validator
CError	All errors derive from this one
CExcludesError	Thrown when an excludes option is present
CExtrasError	Thrown when too many positionals or options are found
CFileError	Thrown when parsing an INI file and it is missing
CFormatter
CFormatterBase
CFormatterLambda	This is a specialty override for lambda functions
CHorribleError
CIncorrectConstruction	Thrown when an option is set to conflicting values (non-vector and multi args, for example)
CInvalidError	Thrown when validation fails before parsing
Cis_bool	Check to see if something is bool (fail check by default)
Cis_bool< bool >	Check to see if something is bool (true if actually a bool)
Cis_copyable_ptr	Check to see if something is copyable pointer
Cis_shared_ptr	Check to see if something is a shared pointer
Cis_shared_ptr< const std::shared_ptr< T > >	Check to see if something is a shared pointer (True if really a shared pointer)
Cis_shared_ptr< std::shared_ptr< T > >	Check to see if something is a shared pointer (True if really a shared pointer)
CIsMember	Verify items are in a set
CIsMemberType	This can be specialized to override the type deduction for IsMember
CIsMemberType< const char * >	The main custom type needed here is const char * should be a string
Cmake_void	A copy of std::void_t from C++17 (helper for C++11 and C++14)
COption
COption_group	Extension of App to better manage groups of options
COptionAlreadyAdded	Thrown when an option already exists
COptionBase
COptionDefaults
COptionNotFound	Thrown when counting a non-existent option
CParseError	Anything that can error in Parse
CRange	Produce a range (factory). Min and max are inclusive
CRequiredError	Thrown when a required option is missing
CRequiresError	Thrown when a requires option is missing
CRuntimeError	Does not output a diagnostic in CLI11_PARSE, but allows main() to return with a specific error code
CSuccess	This is a successful completion on parsing, supposed to exit
CTransformer	Translate named items to other or a value set
CTypeValidator	Validate the input as a particular type
CValidationError	Thrown when validation of results fails
CValidator	Some validators that are provided
►Nghc
►Nfilesystem
►Ndetail
Chas_d_type
Chas_d_type< T, decltype((void) T::d_type, 0)>
Cbasic_filebuf
Cbasic_fstream
Cbasic_ifstream
Cbasic_ofstream
Cdirectory_entry
►Cdirectory_iterator
Cimpl
Cproxy
Cfile_status
Cfilesystem_error
Cnot_implemented_exception
►Cpath
C_is_basic_string
C_is_basic_string< std::basic_string< CharT, std::char_traits< CharT >, std::allocator< CharT > > >
C_is_basic_string< std::basic_string< CharT, Traits, Alloc > >
Citerator
Cpath_helper_base
Crecursive_directory_iterator
Cspace_info
Cu8arguments
►Ngte
CIntpTricubic3
CIntpTrilinear3
►Nnwchem
CBasisSetParser
CMovecReader
►Npars
CRegex
CXyzParser
►Nsisi4s
►Ncc4s
CDimension
CHPHeader
CReadHeader
CScalarTypeTraits
CScalarTypeTraits< ScalarType::Complex64 >
CScalarTypeTraits< ScalarType::Real64 >
CAlgorithm
CAlgorithmFactory
CAlgorithmRegistrar	Class to be statically instantiated by an algorithm to register it in the AlgorithmFactory. Registered algorithms can be instantiated from the sisi4s control language
CAlternatingLeastSquaresRegularizationEstimator
CApproximateCoulombVertex
CApproximateParticleHoleCoulombVertex
CArgument
CBasisSetExtrapolation
CBinaryTensorDimensionHeader
CBinaryTensorHeader
CBinaryTensorHeaderBase
CBlacsWorld
CBooleanData
CCcsdDiagrammaticDecomposition
CCcsdEnergyFromCoulombIntegrals	Implements the iteration routine for the Ccsd method. Calculates the amplitudes $T_{a}^{i}$ and $T_{ab}^{ij}$ from the Coulomb integrals $V_{ij}^{ab}, V_{bj}^{ai}, V_{kl}^{ij}, V_{ka}^{ij}, V_{ci}^{ab}$ and $V_{cd}^{ab}$ (if given, else slicing and the Coulomb Vertex $\Gamma_{pG}^q$ is used)
CCcsdEnergyFromCoulombIntegralsReference	Implements the iteration routine for the Ccsd method. Calculates the amplitudes $T_{a}^{i}$ and $T_{ab}^{ij}$ from the Coulomb integrals $V_{ij}^{ab}, V_{bj}^{ai}, V_{kl}^{ij}, V_{ka}^{ij}, V_{ci}^{ab}$ and $V_{cd}^{ab}$ (if given, else slicing and the Coulomb Vertex $\Gamma_{pG}^q$ is used)
CCcsdEquationOfMotionDavidson
CCcsdPerturbativeTriples	Caclulates perturbative triples correction
CCcsdPerturbativeTriplesComplex	Caclulates perturbative triples correction
CCcsdPreconditioner	Implements the diagonal preconditionar for the davidson method
CCcsdtEnergyFromCoulombIntegrals
CCcsdtEquationOfMotionDavidson
CCisOneBodyReducedDensityMatrix
CCISPreconditioner
CClusterSinglesDoublesAlgorithm	Contains all the necessary tools for an algorithm with singles and doubles amplitudes. It calculates the energy from the amplitudes $T_{a}^{i}$ and $T_{ab}^{ij}$ and the Coulomb integrals $V_{ij}^{ab}$ . For calculating the amplitudes it calls the iteration routine of the actual algorithm
CClusterSinglesDoublesTriplesAlgorithm	Contains all the necessary tools for an algorithm with singles, doubles and triples amplitudes. It calculates the energy from the amplitudes $T_{a}^{i}$ , $T_{ab}^{ij}$ $T_{abc}^{ijk}$ and the Coulomb integrals $V_{ij}^{ab}$ . For calculating the amplitudes it calls the iteration routine of the actual algorithm
CClusterSinglesDoublesTriplesQuadruplesAlgorithm	Contains all the necessary tools for an algorithm with singles, doubles and triples amplitudes. It calculates the energy from the amplitudes $T_{a}^{i}$ , $T_{ab}^{ij}$ $T_{abc}^{ijk}$ and the Coulomb integrals $V_{ij}^{ab}$ . For calculating the amplitudes it calls the iteration routine of the actual algorithm
CComplexTensorContraction
CComplexTensorNorm
CComplexTensorReader
CComplexTensorSum
CComplexTensorWriter
CComplexTraits
CComplexTraits< Complex< T > >
CContainerData
CConversion
CConversion< Real, Complex< Real > >
CConversion< Target, Complex< Real > >
CCoulombIntegralsFromGaussian
CCoulombIntegralsFromRotatedCoulombIntegrals
CCoulombIntegralsFromVertex	Caclulates the Coulomb Integrals $V_{ij}^{ab}, V_{bj}^{ai}, V_{kl}^{ij}, V_{cd}^{ab}, V_{ka}^{ij}, V_{ci}^{ab}$ (if given) from the Coulomb Vertex $\Gamma_{rG}^q$ and stores them in CTF Tensors Vabij, Vaibj, Vijkl, Vabcd, Vijka, and Vabci respectively. The arguments of the integrals are PPPP, PPHH, HHHH, PHPH, HHHP, and PPPHCoulombIntegrals
CCoulombVertexDecomposition	Decomposes the Coulomb vertex $\Gamma_{rG}^q$ into the factor orbitals $\Pi_{qR}$ and the Coulom factors $\Lambda_{GR}$ . The decomposition is done with a regularized alternating least squares (RALS) algorithm, requiring only a few dozen steps for sufficient convergence. Note that currently the employed fit is $\Pi_{qR}\Pi_{rR}\Lambda_{GR}$ rather than the form with $\Pi_{qR}$ conjugated
CCoulombVertexFromFactors	Caclulates the Coulomb vertex $\Gamma^q_{rF}$ from the given given factor orbitals $\Pi^R_r$ and Coulomb factors $\Lambda^R_F$
►CCoulombVertexReader	Reads the Coulomb vertex $\Gamma_{pG}^q$ and the occupied and virtual orbital energies $\varepsilon_i, \varepsilon_a$ from binary data file, and stores them in the CTF Tensors GammaGqr, epsi, epsa
CChunk
CHeader
CCoulombVertexSingularVectors
►CCtfMachineTensor
CProtectedToken
►CCtfMachineTensorFactory
CProtectedToken
CData
CDefaultRandomEngine
CDefineHolesAndParticles
CDelete
CDetailedException
CDiisMixer
CDoublesAmplitudesDecomposition
CDoublesAmplitudesFromVertex	Caclulates the doubles amplitudes $T_{ij}^{ab}$ from the doubles amplitudes Vertex $Y^a_{iL}$
CDrccdEnergyFromCoulombIntegrals	Implements the iteration routine for the Drccd method. Calculates the amplitudes $T_{ab}^{ij}$ from the Coulomb Integrals $V_{ij}^{ab}$ in a $\mathcal{O}(N^{6})$ implementation
CDryIterativePseudoInverse
CDryMatrix
CDryMemory
CDryPseudoInverseHermitianSvd
CDryPseudoInverseSvd
CDryScalar
CDryTensor
CDryVector
CEACcsdPreconditioner
CEigenSystemDavidson
CEigenSystemDavidsonMono
CEmitter	Class with static members offering control over yaml emitting. Entries are emitted with the macro EMIT
CEomOneBodyReducedDensityMatrix	This implements one body rdm for eom ccsd In principle it calculates p T <0\| L \rho R e \|0> q For L and R being singles doubles vectors without 0-th components
CException
CExit
►CFcidumpReader
CFcidumpHeader
CFcidumpWriter
►CFiniteSizeCorrection
CMomentum
CFloatTypes
CFloatTypes< 32 >
CFloatTypes< 64 >
CFlopsCounter
CFockMatrixFromCoulombIntegrals
CFockVector	Represents the direct sum of Tensors and provides the vector space operations of addition, scalar multiplication, inner product, complex conjugation to get dual vectors and matrix multiplication between vectors and duals, which yields a scalar
CFockVectorNdCanonical
CFromComplexTensor
CGenerateRandomComplexMatrix
CGenerateRandomMatrix
CGenerateRandomTensor
CHartreeFockFromCoulombIntegrals
CHartreeFockFromGaussian
CIJKPointer	Caclulates perturbative triples correction, third attemp
CInputFileParser	Parser for sisi4s files specifying the calculation plan, i.e. which algorithms to use in which order
CInputFileParser< InputFileFormat::CC4S >
CInputFileParser< InputFileFormat::YAML >
CIntegerData
CIntegralInfo
CInter1D
CIPCcsdPreconditioner
CIrmlerTensor
CIterativePseudoInverse
CLapackGeneralEigenSystem
►CLapackGeneralEigenSystem< complex >
CEigenValueComparator
►CLapackGeneralEigenSystem< double >
CEigenValueComparator
CLapackInverse
CLapackInverse< Complex64 >
CLapackMatrix
CLinearMixer
CLineNumberStream	Wrapper for an input stream providing tracking of the current line and the current column during stream reading
CLog	Class with static members offering control over logging. Log entries are created with the macro LOG
CLogBuffer
CLogStream
CMap
CMeanCorrelationHoleDepth
CMixer
CMixerFactory
CMixerRegistrar	Class to be statically instantiated by a mixer to register it in the MixerFactory. Registered mixers can be instantiated from the sisi4s control language
CMoReader
CMp2NaturalOrbitals	Caclulates MP2 natural orbitals
CMpiCommunicator
CMpiTypeTraits
CMpiTypeTraits< complex >
CMpiTypeTraits< double >
CMpiTypeTraits< int >
CMpiTypeTraits< int64_t >
CMpiTypeTraits< uint64_t >
CMpiTypeTraits< Vector< F, D > >
CNaturalTransitionOrbitalsFromRhoAI
CNop
CNoRegularizationEstimator
CNuclearRepulsionEnergy
CNumberScanner
CNumberScanner< Complex< Real > >
CNumberScanner< Float64 >
CNumericData
COneBodyFromGaussian
COneBodyReducedDensityMatrix
COneBodyRotation
COptions
CParenthesisTriples
CParticleHoleCoulombVertexDecomposition	Decomposes the particle hole Coulomb vertex $\Gamma_{iG}^a$ into the occupied factor orbitals $\Pi_{iR}$ , the virtual factor orbitals $\Pi_{aR}$ , and the Coulom factors $\Lambda_{GR}$ . The decomposition is done with a regularized alternating least squares (RALS) algorithm, requiring only a few dozen steps for sufficient convergence
CParticleHoleCoulombVertexFromFactors	Caclulates the particle hole Coulomb vertex $\Gamma^a_{iF}$ from the given given particle factors orbitals $\Pi^R_a$ , hole factor orbitals $\Pi^R_i$ and Coulomb factors $\Lambda^R_F$
►CParticleHoleCoulombVertexReader	Reads the particle-hole Coulomb vertex $\Gamma_{iG}^a$ and the occupied and virtual orbital energies $\varepsilon_i, \varepsilon_a$ from binary data file, and stores them in the CTF Tensors GammaGai, epsi, epsa
CChunk
CHeader
CParticleHoleCoulombVertexSingularVectors
CPermutation
CPermutation< 1 >
CPerturbativeTriples	Caclulates perturbative triples correction
CPQRSCoulombIntegralsToVertex
CPreconditioner
CPseudoInverse
CPseudoInverseHermitianSvd
CPseudoInverseSvd
CRandomGenerator
CRangeParser	Class to parse a string of comma separated range delimiters. Note: It only works for unsigned integers
CRead
CRealData
CScaLapackDescriptor
CScaLapackHermitianEigenSystem
CScaLapackHermitianEigenSystem< complex >
CScaLapackHermitianEigenSystem< double >
CScaLapackHermitianEigenSystemDc
CScaLapackHermitianEigenSystemDc< complex >
CScaLapackHermitianEigenSystemDc< double >
CScaLapackMatrix
CScaLapackSingularValueDecomposition
CScaLapackSingularValueDecomposition< complex >
CScaLapackSingularValueDecomposition< double >
CScanner
CSDFockVector
CSDTFockVector
CSFockVector
►CSimilarityTransformedHamiltonian
CStructureFactor
CStructureFactorSettings
Csimpson
CSingleParticleOccupancies	Evaluates $\langle\Psi\|\hat N_p\|\Psi\rangle/\langle\Psi\|\Psi\rangle$ given the DoublesAmplitudes from a linearized coupled cluster theory
CSisi4s
CSliceCoulombVertex	Slices the particle hole part $\Gamma^{aG}_i$ from the full Coulomb vertex $\Gamma^{qG}_r$
CSlicedCtfTensor
CSourceLocation
CStantonIntermediatesUCCSD
CStaticAssert
CTensorAntisymmetrizer
CTensorAntisymmetrizer2
CTensorContraction
CTensorData
CTensorGetMax
CTensorIo
CTensorNorm
CTensorReader
CTensorReduceijij
CTensorSlicer
CTensorSum
CTensorUnrestricter
CTensorWriter
CTextData
CTime
CTimer
Ctrapezium
CTypedData
CTypeRelations
CTypeRelations< A *, A >
CTypeRelations< A, A >
CTypeRelations< double, complex >
CTypeRelations< int, complex >
CTypeRelations< int, double >
CTypeTraits
CTypeTraits< bool >
CTypeTraits< Complex64 >
CTypeTraits< Float64 >
CTypeTraits< int64_t >
CUccsdAmplitudesFromCoulombIntegrals
CUCcsdEAEquationOfMotionDavidson
CUCcsdIPEquationOfMotionDavidson
CUccsdtAmplitudesFromCoulombIntegrals
CUccsdtqAmplitudesFromCoulombIntegrals
CUegVertexGenerator
CUnrestrictedCIS
CUnrestrictedEquationOfMotionSinglesFromRpa
CUPerturbativeTriples	Caclulates perturbative triples correction
CUrpaAmplitudesFromCoulombIntegrals
CVector
CVectorTensor
CWrite
►Ntmole
CMosParser
►NYAML
Cconvert< AxisType >
Cconvert< Dimension >
Cconvert< ElementFileType >
Cconvert< HPHeader >
Cconvert< ReadableType >
Cconvert< ReadHeader >
Cconvert< ReadHeader::Version >
Cconvert< ScalarType >