| ►Nmadchem | |
| CAtomicAttractionFunctor | |
| CAtomicBasisFunctor | |
| CCorePotentialDerivativeFunctor | |
| CMolecularDerivativeFunctor | |
| CMolecularGuessDensityFunctor | |
| CMolecularSecondDerivativeFunctor | |
| ►Nmadness | Namespace for all elements and tools of MADNESS |
| ►Narchive | Namespace for I/O tools |
| ►Ndetail | |
| CRef | |
| Carchive_array | Wrapper for dynamic arrays and pointers |
| Carchive_ptr | Wrapper for an opaque pointer for serialization purposes |
| Carchive_typeinfo | Used to enable type checking inside archives |
| CArchiveImpl | Default implementations of wrap_store and wrap_load |
| CArchiveImpl< Archive, archive_array< T > > | Partial specialization of ArchiveImpl for archive_array |
| CArchiveImpl< Archive, T[n], std::enable_if_t<!std::is_same_v< T, char > &&is_serializable_v< Archive, T > > > | Partial specialization of ArchiveImpl for fixed-dimension arrays that redirects to archive_array |
| CArchiveImpl< ParallelInputArchive< localarchiveT >, archive_array< T > > | Read the archive array and broadcast |
| CArchiveImpl< ParallelInputArchive< localarchiveT >, T > | Specialization of ArchiveImpl for parallel input archives |
| CArchiveImpl< ParallelInputArchive< localarchiveT >, T[n]> | Forward a fixed-size array to archive_array |
| CArchiveImpl< ParallelOutputArchive< localarchiveT >, archive_array< T > > | Write the archive array only from process zero |
| CArchiveImpl< ParallelOutputArchive< localarchiveT >, T > | Specialization of ArchiveImpl for parallel output archives |
| CArchiveImpl< ParallelOutputArchive< localarchiveT >, T[n]> | Forward a fixed-size array to archive_array |
| CArchiveLoadImpl | Default load of an object via serialize(ar, t) |
| CArchiveLoadImpl< Archive, C > | |
| CArchiveLoadImpl< Archive, const DerivativeBase< T, NDIM > * > | |
| CArchiveLoadImpl< Archive, const FunctionImpl< T, NDIM > * > | |
| CArchiveLoadImpl< Archive, const SeparatedConvolution< T, NDIM > * > | |
| CArchiveLoadImpl< Archive, detail::RemoteCounter > | |
| CArchiveLoadImpl< Archive, detail::WorldPtr< T > > | Specialization of ArchiveLoadImpl for world pointers |
| CArchiveLoadImpl< Archive, FunctionImpl< T, NDIM > * > | |
| CArchiveLoadImpl< Archive, Future< T >, std::enable_if_t<!std::is_void_v< T > > > | Deserialize a future into an unassigned future |
| CArchiveLoadImpl< Archive, Future< void > > | Deserialize a future into an unassigned future (void specialization) |
| CArchiveLoadImpl< Archive, GenTensor< T > > | Deserialize a tensor ... existing tensor is replaced |
| CArchiveLoadImpl< Archive, Key< NDIM > > | |
| CArchiveLoadImpl< Archive, linked_list > | |
| CArchiveLoadImpl< Archive, std::allocator< T >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Deserialize a std::allocator |
| CArchiveLoadImpl< Archive, std::array< T, N >, std::enable_if_t< is_serializable_v< Archive, T > > > | Deserialize a std::array. MADNESS_ASSERT 's that the size matches |
| CArchiveLoadImpl< Archive, std::complex< T >, std::enable_if_t< is_serializable_v< Archive, T > > > | Deserialize a complex number |
| CArchiveLoadImpl< Archive, std::list< T, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Deserialize a std::list. Clears and resizes as necessary |
| CArchiveLoadImpl< Archive, std::map< T, Q, Compare, Alloc >, std::enable_if_t< is_serializable_v< Archive, T > &&is_serializable_v< Archive, Q > > > | Deserialize an std::map. The map is not cleared; duplicate elements are replaced |
| CArchiveLoadImpl< Archive, std::set< T, Compare, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Deserialize a std::set. Clears and resizes as necessary |
| CArchiveLoadImpl< Archive, std::shared_ptr< const FunctionImpl< T, NDIM > > > | |
| CArchiveLoadImpl< Archive, std::shared_ptr< FunctionImpl< T, NDIM > > > | |
| CArchiveLoadImpl< Archive, std::string > | Deserialize a std::string. Clears and resizes as necessary |
| CArchiveLoadImpl< Archive, std::vector< bool, Alloc > > | Deserialize a std::vector<bool>. Clears and resizes as necessary |
| CArchiveLoadImpl< Archive, std::vector< Future< T > > > | Deserialize a vector of futures into a vector of unassigned futures |
| CArchiveLoadImpl< Archive, std::vector< T, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Deserialize a std::vector. Clears and resizes as necessary |
| CArchiveLoadImpl< Archive, Tensor< T > > | Deserialize a tensor ... existing tensor is replaced |
| CArchiveLoadImpl< Archive, World * > | Specialization of ArchiveLoadImpl for World pointers |
| CArchiveLoadImpl< BinaryFstreamInputArchive, Key< NDIM > > | |
| CArchiveLoadImpl< BufferInputArchive, const WorldObject< Derived > * > | Specialization of ArchiveLoadImpl for constant, globally-addressable objects |
| CArchiveLoadImpl< BufferInputArchive, WorldObject< Derived > * > | Specialization of ArchiveLoadImpl for globally-addressable objects |
| CArchiveLoadImpl< ParallelInputArchive< archiveT >, CCPairFunction< T, NDIM > > | |
| CArchiveLoadImpl< ParallelInputArchive< archiveT >, Function< T, NDIM > > | |
| CArchiveLoadImpl< ParallelInputArchive< localarchiveT >, WorldContainer< keyT, valueT > > | |
| CArchivePrePostImpl | Default implementation of the pre/postamble for type checking |
| CArchivePrePostImpl< BufferInputArchive, T > | Implement pre/postamble load routines for a BufferInputArchive |
| CArchivePrePostImpl< BufferOutputArchive, T > | Implement pre/postamble storage routines for a BufferOutputArchive |
| CArchivePrePostImpl< ContainerRecordInputArchive, T > | Implementation of functions for loading the pre/postamble in ContainerRecord archives |
| CArchivePrePostImpl< ContainerRecordOutputArchive, T > | Implementation of functions for storing the pre/postamble in ContainerRecord archives |
| CArchivePrePostImpl< MPIInputArchive, T > | Implementation of functions for loading the pre/postamble in MPI archives |
| CArchivePrePostImpl< MPIOutputArchive, T > | Implementation of functions for storing the pre/postamble in MPI archives |
| CArchivePrePostImpl< MPIRawInputArchive, T > | Implementation of functions for loading the pre/postamble in MPI archives |
| CArchivePrePostImpl< MPIRawOutputArchive, T > | Implementation of functions for storing the pre/postamble in MPI archives |
| CArchivePrePostImpl< ParallelInputArchive< localarchiveT >, T > | Disable type info for parallel input archives |
| CArchivePrePostImpl< ParallelOutputArchive< localarchiveT >, T > | Disable type info for parallel output archives |
| CArchivePrePostImpl< TextFstreamInputArchive, T > | Implement pre/postamble load routines for a TextFstreamInputArchive |
| CArchivePrePostImpl< TextFstreamOutputArchive, T > | Implement pre/postamble storage routines for a TextFstreamOutputArchive |
| CArchivePrePostImpl< VectorInputArchive, T > | Implementation of functions for loading the pre/postamble in Vector archives |
| CArchivePrePostImpl< VectorOutputArchive, T > | Implementation of functions for storing the pre/postamble in Vector archives |
| CArchiveSerializeImpl | Default symmetric serialization of a non-fundamental type that has serialize method |
| CArchiveSerializeImpl< Archive, B > | |
| CArchiveSerializeImpl< Archive, Key > | |
| CArchiveSerializeImpl< Archive, resT(*)(paramT...), std::enable_if_t<!is_default_serializable_v< Archive, resT(*)(paramT...)> > > | Serialize a function pointer |
| CArchiveSerializeImpl< Archive, resT(objT::*)(paramT...) const, std::enable_if_t<!is_default_serializable_v< Archive, resT(objT::*)(paramT...) const > > > | Serialize a const member function pointer |
| CArchiveSerializeImpl< Archive, resT(objT::*)(paramT...), std::enable_if_t<!is_default_serializable_v< Archive, resT(objT::*)(paramT...)> > > | Serialize a member function pointer |
| CArchiveSerializeImpl< Archive, std::optional< T >, std::enable_if_t< is_serializable_v< Archive, T > > > | Serialize (deserialize) an std::optional |
| CArchiveSerializeImpl< Archive, std::pair< T, Q >, std::enable_if_t< is_serializable_v< Archive, T > &&is_serializable_v< Archive, Q > > > | Serialize (deserialize) an std::pair |
| CArchiveSerializeImpl< Archive, std::tuple< Types... >, std::enable_if_t<(is_serializable_v< Archive, Types > &&...) > > | Serialize (deserialize) a std::tuple |
| CArchiveStoreImpl | Default store of an object via serialize(ar, t) |
| CArchiveStoreImpl< Archive, C > | |
| CArchiveStoreImpl< Archive, const DerivativeBase< T, NDIM > * > | |
| CArchiveStoreImpl< Archive, const FunctionImpl< T, NDIM > * > | |
| CArchiveStoreImpl< Archive, const SeparatedConvolution< T, NDIM > * > | |
| CArchiveStoreImpl< Archive, detail::RemoteCounter > | |
| CArchiveStoreImpl< Archive, detail::WorldPtr< T > > | Specialization of ArchiveStoreImpl for world pointers |
| CArchiveStoreImpl< Archive, FunctionImpl< T, NDIM > * > | |
| CArchiveStoreImpl< Archive, Future< T >, std::enable_if_t<!std::is_void_v< T > > > | Serialize an assigned future |
| CArchiveStoreImpl< Archive, Future< void > > | Serialize an assigned future (void specialization) |
| CArchiveStoreImpl< Archive, GenTensor< T > > | Serialize a tensor |
| CArchiveStoreImpl< Archive, Key< NDIM > > | |
| CArchiveStoreImpl< Archive, linked_list > | |
| CArchiveStoreImpl< Archive, std::allocator< T >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Serialize a std::allocator |
| CArchiveStoreImpl< Archive, std::array< T, N >, std::enable_if_t< is_serializable_v< Archive, T > > > | Serialize a std::array |
| CArchiveStoreImpl< Archive, std::complex< T >, std::enable_if_t< is_serializable_v< Archive, T > > > | Serialize a complex number |
| CArchiveStoreImpl< Archive, std::list< T, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Serialize a std::list |
| CArchiveStoreImpl< Archive, std::map< T, Q, Compare, Alloc >, std::enable_if_t< is_serializable_v< Archive, T > &&is_serializable_v< Archive, Q > > > | Serialize an std::map |
| CArchiveStoreImpl< Archive, std::set< T, Compare, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Serialize a std::set |
| CArchiveStoreImpl< Archive, std::shared_ptr< const FunctionImpl< T, NDIM > > > | |
| CArchiveStoreImpl< Archive, std::shared_ptr< FunctionImpl< T, NDIM > > > | |
| CArchiveStoreImpl< Archive, std::string > | Serialize a 'std::string' |
| CArchiveStoreImpl< Archive, std::vector< bool, Alloc > > | Serialize a std::vector<bool> (as a plain array of bool) |
| CArchiveStoreImpl< Archive, std::vector< Future< T > > > | Serialize a vector of assigned futures |
| CArchiveStoreImpl< Archive, std::vector< T, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Serialize a std::vector |
| CArchiveStoreImpl< Archive, Tensor< T > > | Serialize a tensor |
| CArchiveStoreImpl< Archive, World * > | Specialization of ArchiveStoreImpl for World pointers |
| CArchiveStoreImpl< BufferOutputArchive, const WorldObject< Derived > * > | Specialization of ArchiveStoreImpl for constant, globally-addressable objects |
| CArchiveStoreImpl< BufferOutputArchive, WorldObject< Derived > * > | Specialization of ArchiveStoreImpl for globally-addressable objects |
| CArchiveStoreImpl< ParallelOutputArchive< archiveT >, CCPairFunction< T, NDIM > > | |
| CArchiveStoreImpl< ParallelOutputArchive< archiveT >, Function< T, NDIM > > | |
| CArchiveStoreImpl< ParallelOutputArchive< ContainerRecordOutputArchive >, WorldContainer< keyT, valueT > > | |
| CArchiveStoreImpl< ParallelOutputArchive< localarchiveT >, WorldContainer< keyT, valueT > > | Write container to parallel archive with optional fence |
| CArchiveStoreImpl< ParallelOutputArchive< VectorOutputArchive >, WorldContainer< keyT, valueT > > | Write container to parallel archive |
| CBaseArchive | Base class for all archive classes |
| CBaseInputArchive | Base class for input archive classes |
| CBaseOutputArchive | Base class for output archive classes |
| CBaseParallelArchive | Base class for input and output parallel archives |
| CBinaryFstreamInputArchive | Wraps an archive around a binary filestream for input |
| CBinaryFstreamOutputArchive | Wraps an archive around a binary filestream for output |
| CBufferInputArchive | Wraps an archive around a memory buffer for input |
| CBufferOutputArchive | Wraps an archive around a memory buffer for output |
| CContainerRecordInputArchive | |
| CContainerRecordOutputArchive | |
| CMPIInputArchive | Archive allowing buffering, deserialization of data, and point-to-point communication between processes with MPI |
| CMPIOutputArchive | Archive allowing buffering, serialization of data, and point-to-point communication between processes with MPI |
| CMPIRawInputArchive | Archive allowing deserialization and point-to-point communication between processes with MPI |
| CMPIRawOutputArchive | Archive allowing serialization and point-to-point communication between processes with MPI |
| CParallelInputArchive | An archive for storing local or parallel data, wrapping a BinaryFstreamInputArchive |
| CParallelOutputArchive | An archive for storing local or parallel data wrapping a BinaryFstreamOutputArchive |
| CParallelSerializableObject | Objects that implement their own parallel archive interface should derive from this class |
| CTextFstreamInputArchive | Wraps an archive around a text filestream for input |
| CTextFstreamOutputArchive | Wraps an archive around a text filestream for output |
| CVectorInputArchive | Wraps an archive around an STL vector for input |
| CVectorOutputArchive | Wraps an archive around an STL vector for output |
| Ncblas | |
| Nconstants | Namespace storing mathematical and physical constants |
| ►Ndetail | |
| Narg_holder | |
| Cabsinplace | |
| Cabsop | |
| Cabssqop | |
| Cabssquareinplace | |
| Cadqtest | |
| CArgCount | |
| CArgCountHelper | |
| CArgCountHelper< void > | |
| CArgHolder | A wrapper object for holding task function argument objects |
| Ccallable_enabler | |
| Ccallable_enabler< callableT, std::enable_if_t< callable_traits< callableT >::value > > | |
| Ccallable_traits | Function traits in the spirit of boost function traits |
| Ccallable_traits< fnT(argTs...), std::enable_if_t< is_type< std::invoke_result_t< fnT, argTs... > >::value > > | Function traits in the spirit of boost function traits |
| CDefaultInitPtr | Default pointer to a. object of type T |
| CDefaultInitPtr< std::shared_ptr< T > > | Default shared pointer to an object of type T |
| CDeferredCleanup | Deferred cleanup of shared_ptr's |
| ►CDistCache | Distributed caching utility |
| CCache | Cache interface class |
| CCacheData | Cache value container |
| CForEachRootTask | Apply an operation to a range of iterators |
| Cfunction_enabler | |
| Cfunction_enabler_helper | Behave like a lazy std::enable_if |
| Cfunction_enabler_helper< false, returnT > | Specialization that disables type when B is false |
| Cfunction_traits | Function traits in the spirit of boost function traits |
| Cfunction_traits< fnT(argTs...), std::enable_if_t< is_type< std::invoke_result_t< fnT, argTs... > >::value > > | Function trait specialization for a callable (can be a function, a (generic) lambda, etc.) |
| Cfunction_traits< resultT(*&)(argTs...), void > | Function trait specialization for a reference to a free function pointer |
| Cfunction_traits< resultT(*)(argTs...), void > | Function trait specialization for a free function pointer |
| Chelper | |
| Chelper< T, 0 > | |
| Chelper< T, 1 > | |
| Cimagop | |
| Cinfo | |
| Cinfo_base | |
| Cis_arg_holder | |
| Cis_arg_holder< ArgHolder< T > > | |
| Cis_functor | |
| Cis_functor< fnT, typename std::enable_if< is_type< typename fnT::result_type >::value >::type > | |
| Cis_type | |
| Cmemfunc_enabler | |
| Cmemfunc_enabler< const objT *, memfnT > | |
| Cmemfunc_enabler< const objT *const, memfnT > | |
| Cmemfunc_enabler< const std::shared_ptr< objT > &, memfnT > | |
| Cmemfunc_enabler< const std::shared_ptr< objT >, memfnT > | |
| Cmemfunc_enabler< objT *, memfnT > | |
| Cmemfunc_enabler< objT *const, memfnT > | |
| Cmemfunc_enabler< std::shared_ptr< objT > &, memfnT > | |
| Cmemfunc_enabler< std::shared_ptr< objT >, memfnT > | |
| Cmemfunc_enabler_base | |
| Cmemfunc_enabler_base< objT, resT(baseT::*)(paramT...) const, typename std::enable_if< std::is_base_of< baseT, objT >::value >::type > | |
| Cmemfunc_enabler_base< objT, resT(baseT::*)(paramT...), typename std::enable_if< std::is_base_of< baseT, objT >::value >::type > | |
| Cmemfunc_traits | Member function traits in the spirit of boost function traits |
| Cmemfunc_traits< returnT(objT::*)(argTs...) const > | Member function traits in the spirit of boost function traits |
| Cmemfunc_traits< returnT(objT::*)(argTs...)> | Member function traits in the spirit of boost function traits |
| CMemFuncWrapper | Functor wrapper for object and member function pointers |
| CMemFuncWrapper< ptrT, memfnT, void > | Functor wrapper for object and member function pointers |
| Cnoop | |
| CPendingMsg | Common base class for pending messages to ensure in-order processing |
| Cptr_traits | |
| Cptr_traits< void > | Specialization of ptr_traits for type void |
| Creal_type | |
| Creal_type< std::complex< T > > | |
| Crealop | |
| CRemoteCounter | Remote reference counter |
| CRemoteCounterBase | Base class for remote counter implementation objects |
| CRemoteCounterImpl | Remote counter implementation object |
| Cresult_of | |
| Cresult_of< fnT, typename std::enable_if< function_traits< fnT >::value >::type > | |
| Cresult_of< fnT, typename std::enable_if< is_type< decltype(&fnT::operator())>::value >::type > | |
| Cresult_of< fnT, typename std::enable_if< memfunc_traits< fnT >::value >::type > | |
| Cscaleinplace | |
| Csquareinplace | |
| CStackBase | Base class for Stack which implements basic memory operations for non-POD objects |
| CStackBase< T, true > | Base class for Stack which implements basic memory operations for POD objects |
| Ctask_arg | |
| Ctask_arg< Future< T > * > | |
| Ctask_arg< Future< T > > | |
| Ctask_arg< Future< void > > | |
| Ctask_arg< void > | |
| Ctask_result_type | |
| CTaskHandlerInfo | Serialization container for sending tasks to remote nodes |
| CWorldMpi | MPI singleton that manages MPI setup and teardown for MADNESS |
| CWorldMpiRuntime | MPI runtime reference counter |
| CWorldObjectTaskHelper | |
| CWorldObjectTaskHelper< objT, memfnT, typename std::enable_if< std::is_base_of< std::enable_shared_from_this< objT >, objT >::value >::type > | |
| CWorldPtr | A global pointer address, valid anywhere in the world |
| ►Nguessfactory | |
| CExopUnaryOpStructure | |
| CGaussFunctor | |
| CPlaneWaveFunctor | Creates a plane-wave: sin (or cos) with argument (npi/L*x) |
| CPolynomialFunctor | Project a general 3D polynomial to the MRA Grid |
| CPolynomialTrigonometricsFunctor | |
| ►NHash_private | |
| Cbin | |
| Centry | |
| CHashAccessor | |
| CHashIterator | Iterator for hash |
| Ninfo | Runtime details on the configuration and version of MADNESS |
| ►Nis_istreammable_ns | |
| Cimpl | |
| ►Nis_ostreammable_ns | |
| Cimpl | |
| Nlapacke | |
| ►Nmeta | |
| ►Ndetail | |
| Cdetector | |
| Cdetector< Default, void_t< Op< Args... > >, Op, Args... > | |
| Cconjunction | |
| Cconjunction< B1 > | |
| Cconjunction< B1, Bn... > | |
| Cdisjunction | |
| Cdisjunction< B1 > | |
| Cdisjunction< B1, Bn... > | |
| Cdrop_last_arg_and_apply | |
| Cdrop_last_arg_and_apply_callable | |
| Cdrop_last_arg_and_apply_callable_impl | |
| Cdrop_last_arg_and_apply_callable_impl< MetaFn, Callable, typelist< UpToLast... >, Last > | |
| Cdrop_last_arg_and_apply_callable_impl< MetaFn, Callable, typelist< UpToT... >, T, Rest... > | |
| Cdrop_last_arg_and_apply_impl | |
| Cdrop_last_arg_and_apply_impl< MetaFn, typelist< UpToLast... >, Last > | |
| Cdrop_last_arg_and_apply_impl< MetaFn, typelist< UpToT... >, T, Rest... > | |
| Clast_type | |
| Clast_type< T0 > | |
| Clast_type< T0, T1, Ts... > | |
| Cmake_void | |
| Cnonesuch | |
| Ctaskattr_is_last_arg | |
| Ctaskattr_is_last_arg<> | |
| Ctypelist | |
| ►Noperators | |
| C__x | |
| ►Nprofiling | |
| CTaskEvent | Task event class |
| CTaskEventList | A list of task events |
| CTaskEventListBase | Task event list base class |
| CTaskProfiler | This class collects and prints task profiling data |
| Ntr1 | |
| ►Nunits | |
| Nliterals | |
| Cabs_op | |
| Cabs_square_op | |
| CAbstractVectorSpace | A generic vector space which provides common operations needed by linear algebra routines (norm, inner product, etc.) |
| CAC | |
| Caccumulate_op | Inserts/accumulates coefficients into impl's tree |
| CACParameters | Contains all the parameters for the asymptotic correction |
| Cadd_future | Maps type T to Future<T> |
| Cadd_future< Future< T > > | Maps Future<T> to Future<T> |
| CAdhocNuclearCorrelationFactor | This ncf has no information about itself, only U2 and U1 assigned |
| CAmArg | World active message that extends an RMI message |
| ►Capply_kernel_helper | |
| Cslater_kernel | |
| Carray_of_bools | Syntactic sugar for std::array<bool, N> |
| Casymptotic_density | |
| Casymptotic_slater | |
| Casymptotic_slater_kernel | |
| CAtom | |
| Catom_information | Needed information about atom to compute asymptotic correction |
| CAtomCore | |
| Catomic_attraction | |
| CAtomicBasis | Represents multiple shells of contracted gaussians on a single center |
| CAtomicBasisFunction | Used to represent one basis function from a shell on a specific center |
| ►CAtomicBasisSet | Contracted Gaussian basis |
| CAnalysisSorter | |
| CAtomicData | |
| CAtomicInt | An integer with atomic set, get, read+increment, read+decrement, and decrement+test operations |
| CBandlimitedPropagator | Class to evaluate the filtered Schrodinger free-particle propagator in real space |
| CBarrier | |
| CBaseTensor | The base class for tensors defines generic capabilities |
| ►CBasisFunctions | |
| CCartesianGaussian | |
| CSolidHarmonicGaussian | |
| CBatch | Batch consists of a 2D-input batch and a 1D-output batch: K-batch <- (I-batch, J-batch) |
| CBatch_1D | |
| CBinaryOpStructure | Computes the corrected exchange correlation potential using the hartree potential |
| CBinSorter | A parallel bin sort across MPI processes |
| CBoundaryConditions | This class is used to specify boundary conditions for all operators |
| CBoxSurfaceDisplacementFilter | |
| ►CBoxSurfaceDisplacementRange | |
| CIterator | Iterator class for lazy generation of surface points |
| CBSHApply | Apply the BSH operator on a vector of functions with corresponding potentials |
| CBSHFunctionInterface | Function like f(x) = exp(-mu x)/x |
| CCalculationParameters | |
| CCallbackInterface | The class used for callbacks (e.g., dependency tracking) |
| Ccartesian_grid | |
| CCC2 | |
| CCC_vecfunction | A helper structure which holds a map of functions |
| ►CCCConvolutionOperator | |
| CParameters | Parameter class |
| CCCFunction | Structure for a CC Function 3D which holds an index and a type |
| CCCIntermediatePotentials | Little helper structure which manages the stored singles potentials |
| CCCMessenger | |
| CCCPair | |
| CCCPairBuilder | Build an MP2 or CC2 or LRCC2 etc pair, possibly including the lo-rank parts |
| CCCPairFunction | 6D function, either in full or low rank form, possibly including an 2-particle function |
| CCCParameters | |
| CCCSize | Print accumulated size of all functions |
| CCCTimer | Timer Structure |
| Ccharactertable | |
| CCISData | POD for CIS excitation |
| ►CCloud | Cloud class |
| Ccloudtimer | |
| Cis_madness_function_vector | |
| Cis_madness_function_vector< std::vector< Function< T, NDIM > > > | |
| Cis_tuple | |
| Cis_tuple< std::tuple< T... > > | |
| Cis_vector | |
| Cis_vector< std::vector< Q > > | |
| CCoeffTracker | Class to track where relevant (parent) coeffs are |
| Ccommandlineparser | Very simple command line parser |
| CComplex_CIS_Parameters | |
| CComplexExp | |
| CCompositeFactory | Factory for facile setup of a CompositeFunctorInterface and its FuncImpl |
| CCompositeFunctorInterface | CompositeFunctorInterface implements a wrapper of holding several functions and functors |
| CConcurrentHashMap | |
| Cconditional_conj_struct | For real types return value, for complex return conjugate |
| Cconditional_conj_struct< Q, true > | For real types return value, for complex return conjugate |
| CConditionVariable | Scalable and fair condition variable (spins on local value) |
| Cconj_op | |
| CContractedGaussianShell | Represents a single shell of contracted, Cartesian, Gaussian primitives |
| CConvolution1D | Provides the common functionality/interface of all 1D convolutions |
| CConvolutionData1D | !!! Note that if Rnormf is zero then ALL of the tensors are empty |
| CConvolutionND | Array of 1D convolutions (one / dimension) |
| CCoreOrbital | |
| CCoreOrbitalDerivativeFunctor | |
| CCoreOrbitalFunctor | |
| CCorePotential | Represents a core potential |
| CCorePotentialManager | |
| ►CCoulomb | |
| ►CMacroTaskCoulomb | |
| CMacroTaskPartitionerCoulomb | |
| CCubicInterpolationTable | An class for 1-D data interpolation based on cubic polynomials |
| Cdefault_allocator | |
| CDeferredDeleter | |
| Cdens_inv | |
| Cdensity_mask_operator | |
| CDependencyInterface | Provides an interface for tracking dependencies |
| CDerivative | Implements derivatives operators with variety of boundary conditions on simulation domain |
| CDerivativeBase | Tri-diagonal operator traversing tree primarily for derivative operator |
| CDerivativeOperator | |
| CDFParameters | |
| CDFT | |
| CDFTCoulombOp | |
| CDFTCoulombPeriodicOp | |
| Cdftgrid | |
| CDFTNuclearChargeDensityOp | |
| CDFTNuclearPotentialOp | |
| CDiamagnetic_potential_factor | To be put in a separate file |
| CDipoleFunctor | A MADNESS functor to compute either x, y, or z |
| CDisplacements | Holds displacements for applying operators to avoid replicating for all operators |
| CDistributedMatrix | Manages data associated with a row/column/block distributed array |
| CDistributedMatrixDistribution | |
| Cdivide_add_interpolate | Class to compute terms of the potential |
| CDNuclear | Derivative of the (regularized) nuclear potential wrt nuclear displacements |
| CDomainMaskInterface | The interface for masking functions defined by signed distance functions |
| CDomainMaskSDFFunctor | Framework for combining a signed distance function (sdf) with a domain mask to produce MADNESS functions |
| CDQStats | |
| CDQueue | A thread safe, fast but simple doubled-ended queue |
| CEigSolver | |
| CEigSolverOp | |
| CElectronCuspyBox_op | |
| CElectronicStructureParams | |
| CElectronPair | Enhanced POD for the pair functions |
| CElectronPairIterator | |
| CElectronRepulsionInterface | Function like f(x)=1/x |
| CElementaryInterface | ElementaryInterface (formerly FunctorInterfaceWrapper) interfaces a c-function |
| Cerror_leaf_op | |
| ►CExchange | |
| ►CExchangeImpl | |
| ►CMacroTaskExchangeRow | |
| CMacroTaskPartitionerRow | Custom partitioning for the exchange operator in exchangeoperator.h |
| ►CMacroTaskExchangeSimple | |
| CMacroTaskPartitionerExchange | Custom partitioning for the exchange operator in exchangeoperator.h |
| CF12Parameters | |
| CF12Potentials | Class that provides all necessary F12 Potentials and Integrals |
| CFock | Computes matrix representation of the Fock operator |
| ►CFunction | A multiresolution adaptive numerical function |
| Cautorefine_square_op | |
| CSimpleUnaryOpWrapper | |
| Cfunction_real2complex_op | |
| CFunctionCommonData | FunctionCommonData holds all Function data common for given k |
| CFunctionCommonFunctionality | Collect common functionality does not need to be member function of funcimpl |
| CFunctionDefaults | FunctionDefaults holds default paramaters as static class members |
| CFunctionFactory | FunctionFactory implements the named-parameter idiom for Function |
| CFunctionFunctorInterface | Abstract base class interface required for functors used as input to Functions |
| ►CFunctionImpl | FunctionImpl holds all Function state to facilitate shallow copy semantics |
| Cadd_op | Add two functions f and g: result=alpha * f + beta * g |
| Ccoeff_value_adaptor | |
| Cdo_accumulate_trees | Merge the coefficent boxes of this into result's tree |
| Cdo_average | "put" this on g |
| Cdo_change_tensor_type | Change representation of nodes' coeffs to low rank, optional fence |
| Cdo_check_symmetry_local | Check symmetry wrt particle exchange |
| Cdo_compute_snorm_and_dnorm | Compute the norm of the wavelet coefficients |
| Cdo_consolidate_buffer | |
| Cdo_convert_to_color | |
| Cdo_dot_local | Compute the inner product of this range with other |
| Cdo_err_box | |
| Cdo_gaxpy_inplace | Functor for the gaxpy_inplace method |
| Cdo_inner_ext_local_ffi | |
| Cdo_inner_local | Compute the inner product of this range with other |
| Cdo_inner_local_on_demand | Compute the inner product of this range with other |
| Cdo_keep_sum_coeffs | Keep only the sum coefficients in each node |
| Cdo_map_and_mirror | Mirror dimensions of this, write result on f |
| Cdo_mapdim | Map this on f |
| Cdo_merge_trees | Merge the coefficient boxes of this into other's tree |
| Cdo_mirror | Mirror dimensions of this, write result on f |
| Cdo_norm2sq_local | |
| Cdo_op_args | Laziness |
| Cdo_reduce_rank | Reduce the rank of the nodes, optional fence |
| Cdo_standard | Changes non-standard compressed form to standard compressed form |
| Cdo_truncate_NS_leafs | Given an NS tree resulting from a convolution, truncate leafs if appropriate |
| Cdo_unary_op_value_inplace | |
| Chartree_op | Hartree product of two LDIM functions to yield a NDIM = 2*LDIM function |
| Cmultiply_op | Perform this multiplication: h(1,2) = f(1,2) * g(1) |
| Cpointwise_multiplier | |
| Cproject_out_op | Project the low-dim function g on the hi-dim function f: result(x) = <f(x,y) | g(y)> |
| Crecursive_apply_op | Recursive part of recursive_apply |
| Crecursive_apply_op2 | Recursive part of recursive_apply |
| Cremove_internal_coeffs | Remove all coefficients of internal nodes |
| Cremove_leaf_coeffs | Remove all coefficients of leaf nodes |
| Ctrue_refine_test | |
| CVphi_op_NS | Given a ket and the 1- and 2-electron potentials, construct the function V phi |
| CFunctionInterface | FunctionInterface implements a wrapper around any class with the operator()() |
| CFunctionNode | FunctionNode holds the coefficients, etc., at each node of the 2^NDIM-tree |
| CFunctionSpace | A vector space using MADNESS Functions |
| CFunctorInterface | FunctorInterface interfaces a class or struct with an operator()() |
| ►CFuture | A future is a possibly yet unevaluated value |
| Cdddd | |
| CFuture< Future< T > > | A future of a future is forbidden (by deleted constructor) |
| CFuture< std::vector< Future< T > > > | Specialization of Future for a vector of Futures |
| CFuture< void > | Specialization of Future<void> for internal convenience. This does nothing useful! |
| Cfuture_to_ref | |
| Cfuture_to_ref< const Future< T > & > | |
| Cfuture_to_ref< Future< T > & > | |
| Cfuture_to_ref< Future< T > * > | |
| Cfuture_to_ref< Future< T > > | |
| CFutureImpl | Implements the functionality of futures |
| CFutureImpl< void > | Specialization of FutureImpl<void> for internal convenience. This does nothing useful! |
| CGaussianConvolution1D | 1D convolution with (derivative) Gaussian; coeff and expnt given in simulation coordinates [0,1] |
| CGaussianConvolution1DCache | |
| CGaussianDomainMask | Use a Gaussian for the surface function and the corresponding erf for the domain mask |
| CGaussianGenericFunctor | |
| CGaussSlater | A nuclear correlation factor class |
| CGeneralTwoElectronInterface | Function like f(x)=1/x |
| ►CGenericConvolution1D | Generic 1D convolution using brute force (i.e., slow) adaptive quadrature for rnlp |
| CShmoo | |
| CGenTensor | |
| CGFit | |
| CGnuplot | |
| CGradientalGaussSlater | A nuclear correlation factor class |
| Cgridbase | |
| ►CGroup | A collection of processes |
| CImpl | |
| CGTHPseudopotential | |
| Charmonic_potential_boxed | Functor for the diamagnetic term in a box |
| Chartree_convolute_leaf_op | |
| Chartree_leaf_op | Returns true if the result of a hartree_product is a leaf node (compute norm & error) |
| CHartreeFock | |
| CHartreeFockCoulombOp | |
| CHartreeFockExchangeOp | |
| CHartreeFockNuclearPotentialOp | |
| CHash | Hash functor |
| CHighDimIndexIterator | |
| CIEigSolverObserver | |
| Cimag_op | |
| CIndexIterator | |
| CInfo | POD holding some basic functions and some intermediates for the CC2 calculation |
| CInitParameters | |
| Cinsert_op | Insert/replaces the coefficients into the function |
| Cint_factor_functor | Functor for the correction factor, which is multiplied with the exchange correlation potential |
| Cis_any_function_pointer | True type if T is a pointer to free or member function |
| Cis_any_function_pointer< T, std::enable_if_t< std::is_member_function_pointer< T >::value||is_function_pointer_v< T > > > | |
| Cis_archive | Checks if T is an archive type |
| Cis_archive< archive::BinaryFstreamInputArchive > | |
| Cis_archive< archive::BinaryFstreamOutputArchive > | |
| Cis_archive< archive::BufferInputArchive > | |
| Cis_archive< archive::BufferOutputArchive > | |
| Cis_archive< archive::ContainerRecordInputArchive > | |
| Cis_archive< archive::ContainerRecordOutputArchive > | |
| Cis_archive< archive::MPIInputArchive > | |
| Cis_archive< archive::MPIOutputArchive > | |
| Cis_archive< archive::MPIRawInputArchive > | |
| Cis_archive< archive::MPIRawOutputArchive > | |
| Cis_archive< archive::ParallelInputArchive< localarchiveT > > | |
| Cis_archive< archive::ParallelOutputArchive< localarchiveT > > | |
| Cis_archive< archive::TextFstreamInputArchive > | |
| Cis_archive< archive::TextFstreamOutputArchive > | |
| Cis_archive< archive::VectorInputArchive > | |
| Cis_archive< archive::VectorOutputArchive > | |
| Cis_cereal_archive | |
| Cis_default_serializable | std::true_type if T can be serialized to Archive without specialized serialize() method |
| Cis_default_serializable_helper | |
| Cis_default_serializable_helper< Archive, archive::archive_array< T >, std::enable_if_t< is_default_serializable_helper< Archive, T >::value > > | |
| Cis_default_serializable_helper< archive::BinaryFstreamInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::BinaryFstreamOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::BufferInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::BufferOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::ContainerRecordInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::ContainerRecordOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::MPIInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::MPIOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::MPIRawInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::MPIRawOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::ParallelInputArchive< localarchiveT >, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::ParallelOutputArchive< localarchiveT >, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::TextFstreamInputArchive, T, std::enable_if_t< is_iostreammable_v< T >||is_any_function_pointer_v< T > > > | |
| Cis_default_serializable_helper< archive::TextFstreamOutputArchive, T, std::enable_if_t< is_iostreammable_v< T >||std::is_function_v< T >||is_any_function_pointer_v< T > > > | |
| Cis_default_serializable_helper< archive::VectorInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_default_serializable_helper< archive::VectorOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cis_function_pointer | True type if T is a pointer to a free function |
| Cis_function_pointer< T, std::enable_if_t< std::is_function< typename std::remove_pointer< T >::type >::value > > | |
| Cis_future | Test if a type is a future |
| Cis_future< Future< T > > | |
| Cis_input_archive | Checks if T is an input archive type |
| Cis_input_archive< archive::BinaryFstreamInputArchive > | |
| Cis_input_archive< archive::BufferInputArchive > | |
| Cis_input_archive< archive::ContainerRecordInputArchive > | |
| Cis_input_archive< archive::MPIInputArchive > | |
| Cis_input_archive< archive::MPIRawInputArchive > | |
| Cis_input_archive< archive::ParallelInputArchive< localarchiveT > > | |
| Cis_input_archive< archive::TextFstreamInputArchive > | |
| Cis_input_archive< archive::VectorInputArchive > | |
| Cis_istreammable | |
| Cis_madness_function | |
| Cis_madness_function< madness::Function< T, NDIM > > | |
| Cis_madness_function_vector | |
| Cis_madness_function_vector< std::vector< typename madness::Function< T, NDIM > > > | |
| Cis_ostreammable | |
| Cis_output_archive | Checks if T is an output archive type |
| Cis_output_archive< archive::BinaryFstreamOutputArchive > | |
| Cis_output_archive< archive::BufferOutputArchive > | |
| Cis_output_archive< archive::ContainerRecordOutputArchive > | |
| Cis_output_archive< archive::MPIOutputArchive > | |
| Cis_output_archive< archive::MPIRawOutputArchive > | |
| Cis_output_archive< archive::ParallelOutputArchive< localarchiveT > > | |
| Cis_output_archive< archive::TextFstreamOutputArchive > | |
| Cis_output_archive< archive::VectorOutputArchive > | |
| Cis_scalar_result | |
| Cis_scalar_result< madness::ScalarResult< T > > | |
| Cis_scalar_result< madness::ScalarResultImpl< T > > | |
| Cis_scalar_result_impl | |
| Cis_scalar_result_ptr | |
| Cis_scalar_result_ptr< std::shared_ptr< madness::ScalarResultImpl< T > > > | |
| Cis_scalar_result_ptr_vector | |
| Cis_scalar_result_ptr_vector< std::vector< std::shared_ptr< typename madness::ScalarResultImpl< T > > > > | |
| Cis_scalar_result_vector | |
| Cis_scalar_result_vector< std::vector< typename madness::ScalarResult< T > > > | |
| Cis_serializable | |
| Cis_text_archive | This trait types tests if Archive is a text archive |
| Cis_text_archive< archive::TextFstreamInputArchive > | |
| Cis_text_archive< archive::TextFstreamOutputArchive > | |
| Cis_trivially_copyable | Trait for trivial (=bitwise) copyability of T, defaults to std::is_trivially_copyable<T> but can be specialized as needed |
| Cis_trivially_serializable | |
| Cis_tuple | |
| Cis_tuple< std::tuple< T... > > | |
| Cis_vector | |
| Cis_vector< std::vector< Q > > | |
| CIsSupported | |
| CIsSupported< TypeData, ReturnType, true > | |
| CKahanAccumulator | |
| CKahanAccumulator< Complex, std::enable_if_t<!std::is_floating_point_v< Complex > > > | Implements Kahan summation for complex numbers |
| CKahanAccumulator< Real, std::enable_if_t< std::is_floating_point_v< Real > > > | Implements Kahan summation for real numbers |
| ►CKernelRange | |
| CData | |
| CRestrictor | Restrictor function |
| CKey | Key is the index for a node of the 2^NDIM-tree |
| CKeyChildIterator | Iterates in lexical order thru all children of a key |
| CKinetic | |
| CKPoint | |
| CLaplacian | Laplacian operator: \sum_i \nabla^2_i |
| CLBCost | |
| Clbcost | |
| CLBDeuxPmap | |
| CLBNodeDeux | |
| Cleaf_op | |
| CLeaf_op | |
| CLeaf_op_other | |
| CLevelPmap | A pmap that locates children on odd levels with their even level parents |
| CLinAlgException | Linear algebra Exception |
| CLinearSlater | A nuclear correlation factor class |
| CLLRVDomainMask | Provides the Li-Lowengrub-Ratz-Voight (LLRV) domain mask characteristic functions |
| ►CLoadBalanceDeux | |
| Cadd_op | |
| CCostPerProc | |
| CLoadBalImpl | |
| CLocalizer | |
| CLocalPotentialOperator | |
| CLowDimIndexIterator | |
| CLowRankFunction | LowRankFunction represents a hi-dimensional (NDIM) function as a sum of products of low-dimensional (LDIM) functions |
| CLowRankFunctionFactory | |
| CLowRankFunctionParameters | |
| Clr_pot_functor | Functor for the 1/r potential to induce the correct asymptotic behaviour of the exchange correlation potential |
| CLRFunctorBase | Low-rank functor is what the LowRankFunction will represent |
| CLRFunctorF12 | |
| CLRFunctorPure | |
| CLz | Z component of the angular momentum |
| ►CMacroTask | |
| Cio_redirect | RAII class to redirect cout to a file |
| Cis_vector | |
| Cis_vector< std::vector< Q > > | |
| CMacroTaskInternal | |
| CMacroTaskBase | Base class |
| CMacroTaskComputeCorrelationEnergy | |
| ►CMacroTaskConstantPart | |
| CConstantPartPartitioner | |
| CMacroTaskIntermediate | |
| ►CMacroTaskIteratePair | |
| CIteratePairPartitioner | |
| ►CMacroTaskMp2ConstantPart | |
| CConstantPartPartitioner | |
| ►CMacroTaskMp2UpdatePair | |
| CUpdatePairPartitioner | |
| CMacroTaskOperationBase | |
| CMacroTaskPartitioner | Partition one (two) vectors into 1D (2D) batches |
| CMacroTaskQ | |
| CMacroTaskSinglesPotentialEx | |
| CMacroTaskSinglesPotentialGs | |
| CMadnessException | Base class for exceptions thrown in MADNESS |
| CMatrixInnerTask | |
| Cmax_of_x_1_smooth | |
| ►CMemoryMeasurer | Measure the memory usage of all FunctionImpl objects of all worlds |
| CMemInfo | |
| CMemKey | |
| Cmerging_operator | |
| Cmolecular_grid | Given a molecule, return a suitable grid |
| CMolecularCorePotentialFunctor | |
| CMolecularEnergy | |
| CMolecularOptimizationParameters | |
| CMolecularOptimizationTargetInterface | |
| CMolecularOptimizer | Molecular optimizer derived from the QuasiNewton optimizer |
| CMolecularOrbitals | |
| CMolecularPotentialFunctor | |
| ►CMolecule | |
| Capply_c2 | Apply to (x,y,z) a C2 rotation about an axis thru the origin and (xaxis,yaxis,zaxis) |
| Capply_inverse | |
| Capply_sigma | Apply to (x,y,z) a reflection through a plane containing the origin with normal (xaxis,yaxis,zaxis) |
| CGeometryParameters | |
| CMomentFunctor | A MADNESS functor to compute the cartesian moment x^i * y^j * z^k (i, j, k integer and >= 0) |
| ►CMP2 | Class for computing the first order wave function and MP2 pair energies |
| CPairs | POD holding all electron pairs with easy access |
| CParameters | POD for MP2 keywords |
| ►CMP3 | |
| ►CMacroTaskMP3 | Helper class for calculating the MP3 energy contributions |
| CPartitioner | |
| Cmul_leaf_op | |
| Cmunging_operator | |
| CMutex | Mutex using pthread mutex operations |
| CMutexFair | A scalable and fair mutex (not recursive) |
| CMutexReaderWriter | |
| CMutexWaiter | |
| CMyPmap | Procmap implemented using Tree of TreeCoords |
| CMyTimer | Timer structure |
| ►CNemo | The Nemo class |
| CNemoCalculationParameters | Class holding parameters for a nemo calculation beyond the standard dft parameters from moldft |
| CNemo_complex_Parameters | |
| CNemoBase | |
| CNonlinearSolverND | A simple Krylov-subspace nonlinear equation solver |
| CNonstandardIndexIterator | |
| Cnoop | |
| CNuclear | |
| ►CNuclearCorrelationFactor | ABC for the nuclear correlation factors |
| CR_functor | |
| CRX_functor | Compute the derivative of R wrt the displacement of atom A, coord axis |
| Csquare_times_V_derivative_functor | |
| Csquare_times_V_functor | |
| CU1_atomic_functor | U1 functor for a specific atom |
| CU1_dot_U1_functor | Functor for a local U1 dot U1 potential |
| CU1_functor | Functor for the local part of the U1 potential – NOTE THE SIGN |
| CU1X_functor | Compute the derivative of U1 wrt the displacement of atom A, coord axis |
| CU2_atomic_functor | U2 functor for a specific atom |
| CU2_functor | |
| CU2X_functor | Compute the derivative of U2 wrt the displacement of atom A |
| CU3_atomic_functor | U3 functor for a specific atom |
| CU3_functor | |
| CU3X_functor | Compute the derivative of U3 wrt the displacement of atom A, coord axis |
| CNuclearCuspyBox_op | |
| CNuclearDensityFunctor | Default functor for the nuclear charge density |
| COEP | |
| COEP_Parameters | |
| Cop_leaf_op | |
| COperator | A generic operator: takes in one T and produces another T |
| COperatorInfo | |
| COptimizationTargetInterface | The interface to be provided by functions to be optimized |
| COptimizerInterface | The interface to be provided by optimizers |
| COrbitalIterator | Iterates the third index for pair coupling |
| COuterProjector | Outer product of two projectors |
| CPairEnergies | POD structure for energies |
| CPairs | |
| CPairVectorMap | |
| CParametrizedExchange | |
| Cparticle | |
| CPCM | Interface class to the PCMSolver library |
| Cpermutation | Permutations in physisists notation: <ij | kl> = (ik | jl), loop over ik<jl |
| Cpg_operator | This class implements the symmetry operations (not the point groups) |
| CPlotParameters | |
| CPNO | |
| ►CPNOPairs | POD for PNO code |
| CMemInfo | |
| CPNOParameters | |
| Cpoly4erfc | |
| CPolynomial | A nuclear correlation factor class |
| ►CPoolTaskInterface | Lowest level task interface |
| CFunctionPointerGrabber | Object that is used to convert function and member function pointers into void* |
| CPoolTaskNull | A no-operation task used for various purposes |
| CPotentialManager | |
| Cprintleveler | |
| CProcessKey | Key object that includes the process information |
| CProfileStat | Simple container for parallel profile statistic |
| CProjector | Simple projector class |
| Cprojector_irrep | |
| CProjectorBase | |
| CProjRLMFunctor | |
| CProjRLMStore | |
| CPseudoNuclearCorrelationFactor | |
| CPthreadConditionVariable | Simple wrapper for Pthread condition variable with its own mutex |
| CQCCalculationParametersBase | Class for holding the parameters for calculation |
| CQCParameter | Structure holding the value for a given parameter |
| CQCPropertyInterface | Class implementing properties of QC models |
| Cqmsg | |
| CQProjector | Orthogonality projector |
| CQuasiNewton | Optimization via quasi-Newton (BFGS or SR1 update) |
| CR_times_arg_div_R | Compute the expression (\sum_i R_i)^(-1) \sum_i R_i arg(r,B,v_i) |
| CRandom | A random number generator (portable, vectorized, and thread-safe) |
| Crandomgrid | Grid with random points around the origin, with a Gaussian distribution |
| ►CRandomizedMatrixDecomposition | |
| CY_former | Functor for forming Y = matrix * randomvector |
| CRandomState | |
| CRange | Range, vaguely a la Intel TBB, to encapsulate a random-access, STL-like start and end iterator with chunksize |
| Creal_op | |
| CRecordlist | |
| CRecursiveMutex | Recursive mutex using pthread mutex operations |
| CRemoteReference | Simple structure used to manage references/pointers to remote instances |
| Cremove_fcvr | |
| Cremove_future | Maps Future<T> to T |
| Cremove_future< const Future< T > & > | |
| Cremove_future< const Future< T > > | |
| Cremove_future< Future< T > & > | |
| Cremove_future< Future< T > && > | |
| Cremove_future< Future< T > > | This metafunction maps Future<T> to T |
| Cresponse_function_allocator | |
| Cresponse_matrix_allocator | |
| Cresponse_space | |
| CResponseParameters | |
| CRMDFactory | Simple factory pattern for the RandomizedMatrixDecomposition |
| ►CRMI | This class implements the communications server thread and provides the only send interface |
| ►CRmiTask | |
| Cheader | |
| CRMISendReq | This for RMI server thread to manage lifetime of WorldAM messages that it is sending |
| CRMIStats | |
| CSAPFunctor | SAPFunctor = Interpolated Atomic Potential for 1 atom |
| CScalarResult | |
| CScalarResultImpl | Helper class for returning the result of a task, which is not a madness Function, but a simple scalar |
| CScalingFunctionFunctor | This FunctionFunctorInterface evaluates Legendre scaling functions |
| CScalingFunctionFunctor< 1 > | |
| CScalingFunctionFunctor< NDIM, std::enable_if_t< std::greater{}(NDIM, 1)> > | |
| CSCF | |
| Cscf_data | |
| CSCFOperatorBase | |
| CSCFProtocol | Struct for running a protocol of subsequently tightening precision |
| CScopedMutex | Mutex that is applied/released at start/end of a scope |
| CSDFBox | A box (3 dimensions) |
| CSDFCircle | A circle (2 dimensions) |
| CSDFCone | A cone (3 dimensions) |
| CSDFCube | A cube (3 dimensions) |
| CSDFCylinder | A cylinder (3 dimensions) |
| CSDFEllipsoid | An ellipsoid (3 dimensions) |
| CSDFParaboloid | A paraboloid (3 dimensions) |
| CSDFPlane | A plane surface (3 dimensions) |
| CSDFRectangle | A rectangle (2 dimensions) |
| CSDFSphere | A spherical surface (3 dimensions) |
| ►CSeparatedConvolution | Convolutions in separated form (including Gaussian) |
| CApplyTerms | Laziness for calling lists: which terms to apply |
| CTransformation | Too lazy for extended calling lists |
| CSeparatedConvolutionData | SeparatedConvolutionData keeps data for all terms, all dimensions |
| CSeparatedConvolutionInternal | |
| CShallowNode | Shallow-copy, pared-down version of FunctionNode, for special purpose only |
| CSignedDFInterface | The interface for a signed distance function (sdf) |
| CSimpleCache | Simplified interface around hash_map to cache stuff for 1D |
| CSimplePmap | A simple process map |
| CSlater | A nuclear correlation factor class |
| Cslater_kernel | |
| Cslater_kernel_apply | |
| CSlaterF12Interface | Function like f(x) = (1 - exp(-mu x))/(2 gamma) |
| CSlaterFunctionInterface | Function like f(x)=exp(-mu x) |
| CSlice | A slice defines a sub-range or patch of a dimension |
| CSliceGenTensor | |
| CSliceLowRankTensor | Implements a temporary(!) slice of a LowRankTensor |
| CSliceTensor | Indexing a non-constant tensor with slices returns a SliceTensor |
| ►Csmooth | |
| Cinv_mask_functor | |
| Cmask_functor | |
| ►CSolver | The main class of the periodic DFT solver |
| CGuessDensity | |
| CSolverTargetInterface | The interface to be provided by targets for non-linear equation solver |
| CSpecialbox_op | |
| CSpectralPropagator | Spectral propagtor in time. Refer to documentation of file spectralprop.h for math detail |
| CSpectralPropagatorGaussLobatto | |
| Cspherical_box | 2-dimensional smooth mask that is 1 inside the radius and 0 outside |
| CSpinlock | Spinlock using pthread spinlock operations |
| CSRConf | |
| CStack | Dynamically sized Stack with small stack size optimization |
| CSteepestDescent | Unconstrained minimization via steepest descent |
| CStrongOrthogonalityProjector | SO projector class |
| CSubspace | The SubspaceK class is a container class holding previous orbitals and residuals |
| CSubspaceK | The SubspaceK class is a container class holding previous orbitals and residuals |
| CSVDTensor | |
| CSystolicFixOrbitalOrders | |
| CSystolicMatrixAlgorithm | Base class for parallel algorithms that employ a systolic loop to generate all row pairs in parallel |
| CSystolicPMOrbitalLocalize | |
| CTaggedKey | Key object that uses a tag to differentiate keys |
| CTaskAttributes | Contains attributes of a task |
| CTaskFn | Wrap a callable object and its arguments into a task function |
| CTaskFunction | |
| ►CTaskInterface | All world tasks must be derived from this public interface |
| CSubmit | |
| CTaskMemfun | |
| CTaskThreadEnv | Used to pass information about the thread environment to a user's task |
| ►CTDHF | |
| CTDHFParameters | TDHF parameter class |
| CTDHF_allocator | |
| CTensor | A tensor is a multidimensional array |
| CTensorArgs | TensorArgs holds the arguments for creating a LowRankTensor |
| CTensorException | Tensor is intended to throw only TensorExceptions |
| CTensorIterator | |
| CTensorResultType | TensorResultType<L,R>::type is the type of (L op R) where op is nominally multiplication |
| CTensorTrain | |
| CTensorTypeData | Traits class to specify support of numeric types |
| CTensorTypeFromId | This provides the reverse mapping from integer id to type name |
| Ctest_output | Small class for pretty printing of test output |
| CThread | Simplified thread wrapper to hide pthread complexity |
| CThreadBase | Simplified thread wrapper to hide pthread complexity |
| CThreadBinder | |
| CThreadPool | A singleton pool of threads for dynamic execution of tasks |
| CThreadPoolThread | ThreadPool thread object |
| Ctimer | |
| CTimer | |
| Ctrajectory | |
| Ctrue_op | |
| CTwoBodyFunctionComponentBase | |
| CTwoBodyFunctionPureComponent | Two-body, explicitly 6-dimensional function |
| CTwoBodyFunctionSeparatedComponent | |
| CTwoElectronFactory | Factory for generating TwoElectronInterfaces |
| CTwoElectronInterface | Base class to compute the wavelet coefficients for an isotropic 2e-operator |
| Ctwoscale_cache_class | |
| Cunaryexp | |
| CUnaryOpStructure | Computes the corrected exchange correlation potential using the multipole approximation |
| CuniqueidT | Class for unique global IDs |
| Cvalarray_allocator | |
| CVector | A simple, fixed dimension vector |
| Cvector_function_allocator | |
| CVectorOfFunctionsSpace | A vector space using MADNESS Vectors of MADNESS Functions |
| CVectorSpace | A vector space using MADNESS Vectors |
| CVLocalFunctor | |
| CWignerSeitzPotentialFunctor | Evaluates Wigner-Seitz-truncated potential in the simulation cell, due to periodic or nonperiodic source functions |
| ►CWorld | A parallel world class |
| ChashuniqueT | |
| Chashvoidp | |
| CMpiRequestTester | |
| CWorldAbsMaxOp | |
| CWorldAbsMinOp | |
| ►CWorldAmInterface | Implements AM interface |
| CSendReq | |
| CWorldBitAndOp | |
| CWorldBitOrOp | |
| CWorldBitXorOp | |
| CWorldContainer | Makes a distributed container with specified attributes |
| ►CWorldContainerImpl | Internal implementation of distributed container to facilitate shallow copy |
| CP2Op | |
| CWorldContainerIterator | Iterator for distributed container wraps the local iterator |
| CWorldDCDefaultPmap | Default process map is "random" using madness::hash(key) |
| CWorldDCLocalPmap | Local process map will always return the current process as owner |
| CWorldDCPmapInterface | Interface to be provided by any process map |
| CWorldDCRedistributeInterface | |
| ►CWorldGopInterface | Provides collectives that interoperate with the AM and task interfaces |
| CAllReduceTag | |
| CBcastTag | |
| CDelayedSend | Delayed send callback object |
| CGroupAllReduceTag | |
| CGroupBcastTag | |
| CGroupLazySyncTag | |
| CGroupReduceTag | |
| CLazySyncTag | |
| CPointToPointTag | |
| CReduceTag | |
| CWorldLogicAndOp | |
| CWorldLogicOrOp | |
| CWorldMaxOp | |
| CWorldMemInfo | Used to output memory statistics and control tracing, etc |
| CWorldMinOp | |
| CWorldMpiInterface | This class wraps/extends the MPI interface for World |
| CWorldMultOp | |
| CWorldObject | Implements most parts of a globally addressable object (via unique ID) |
| CWorldObjectBase | Base class for WorldObject, useful for introspection |
| CWorldProfile | Singleton-like class for holding profiling data and functionality |
| CWorldProfileEntry | Used to store profiler info |
| CWorldProfileObj | |
| CWorldSumOp | |
| ►CWorldTaskQueue | Multi-threaded queue to manage and run tasks |
| CProbeAllDone | |
| Cwrite_test_input | Will write a test input and remove it from disk upon destruction |
| CWSTAtomicBasisFunctor | |
| CX_space | |
| CX_vector | |
| Cxc_functional | Class to compute the energy functional |
| Cxc_kernel_apply | Class to compute terms of the kernel |
| Cxc_lda_potential | Compute the spin-restricted LDA potential using unaryop (only for the initial guess) |
| Cxc_potential | Class to compute terms of the potential |
| CXCfunctional | Simplified interface to XC functionals |
| CXCFunctionalLDA | |
| ►CXCOperator | Operator class for the handling of DFT exchange-correlation functionals |
| ►Cexpme | Simple structure to take the pointwise exponential of a function, shifted by +14 |
| Cexpme1 | |
| ►Clogme | Simple structure to take the pointwise logarithm of a function, shifted by +14 |
| Clogme1 | |
| CXNonlinearSolver | Generalized version of NonlinearSolver not limited to a single madness function |
| ►CZcis | |
| Croot | |
| ►CZnemo | |
| Clandau_wave_function | Following Doucot Pascier 2005 |
| Cp_orbital | |
| Cpotentials | |
| Cs_orbital | |
| Ctimer | |
| ►Nmolresponse | |
| Cwrite_response_input | Will write a test input and remove it from disk upon destruction |
| Cwrite_test_input | Will write a test input and remove it from disk upon destruction |
| ►NPNOTensors | |
| CTensor_IJ_IK | |
| CTensor_IJ_KJ | |
| ►NSafeMPI | |
| Ndetail | |
| CException | SafeMPI exception object |
| ►CGroup | |
| CImpl | |
| ►CIntracomm | Wrapper around MPI_Comm. Has a shallow copy constructor; use Create(Get_group()) for deep copy |
| CImpl | |
| CWorldInitObject | |
| CRequest | |
| CStatus | |
| ►Nslymer | |
| NProperties | |
| CAtom | An atom (symbol and position) |
| CBasisFunction | Abstract base class for generic basis functions |
| CBasisShell | Store information on a shell of basis functions as it's being read |
| CES_Interface | Abstract base class for interfacing with electronic structure codes |
| CGaussian_Functor | |
| CGaussianFunction | A Gaussian basis function used by chemistry electronic structure codes |
| CNWChem_Interface | Class for interfacing with NWChem (tested on version 6.6) |
| CPolynomialCoeffs | Array for storing coefficients of a polynomial of three variables with specified degree |
| CPrimitiveGaussian | A primitive Gaussian function |
| Nstd | |
