| Cmadness::operators::__x | |
| CA | |
| CA_omega | Computes term k at quadrature point t in infinte Fourier-space sum defining A |
| Cmadness::abs_op< Q, NDIM > | |
| Cmadness::abs_square_op< Q, NDIM > | |
| Cmadness::detail::absinplace< T, NDIM > | |
| Cmadness::detail::absop< NDIM > | |
| Cmadness::detail::abssqop< NDIM > | |
| Cmadness::detail::abssquareinplace< T, NDIM > | |
| Cmadness::AbstractVectorSpace< T, real_type, scalar_type > | A generic vector space which provides common operations needed by linear algebra routines (norm, inner product, etc.) |
| ►Cmadness::AbstractVectorSpace< Function< T, NDIM >, TensorTypeData< T >::float_scalar_type, T > | |
| Cmadness::FunctionSpace< T, NDIM > | A vector space using MADNESS Functions |
| ►Cmadness::AbstractVectorSpace< Vector< Function< T, FDIM >, VDIM >, TensorTypeData< T >::float_scalar_type, T > | |
| Cmadness::VectorOfFunctionsSpace< T, VDIM, FDIM > | A vector space using MADNESS Vectors of MADNESS Functions |
| ►Cmadness::AbstractVectorSpace< Vector< T, NDIM >, TensorTypeData< T >::float_scalar_type, T > | |
| Cmadness::VectorSpace< T, NDIM > | A vector space using MADNESS Vectors |
| Cmadness::AC< NDIM > | |
| Cmadness::AC< 3 > | |
| Cmadness::accumulate_op< T, NDIM > | Inserts/accumulates coefficients into impl's tree |
| Cmadness::ACParameters< NDIM > | Contains all the parameters for the asymptotic correction |
| Cmadness::add_future< T > | Maps type T to Future<T> |
| Cmadness::add_future< Future< T > > | Maps Future<T> to Future<T> |
| Cmadness::FunctionImpl< T, NDIM >::add_op | Add two functions f and g: result=alpha * f + beta * g |
| Cmadness::LoadBalanceDeux< NDIM >::add_op< T, costT > | |
| Cmadness::detail::adqtest | |
| Callocator | |
| Cmadness::WorldGopInterface::AllReduceTag | |
| Cmadness::AmArg | World active message that extends an RMI message |
| CAtomicBasisSet::AnalysisSorter< T > | |
| Cmadness::AtomicBasisSet::AnalysisSorter< T > | |
| ►CAnsatzBase | |
| CAnsatz0 | |
| CAPbar_omega | Computes term k at quadrature point t in infinte Fourier-space sum defining APbar |
| Cmadness::Molecule::apply_c2 | Apply to (x,y,z) a C2 rotation about an axis thru the origin and (xaxis,yaxis,zaxis) |
| Cmadness::Molecule::apply_inverse | |
| Cmadness::apply_kernel_helper | |
| Cmadness::Molecule::apply_sigma | Apply to (x,y,z) a reflection through a plane containing the origin with normal (xaxis,yaxis,zaxis) |
| Cmadness::SeparatedConvolution< Q, NDIM >::ApplyTerms | Laziness for calling lists: which terms to apply |
| Cmadness::archive::archive_array< T > | Wrapper for dynamic arrays and pointers |
| Cmadness::archive::archive_ptr< T > | Wrapper for an opaque pointer for serialization purposes |
| Cmadness::archive::archive_typeinfo< T > | Used to enable type checking inside archives |
| Cmadness::archive::ArchiveImpl< Archive, T, Enabler > | Default implementations of wrap_store and wrap_load |
| Cmadness::archive::ArchiveImpl< Archive, archive_array< T > > | Partial specialization of ArchiveImpl for archive_array |
| Cmadness::archive::ArchiveImpl< 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 |
| Cmadness::archive::ArchiveImpl< ParallelInputArchive< localarchiveT >, archive_array< T > > | Read the archive array and broadcast |
| Cmadness::archive::ArchiveImpl< ParallelInputArchive< localarchiveT >, T > | Specialization of ArchiveImpl for parallel input archives |
| Cmadness::archive::ArchiveImpl< ParallelInputArchive< localarchiveT >, T[n]> | Forward a fixed-size array to archive_array |
| Cmadness::archive::ArchiveImpl< ParallelOutputArchive< localarchiveT >, archive_array< T > > | Write the archive array only from process zero |
| Cmadness::archive::ArchiveImpl< ParallelOutputArchive< localarchiveT >, T > | Specialization of ArchiveImpl for parallel output archives |
| Cmadness::archive::ArchiveImpl< ParallelOutputArchive< localarchiveT >, T[n]> | Forward a fixed-size array to archive_array |
| Cmadness::archive::ArchiveLoadImpl< Archive, T, Enabler > | Default load of an object via serialize(ar, t) |
| Cmadness::archive::ArchiveLoadImpl< Archive, C > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, const DerivativeBase< T, NDIM > * > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, const FunctionImpl< T, NDIM > * > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, const SeparatedConvolution< T, NDIM > * > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, detail::RemoteCounter > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, detail::WorldPtr< T > > | Specialization of ArchiveLoadImpl for world pointers |
| Cmadness::archive::ArchiveLoadImpl< Archive, FunctionImpl< T, NDIM > * > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, Future< T >, std::enable_if_t<!std::is_void_v< T > > > | Deserialize a future into an unassigned future |
| Cmadness::archive::ArchiveLoadImpl< Archive, Future< void > > | Deserialize a future into an unassigned future (void specialization) |
| Cmadness::archive::ArchiveLoadImpl< Archive, GenTensor< T > > | Deserialize a tensor ... existing tensor is replaced |
| Cmadness::archive::ArchiveLoadImpl< Archive, Key< NDIM > > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, linked_list > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::allocator< T >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Deserialize a std::allocator |
| Cmadness::archive::ArchiveLoadImpl< 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 |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::complex< T >, std::enable_if_t< is_serializable_v< Archive, T > > > | Deserialize a complex number |
| Cmadness::archive::ArchiveLoadImpl< 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 |
| Cmadness::archive::ArchiveLoadImpl< 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 |
| Cmadness::archive::ArchiveLoadImpl< 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 |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::shared_ptr< const FunctionImpl< T, NDIM > > > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::shared_ptr< FunctionImpl< T, NDIM > > > | |
| Cmadness::madness::archive::ArchiveLoadImpl< Archive, std::shared_ptr< ScalarResultImpl< T > > > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::string > | Deserialize a std::string. Clears and resizes as necessary |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::vector< bool, Alloc > > | Deserialize a std::vector<bool>. Clears and resizes as necessary |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::vector< Future< T > > > | Deserialize a vector of futures into a vector of unassigned futures |
| Cmadness::archive::ArchiveLoadImpl< 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 |
| Cmadness::archive::ArchiveLoadImpl< Archive, Tensor< T > > | Deserialize a tensor ... existing tensor is replaced |
| Cmadness::archive::ArchiveLoadImpl< Archive, World * > | Specialization of ArchiveLoadImpl for World pointers |
| Cmadness::archive::ArchiveLoadImpl< BinaryFstreamInputArchive, Key< NDIM > > | |
| Cmadness::archive::ArchiveLoadImpl< BufferInputArchive, const WorldObject< Derived > * > | Specialization of ArchiveLoadImpl for constant, globally-addressable objects |
| Cmadness::archive::ArchiveLoadImpl< BufferInputArchive, WorldObject< Derived > * > | Specialization of ArchiveLoadImpl for globally-addressable objects |
| Cmadness::archive::ArchiveLoadImpl< ParallelInputArchive< archiveT >, CCPairFunction< T, NDIM > > | |
| Cmadness::archive::ArchiveLoadImpl< ParallelInputArchive< archiveT >, Function< T, NDIM > > | |
| Cmadness::archive::ArchiveLoadImpl< ParallelInputArchive< localarchiveT >, WorldContainer< keyT, valueT > > | |
| Cmadness::archive::ArchivePrePostImpl< Archive, T > | Default implementation of the pre/postamble for type checking |
| Cmadness::archive::ArchivePrePostImpl< BufferInputArchive, T > | Implement pre/postamble load routines for a BufferInputArchive |
| Cmadness::archive::ArchivePrePostImpl< BufferOutputArchive, T > | Implement pre/postamble storage routines for a BufferOutputArchive |
| Cmadness::archive::ArchivePrePostImpl< ContainerRecordInputArchive, T > | Implementation of functions for loading the pre/postamble in ContainerRecord archives |
| Cmadness::archive::ArchivePrePostImpl< ContainerRecordOutputArchive, T > | Implementation of functions for storing the pre/postamble in ContainerRecord archives |
| Cmadness::archive::ArchivePrePostImpl< MPIInputArchive, T > | Implementation of functions for loading the pre/postamble in MPI archives |
| Cmadness::archive::ArchivePrePostImpl< MPIOutputArchive, T > | Implementation of functions for storing the pre/postamble in MPI archives |
| Cmadness::archive::ArchivePrePostImpl< MPIRawInputArchive, T > | Implementation of functions for loading the pre/postamble in MPI archives |
| Cmadness::archive::ArchivePrePostImpl< MPIRawOutputArchive, T > | Implementation of functions for storing the pre/postamble in MPI archives |
| Cmadness::archive::ArchivePrePostImpl< ParallelInputArchive< localarchiveT >, T > | Disable type info for parallel input archives |
| Cmadness::archive::ArchivePrePostImpl< ParallelOutputArchive< localarchiveT >, T > | Disable type info for parallel output archives |
| Cmadness::archive::ArchivePrePostImpl< TextFstreamInputArchive, T > | Implement pre/postamble load routines for a TextFstreamInputArchive |
| Cmadness::archive::ArchivePrePostImpl< TextFstreamOutputArchive, T > | Implement pre/postamble storage routines for a TextFstreamOutputArchive |
| Cmadness::archive::ArchivePrePostImpl< VectorInputArchive, T > | Implementation of functions for loading the pre/postamble in Vector archives |
| Cmadness::archive::ArchivePrePostImpl< VectorOutputArchive, T > | Implementation of functions for storing the pre/postamble in Vector archives |
| Cmadness::archive::ArchiveSerializeImpl< Archive, T, Enabler > | Default symmetric serialization of a non-fundamental type that has serialize method |
| Cmadness::archive::ArchiveSerializeImpl< Archive, B > | |
| Cmadness::archive::ArchiveSerializeImpl< Archive, Key > | |
| Cmadness::archive::ArchiveSerializeImpl< Archive, resT(*)(paramT...), std::enable_if_t<!is_default_serializable_v< Archive, resT(*)(paramT...)> > > | Serialize a function pointer |
| Cmadness::archive::ArchiveSerializeImpl< Archive, resT(objT::*)(paramT...) const, std::enable_if_t<!is_default_serializable_v< Archive, resT(objT::*)(paramT...) const > > > | Serialize a const member function pointer |
| Cmadness::archive::ArchiveSerializeImpl< Archive, resT(objT::*)(paramT...), std::enable_if_t<!is_default_serializable_v< Archive, resT(objT::*)(paramT...)> > > | Serialize a member function pointer |
| Cmadness::archive::ArchiveSerializeImpl< Archive, std::optional< T >, std::enable_if_t< is_serializable_v< Archive, T > > > | Serialize (deserialize) an std::optional |
| Cmadness::archive::ArchiveSerializeImpl< Archive, std::pair< T, Q >, std::enable_if_t< is_serializable_v< Archive, T > &&is_serializable_v< Archive, Q > > > | Serialize (deserialize) an std::pair |
| Cmadness::archive::ArchiveSerializeImpl< Archive, std::tuple< Types... >, std::enable_if_t<(is_serializable_v< Archive, Types > &&...) > > | Serialize (deserialize) a std::tuple |
| Cmadness::archive::ArchiveStoreImpl< Archive, T, Enabler > | Default store of an object via serialize(ar, t) |
| Cmadness::archive::ArchiveStoreImpl< Archive, C > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, const DerivativeBase< T, NDIM > * > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, const FunctionImpl< T, NDIM > * > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, const SeparatedConvolution< T, NDIM > * > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, detail::RemoteCounter > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, detail::WorldPtr< T > > | Specialization of ArchiveStoreImpl for world pointers |
| Cmadness::archive::ArchiveStoreImpl< Archive, FunctionImpl< T, NDIM > * > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, Future< T >, std::enable_if_t<!std::is_void_v< T > > > | Serialize an assigned future |
| Cmadness::archive::ArchiveStoreImpl< Archive, Future< void > > | Serialize an assigned future (void specialization) |
| Cmadness::archive::ArchiveStoreImpl< Archive, GenTensor< T > > | Serialize a tensor |
| Cmadness::archive::ArchiveStoreImpl< Archive, Key< NDIM > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, linked_list > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::allocator< T >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Serialize a std::allocator |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::array< T, N >, std::enable_if_t< is_serializable_v< Archive, T > > > | Serialize a std::array |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::complex< T >, std::enable_if_t< is_serializable_v< Archive, T > > > | Serialize a complex number |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::list< T, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Serialize a std::list |
| Cmadness::archive::ArchiveStoreImpl< 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 |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::set< T, Compare, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Serialize a std::set |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::shared_ptr< const FunctionImpl< T, NDIM > > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::shared_ptr< FunctionImpl< T, NDIM > > > | |
| Cmadness::madness::archive::ArchiveStoreImpl< Archive, std::shared_ptr< ScalarResultImpl< T > > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::string > | Serialize a 'std::string' |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::vector< bool, Alloc > > | Serialize a std::vector<bool> (as a plain array of bool) |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::vector< Future< T > > > | Serialize a vector of assigned futures |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::vector< T, Alloc >, std::enable_if_t<!is_future< T >::value &&is_serializable_v< Archive, T > > > | Serialize a std::vector |
| Cmadness::archive::ArchiveStoreImpl< Archive, Tensor< T > > | Serialize a tensor |
| Cmadness::archive::ArchiveStoreImpl< Archive, World * > | Specialization of ArchiveStoreImpl for World pointers |
| Cmadness::archive::ArchiveStoreImpl< BufferOutputArchive, const WorldObject< Derived > * > | Specialization of ArchiveStoreImpl for constant, globally-addressable objects |
| Cmadness::archive::ArchiveStoreImpl< BufferOutputArchive, WorldObject< Derived > * > | Specialization of ArchiveStoreImpl for globally-addressable objects |
| Cmadness::archive::ArchiveStoreImpl< ParallelOutputArchive< archiveT >, CCPairFunction< T, NDIM > > | |
| Cmadness::archive::ArchiveStoreImpl< ParallelOutputArchive< archiveT >, Function< T, NDIM > > | |
| Cmadness::archive::ArchiveStoreImpl< ParallelOutputArchive< ContainerRecordOutputArchive >, WorldContainer< keyT, valueT > > | |
| Cmadness::archive::ArchiveStoreImpl< ParallelOutputArchive< localarchiveT >, WorldContainer< keyT, valueT > > | Write container to parallel archive with optional fence |
| Cmadness::archive::ArchiveStoreImpl< ParallelOutputArchive< VectorOutputArchive >, WorldContainer< keyT, valueT > > | Write container to parallel archive |
| Cmadness::detail::ArgCountHelper< T > | |
| Cmadness::detail::ArgCountHelper< void > | |
| ►Cstd::array | |
| Cmadness::array_of_bools< NDIM > | |
| Cmadness::array_of_bools< N > | Syntactic sugar for std::array<bool, N> |
| Cmadness::asymptotic_density | |
| Cmadness::asymptotic_slater_kernel | |
| CAtom | |
| Cmadness::Atom | |
| Cslymer::Atom | An atom (symbol and position) |
| Cmadness::atom_information< NDIM > | Needed information about atom to compute asymptotic correction |
| Cmadness::AtomCore | |
| CAtomicBasis | Represents multiple shells of contracted gaussians on a single center |
| Cmadness::AtomicBasis | Represents multiple shells of contracted gaussians on a single center |
| CAtomicBasisFunction | Used to represent one basis function from a shell on a specific center |
| Cmadness::AtomicBasisFunction | Used to represent one basis function from a shell on a specific center |
| CAtomicBasisSet | Contracted Gaussian basis |
| Cmadness::AtomicBasisSet | Contracted Gaussian basis |
| CAtomicData | |
| Cmadness::AtomicData | |
| Cmadness::AtomicInt | An integer with atomic set, get, read+increment, read+decrement, and decrement+test operations |
| Cmadness::Function< T, NDIM >::autorefine_square_op | |
| CB | |
| ►CB1 | |
| Cmadness::meta::conjunction< B1 > | |
| Cmadness::meta::disjunction< B1 > | |
| Cmadness::BandlimitedPropagator | Class to evaluate the filtered Schrodinger free-particle propagator in real space |
| Cmadness::Barrier | |
| ►Cmadness::archive::BaseArchive | Base class for all archive classes |
| ►Cmadness::archive::BaseInputArchive | Base class for input archive classes |
| Cmadness::archive::BinaryFstreamInputArchive | Wraps an archive around a binary filestream for input |
| Cmadness::archive::BufferInputArchive | Wraps an archive around a memory buffer for input |
| Cmadness::archive::ContainerRecordInputArchive | |
| Cmadness::archive::MPIInputArchive | Archive allowing buffering, deserialization of data, and point-to-point communication between processes with MPI |
| Cmadness::archive::MPIRawInputArchive | Archive allowing deserialization and point-to-point communication between processes with MPI |
| Cmadness::archive::ParallelInputArchive< localarchiveT > | An archive for storing local or parallel data, wrapping a BinaryFstreamInputArchive |
| Cmadness::archive::TextFstreamInputArchive | Wraps an archive around a text filestream for input |
| Cmadness::archive::VectorInputArchive | Wraps an archive around an STL vector for input |
| ►Cmadness::archive::BaseOutputArchive | Base class for output archive classes |
| Cmadness::archive::BinaryFstreamOutputArchive | Wraps an archive around a binary filestream for output |
| Cmadness::archive::BufferOutputArchive | Wraps an archive around a memory buffer for output |
| Cmadness::archive::ContainerRecordOutputArchive | |
| Cmadness::archive::MPIOutputArchive | Archive allowing buffering, serialization of data, and point-to-point communication between processes with MPI |
| Cmadness::archive::MPIRawOutputArchive | Archive allowing serialization and point-to-point communication between processes with MPI |
| Cmadness::archive::ParallelOutputArchive< localarchiveT > | An archive for storing local or parallel data wrapping a BinaryFstreamOutputArchive |
| Cmadness::archive::TextFstreamOutputArchive | Wraps an archive around a text filestream for output |
| Cmadness::archive::VectorOutputArchive | Wraps an archive around an STL vector for output |
| ►Cmadness::archive::BaseParallelArchive< Archive > | Base class for input and output parallel archives |
| Cmadness::archive::ParallelInputArchive< localarchiveT > | An archive for storing local or parallel data, wrapping a BinaryFstreamInputArchive |
| Cmadness::archive::ParallelOutputArchive< localarchiveT > | An archive for storing local or parallel data wrapping a BinaryFstreamOutputArchive |
| Cmadness::archive::BaseParallelArchive< BinaryFstreamInputArchive > | |
| Cmadness::archive::BaseParallelArchive< BinaryFstreamOutputArchive > | |
| ►Cmadness::BaseTensor | The base class for tensors defines generic capabilities |
| Cmadness::Tensor< double > | |
| Cmadness::Tensor< Q > | |
| Cmadness::Tensor< typename madness::Tensor< Q >::scalar_type > | |
| Cmadness::Tensor< TENSOR_RESULT_TYPE(T, R)> | |
| Cmadness::Tensor< ProcessID > | |
| Cmadness::Tensor< int > | |
| Cmadness::Tensor< typename madness::Tensor< T >::scalar_type > | |
| Cmadness::Tensor< valueT > | |
| ►Cmadness::SRConf< T > | |
| Cmadness::SVDTensor< T > | |
| ►Cmadness::Tensor< T > | A tensor is a multidimensional array |
| ►Cmadness::GenTensor< T > | |
| Cmadness::SliceLowRankTensor< T > | Implements a temporary(!) slice of a LowRankTensor |
| Cmadness::SliceTensor< T > | Indexing a non-constant tensor with slices returns a SliceTensor |
| Cmadness::TensorTrain< T > | |
| ►Cslymer::BasisFunction | Abstract base class for generic basis functions |
| Cslymer::GaussianFunction | A Gaussian basis function used by chemistry electronic structure codes |
| Cmadness::BasisFunctions | |
| Cslymer::BasisShell | Store information on a shell of basis functions as it's being read |
| Cmadness::Batch | Batch consists of a 2D-input batch and a 1D-output batch: K-batch <- (I-batch, J-batch) |
| Cmadness::Batch_1D | |
| Cmadness::WorldGopInterface::BcastTag | |
| ►Cstd::binary_function | |
| CvectorLengthFunctor | |
| Cmadness::BinaryOpStructure< NDIM > | Computes the corrected exchange correlation potential using the hartree potential |
| ►Cstd::bool_constant | |
| Cmadness::is_serializable< Archive, T > | |
| CSurfaceMoleculeInteraction::Bop | |
| Cmadness::BoundaryConditions< NDIM > | This class is used to specify boundary conditions for all operators |
| Cmadness::BoundaryConditions< 3 > | |
| Cmadness::BoundaryConditions< 6 > | |
| Cmadness::BoxSurfaceDisplacementFilter< NDIM > | |
| Cmadness::BoxSurfaceDisplacementRange< NDIM > | |
| CBoysLocalization | |
| Cmadness::BSHApply< T, NDIM > | Apply the BSH operator on a vector of functions with corresponding potentials |
| CC | |
| ►Cmadness::detail::DistCache< keyT >::Cache | Cache interface class |
| Cmadness::detail::DistCache< keyT >::CacheData< valueT > | Cache value container |
| CCalcParams | |
| CCalculation | |
| CCalculationParameters | |
| Cmadness::detail::callable_enabler< callableT, Enabler > | |
| Cmadness::detail::callable_enabler< callableT, std::enable_if_t< callable_traits< callableT >::value > > | |
| Cmadness::detail::callable_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 |
| ►Cmadness::CallbackInterface | The class used for callbacks (e.g., dependency tracking) |
| ►Cmadness::DependencyInterface | Provides an interface for tracking dependencies |
| Cmadness::Future< std::vector< Future< T > > > | Specialization of Future for a vector of Futures |
| ►Cmadness::TaskInterface | All world tasks must be derived from this public interface |
| ►Cmadness::SystolicMatrixAlgorithm< double > | |
| Cmadness::SystolicFixOrbitalOrders | |
| Cmadness::SystolicPMOrbitalLocalize | |
| CTask | |
| CTestBarrier | |
| CTestTask | |
| CTimeBarrier | |
| Cmadness::MatrixInnerTask< T, R, NDIM > | |
| ►Cmadness::SystolicMatrixAlgorithm< T > | Base class for parallel algorithms that employ a systolic loop to generate all row pairs in parallel |
| CTestSystolicMatrixAlgorithm< T > | |
| Cmadness::TaskFn< fnT, arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T > | Wrap a callable object and its arguments into a task function |
| Cmadness::detail::ForEachRootTask< rangeT, opT > | Apply an operation to a range of iterators |
| Cmadness::TaskInterface::Submit | |
| Cmadness::WorldGopInterface::DelayedSend< keyT, valueT > | Delayed send callback object |
| Cmadness::WorldTaskQueue | Multi-threaded queue to manage and run tasks |
| Cmadness::cartesian_grid< NDIM > | |
| Cmadness::CCConvolutionOperator< T, NDIM > | |
| Cmadness::CCIntermediatePotentials | Little helper structure which manages the stored singles potentials |
| Cmadness::CCMessenger | |
| Cmadness::CCPairBuilder | Build an MP2 or CC2 or LRCC2 etc pair, possibly including the lo-rank parts |
| Cmadness::CCSize | Print accumulated size of all functions |
| Cmadness::CCTimer | Timer Structure |
| CCFFT | |
| Cmadness::charactertable | |
| Cmadness::CISData | POD for CIS excitation |
| Cmadness::Cloud | Cloud class |
| Cmadness::Cloud::cloudtimer | |
| Cmadness::FunctionImpl< T, NDIM >::coeff_value_adaptor< Q, opT > | |
| Cmadness::CoeffTracker< T, NDIM > | Class to track where relevant (parent) coeffs are |
| Cmadness::CoeffTracker< T, LDIM > | |
| Cmadness::commandlineparser | Very simple command line parser |
| Cmadness::ConcurrentHashMap< keyT, valueT, hashfunT > | |
| Cmadness::ConcurrentHashMap< hashT, std::shared_ptr< madness::GaussianConvolution1D< Q > > > | |
| Cmadness::ConcurrentHashMap< int, double > | |
| Cmadness::ConcurrentHashMap< Key< NDIM >, madness::ConvolutionData1D< Q > > | |
| Cmadness::ConcurrentHashMap< Key< NDIM >, madness::SeparatedConvolutionData< double, NDIM > > | |
| Cmadness::ConcurrentHashMap< Key< NDIM >, madness::SeparatedConvolutionData< Q, NDIM > > | |
| Cmadness::ConcurrentHashMap< Key< NDIM >, madness::SeparatedConvolutionData< T, NDIM > > | |
| Cmadness::ConcurrentHashMap< Key< NDIM >, madness::Tensor< Q > > | |
| Cmadness::ConcurrentHashMap< Key< NDIM >, Q > | |
| Cmadness::ConcurrentHashMap< keyT, valueT, hashfunT > | |
| Cmadness::ConcurrentHashMap< uniqueidT, void *, hashuniqueT > | |
| Cmadness::ConcurrentHashMap< void *, uniqueidT, hashvoidp > | |
| Cmadness::conditional_conj_struct< Q, iscomplex > | For real types return value, for complex return conjugate |
| Cmadness::conditional_conj_struct< Q, true > | For real types return value, for complex return conjugate |
| ►Cstd::conditional_t | |
| Cmadness::meta::conjunction< B1, Bn... > | |
| Cmadness::meta::disjunction< B1, Bn... > | |
| Cmadness::conj_op< Q, NDIM > | |
| CContractedGaussianShell | Represents a single shell of contracted, Cartesian, Gaussian primitives |
| Cmadness::ContractedGaussianShell | Represents a single shell of contracted, Cartesian, Gaussian primitives |
| ►Cmadness::Convolution1D< Q > | Provides the common functionality/interface of all 1D convolutions |
| Cmadness::GaussianConvolution1D< Q > | 1D convolution with (derivative) Gaussian; coeff and expnt given in simulation coordinates [0,1] |
| Cmadness::GenericConvolution1D< Q, opT > | Generic 1D convolution using brute force (i.e., slow) adaptive quadrature for rnlp |
| Cmadness::ConvolutionData1D< Q > | !!! Note that if Rnormf is zero then ALL of the tensors are empty |
| Cmadness::ConvolutionND< Q, NDIM > | Array of 1D convolutions (one / dimension) |
| Cmadness::CoreOrbital | |
| Cmadness::CorePotential | Represents a core potential |
| Cmadness::CorePotentialManager | |
| Cmadness::LoadBalanceDeux< NDIM >::CostPerProc | |
| Cmadness::CubicInterpolationTable< T > | An class for 1-D data interpolation based on cubic polynomials |
| Cmadness::CubicInterpolationTable< double_complex > | |
| Ccustom_serialize_tester | This class stores different member variables in different records of the cloud |
| CD | |
| Cdata< T, NDIM > | |
| Cmadness::KernelRange::Data | |
| Cmadness::Future< T >::dddd | |
| Cmadness::default_allocator< T > | |
| Cmadness::detail::DefaultInitPtr< T > | Default pointer to a. object of type T |
| Cmadness::detail::DefaultInitPtr< std::shared_ptr< T > > | Default shared pointer to an object of type T |
| Cmadness::detail::DeferredCleanup | Deferred cleanup of shared_ptr's |
| Cmadness::DeferredDeleter< typename, typename > | |
| Cmadness::dens_inv | |
| Cmadness::density_mask_operator | |
| Cmadness::meta::detail::detector< Default, Enabler, Op, Args > | |
| Cmadness::meta::detail::detector< Default, void_t< Op< Args... > >, Op, Args... > | |
| CDF | Given a molecule and nonrelativistic ground state orbitals, solve the Dirac-Hartree-Fock equations |
| Cmadness::DFParameters | |
| Cmadness::Diamagnetic_potential_factor | To be put in a separate file |
| CDirichletLBCost< NDIM > | |
| Cmadness::Displacements< NDIM > | Holds displacements for applying operators to avoid replicating for all operators |
| Cmadness::detail::DistCache< keyT > | Distributed caching utility |
| ►Cmadness::DistributedMatrixDistribution | |
| Cmadness::DistributedMatrix< double > | |
| Cmadness::DistributedMatrix< T > | Manages data associated with a row/column/block distributed array |
| Cmadness::divide_add_interpolate | Class to compute terms of the potential |
| Cmadness::FunctionImpl< T, NDIM >::do_accumulate_trees< Q, R > | Merge the coefficent boxes of this into result's tree |
| Cmadness::FunctionImpl< T, NDIM >::do_average | "put" this on g |
| Cmadness::FunctionImpl< T, NDIM >::do_change_tensor_type | Change representation of nodes' coeffs to low rank, optional fence |
| Cmadness::FunctionImpl< T, NDIM >::do_check_symmetry_local | Check symmetry wrt particle exchange |
| Cmadness::FunctionImpl< T, NDIM >::do_compute_snorm_and_dnorm | Compute the norm of the wavelet coefficients |
| Cmadness::FunctionImpl< T, NDIM >::do_consolidate_buffer | |
| Cmadness::FunctionImpl< T, NDIM >::do_convert_to_color | |
| Cmadness::FunctionImpl< T, NDIM >::do_dot_local< R > | Compute the inner product of this range with other |
| Cmadness::FunctionImpl< T, NDIM >::do_err_box< opT > | |
| Cmadness::FunctionImpl< T, NDIM >::do_gaxpy_inplace< Q, R > | Functor for the gaxpy_inplace method |
| Cmadness::FunctionImpl< T, NDIM >::do_inner_ext_local_ffi | |
| Cmadness::FunctionImpl< T, NDIM >::do_inner_local< R > | Compute the inner product of this range with other |
| Cmadness::FunctionImpl< T, NDIM >::do_inner_local_on_demand< R > | Compute the inner product of this range with other |
| Cmadness::FunctionImpl< T, NDIM >::do_keep_sum_coeffs | Keep only the sum coefficients in each node |
| Cmadness::FunctionImpl< T, NDIM >::do_map_and_mirror | Mirror dimensions of this, write result on f |
| Cmadness::FunctionImpl< T, NDIM >::do_mapdim | Map this on f |
| Cmadness::FunctionImpl< T, NDIM >::do_merge_trees< Q, R > | Merge the coefficient boxes of this into other's tree |
| Cmadness::FunctionImpl< T, NDIM >::do_mirror | Mirror dimensions of this, write result on f |
| Cmadness::FunctionImpl< T, NDIM >::do_norm2sq_local | |
| Cmadness::FunctionImpl< T, NDIM >::do_op_args< OPDIM > | Laziness |
| CNode::do_random_insert | |
| Cmadness::FunctionImpl< T, NDIM >::do_reduce_rank | Reduce the rank of the nodes, optional fence |
| Cmadness::FunctionImpl< T, NDIM >::do_standard | Changes non-standard compressed form to standard compressed form |
| Cmadness::FunctionImpl< T, NDIM >::do_truncate_NS_leafs | Given an NS tree resulting from a convolution, truncate leafs if appropriate |
| Cmadness::FunctionImpl< T, NDIM >::do_unary_op_value_inplace< opT > | |
| ►Cmadness::DomainMaskInterface | The interface for masking functions defined by signed distance functions |
| Cmadness::GaussianDomainMask | Use a Gaussian for the surface function and the corresponding erf for the domain mask |
| Cmadness::LLRVDomainMask | Provides the Li-Lowengrub-Ratz-Voight (LLRV) domain mask characteristic functions |
| CDouble | |
| Cmadness::DQStats | |
| Cmadness::meta::drop_last_arg_and_apply< MetaFn, Args > | |
| Cmadness::meta::drop_last_arg_and_apply_callable< MetaFn, Callable, Args > | |
| Cmadness::meta::drop_last_arg_and_apply_callable_impl< MetaFn, Callable, CurrentTypelist, RestOfTypes > | |
| Cmadness::meta::drop_last_arg_and_apply_callable_impl< MetaFn, Callable, typelist< UpToLast... >, Last > | |
| Cmadness::meta::drop_last_arg_and_apply_callable_impl< MetaFn, Callable, typelist< UpToT... >, T, Rest... > | |
| Cmadness::meta::drop_last_arg_and_apply_impl< MetaFn, CurrentTypelist, RestOfTypes > | |
| Cmadness::meta::drop_last_arg_and_apply_impl< MetaFn, typelist< UpToLast... >, Last > | |
| Cmadness::meta::drop_last_arg_and_apply_impl< MetaFn, typelist< UpToT... >, T, Rest... > | |
| CGridBuilder::dummygrid | |
| Cmadness::EigSolver< T, NDIM > | |
| ►Cmadness::EigSolverOp< T, NDIM > | |
| CNuclearChargeDensityOp< T, NDIM > | |
| Cmadness::DFTCoulombOp< T, NDIM > | |
| Cmadness::DFTCoulombPeriodicOp< T, NDIM > | |
| Cmadness::DFTNuclearChargeDensityOp< T, NDIM > | |
| Cmadness::DFTNuclearPotentialOp< T, NDIM > | |
| Cmadness::HartreeFockCoulombOp< T, NDIM > | |
| Cmadness::HartreeFockExchangeOp< T, NDIM > | |
| Cmadness::HartreeFockNuclearPotentialOp< T, NDIM > | |
| Cmadness::XCFunctionalLDA< T, NDIM > | |
| Cmadness::ElectronicStructureParams | |
| Cmadness::ElectronPairIterator | |
| ►Cstd::enable_shared_from_this | |
| Cmadness::WorldContainerImpl< keyT, valueT, hashfunT > | Internal implementation of distributed container to facilitate shallow copy |
| Cmadness::error_leaf_op< T, NDIM > | |
| ►Cslymer::ES_Interface | Abstract base class for interfacing with electronic structure codes |
| Cslymer::NWChem_Interface | Class for interfacing with NWChem (tested on version 6.6) |
| ►Cstd::exception | |
| CSafeMPI::Exception | SafeMPI exception object |
| Cmadness::LinAlgException | Linear algebra Exception |
| Cmadness::MadnessException | Base class for exceptions thrown in MADNESS |
| Cmadness::TensorException | Tensor is intended to throw only TensorExceptions |
| Cmadness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM > | |
| Cmadness::guessfactory::ExopUnaryOpStructure | |
| Cmadness::XCOperator< T, NDIM >::expme | Simple structure to take the pointwise exponential of a function, shifted by +14 |
| Cmadness::XCOperator< T, NDIM >::expme::expme1 | |
| Cmadness::F12Potentials | Class that provides all necessary F12 Potentials and Integrals |
| ►Cstd::false_type | |
| ►Cmadness::meta::disjunction< meta::is_detected_exact< std::istream &, right_shift, std::istream &, std::add_lvalue_reference_t< T > >, meta::is_detected_exact< std::istream &, right_shift_in_ns_madness_operators, std::istream &, std::add_lvalue_reference_t< T > > > | |
| ►Cmadness::is_istreammable_ns::impl< T > | |
| Cmadness::is_istreammable< T > | |
| ►Cmadness::meta::disjunction< meta::is_detected_exact< std::ostream &, left_shift, std::ostream &, std::add_const_t< std::add_lvalue_reference_t< T > > >, meta::is_detected_exact< std::ostream &, left_shift_in_ns_madness_operators, std::ostream &, std::add_const_t< std::add_lvalue_reference_t< T > > > > | |
| ►Cmadness::is_ostreammable_ns::impl< T > | |
| Cmadness::is_ostreammable< T > | |
| Cmadness::Cloud::is_madness_function_vector< typename > | |
| Cmadness::Cloud::is_tuple< typename > | |
| Cmadness::Cloud::is_vector< Q > | |
| Cmadness::MacroTask< taskT >::is_vector< Q > | |
| Cmadness::detail::callable_traits< functionT, enablerT > | Function traits in the spirit of boost function traits |
| Cmadness::detail::function_traits< functionT, enablerT > | Function traits in the spirit of boost function traits |
| Cmadness::detail::is_arg_holder< T > | |
| Cmadness::detail::memfunc_traits< memfuncT > | Member function traits in the spirit of boost function traits |
| Cmadness::is_any_function_pointer< T, Enabler > | True type if T is a pointer to free or member function |
| Cmadness::is_cereal_archive< Archive > | |
| Cmadness::is_default_serializable_helper< Archive, T, Enabler > | |
| Cmadness::is_function_pointer< T, Enabler > | True type if T is a pointer to a free function |
| Cmadness::is_future< T > | Test if a type is a future |
| Cmadness::is_madness_function< typename > | |
| Cmadness::is_madness_function_vector< typename > | |
| Cmadness::is_scalar_result< typename > | |
| Cmadness::is_scalar_result_impl< typename > | |
| Cmadness::is_scalar_result_ptr< typename > | |
| Cmadness::is_scalar_result_ptr_vector< typename > | |
| Cmadness::is_scalar_result_vector< typename > | |
| Cmadness::is_text_archive< Archive, Enabler > | This trait types tests if Archive is a text archive |
| Cmadness::is_tuple< typename > | |
| Cmadness::is_vector< Q > | |
| Cmadness::meta::disjunction<... > | |
| Cmadness::meta::taskattr_is_last_arg<> | |
| CFcwf | |
| CFcwf_vector_allocator | |
| CFunc< FLOAT > | |
| Cfunction_allocator< T, NDIM > | |
| Cmadness::detail::function_enabler_helper< B, returnT > | Behave like a lazy std::enable_if |
| Cmadness::detail::function_enabler_helper< false, returnT > | Specialization that disables type when B is false |
| ►Cmadness::detail::function_enabler_helper< function_traits< fnT >::value||is_functor< fnT >::value, task_result_type< fnT > > | |
| Cmadness::detail::function_enabler< fnT > | |
| Cfunction_real2complex_op< Q, NDIM > | |
| Cmadness::function_real2complex_op< Q, NDIM > | |
| Cmadness::detail::function_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.) |
| Cmadness::detail::function_traits< resultT(*&)(argTs...), void > | Function trait specialization for a reference to a free function pointer |
| Cmadness::detail::function_traits< resultT(*)(argTs...), void > | Function trait specialization for a free function pointer |
| Cmadness::FunctionCommonData< T, NDIM > | FunctionCommonData holds all Function data common for given k |
| Cmadness::FunctionCommonData< double, 3 > | |
| Cmadness::FunctionCommonData< double, NDIM > | |
| Cmadness::FunctionCommonData< Q, NDIM > | |
| Cmadness::FunctionCommonData< R, NDIM > | |
| Cmadness::FunctionCommonFunctionality< T, NDIM > | Collect common functionality does not need to be member function of funcimpl |
| Cmadness::FunctionDefaults< NDIM > | FunctionDefaults holds default paramaters as static class members |
| ►Cmadness::FunctionFactory< T, NDIM > | FunctionFactory implements the named-parameter idiom for Function |
| Cmadness::CompositeFactory< T, NDIM, MDIM > | Factory for facile setup of a CompositeFunctorInterface and its FuncImpl |
| Cmadness::TwoElectronFactory< T, NDIM > | Factory for generating TwoElectronInterfaces |
| Cmadness::FunctionFactory< double, 6 > | |
| ►CFunctionFunctorInterface | |
| CAtomicBasisFunctor< Q > | |
| ►Cmadness::FunctionFunctorInterface< T, NDIM > | Abstract base class interface required for functors used as input to Functions |
| ►Cmadness::TwoElectronInterface< double, 6 > | |
| Cmadness::BSHFunctionInterface | Function like f(x) = exp(-mu x)/x |
| Cmadness::SlaterF12Interface | Function like f(x) = (1 - exp(-mu x))/(2 gamma) |
| Cmadness::SlaterFunctionInterface | Function like f(x)=exp(-mu x) |
| ►Cmadness::TwoElectronInterface< double, NDIM > | |
| Cmadness::ElectronRepulsionInterface< T, NDIM > | Function like f(x)=1/x |
| CDerivativeGaussian< T, NDIM > | |
| CGaussian< T, NDIM > | |
| CGaussian< T, NDIM > | |
| CGaussian< T, NDIM > | |
| CGaussian< T, NDIM > | |
| CGaussian< T, NDIM > | |
| CGaussian< T, NDIM > | |
| CGaussianGuess< NDIM > | N-dimensional real-valued Gaussian function |
| CHeElectronicChargeDensityIGuess< T, NDIM > | |
| CHeNuclearChargeDensityIGuess< T, NDIM > | |
| CParserHandler< T, NDIM > | |
| Cmadness::CompositeFunctorInterface< T, NDIM, MDIM > | CompositeFunctorInterface implements a wrapper of holding several functions and functors |
| Cmadness::ElementaryInterface< T, NDIM > | ElementaryInterface (formerly FunctorInterfaceWrapper) interfaces a c-function |
| Cmadness::FunctionInterface< T, NDIM, opT > | FunctionInterface implements a wrapper around any class with the operator()() |
| Cmadness::FunctorInterface< T, NDIM, opT > | FunctorInterface interfaces a class or struct with an operator()() |
| ►Cmadness::TwoElectronInterface< T, NDIM > | Base class to compute the wavelet coefficients for an isotropic 2e-operator |
| Cmadness::GeneralTwoElectronInterface< T, NDIM > | Function like f(x)=1/x |
| ►Cmadness::FunctionFunctorInterface< double, 1 > | |
| CF | Simple class for testing the solver |
| CG | |
| CG | |
| CGConvGNP | |
| CGConvGRNP | |
| CGConvGRP | |
| CVnuclear | |
| Cmadness::ScalingFunctionFunctor< 1 > | |
| ►Cmadness::FunctionFunctorInterface< double, 3 > | |
| CAtomicOrbitalFunctor | |
| CCharge | |
| CCoreOrbitalFunctor | |
| CCorePotentialFunctor | |
| CCosPotentialFunctor | |
| CDPot | |
| CDSphere | Functor representing the log-derivative of  along an axis |
| CDSphere | Functor representing the log-derivative of along an axis |
| CDipoleFunctor | A MADNESS functor to compute either x, y, or z |
| ►CEmbeddedDirichlet | Abstract base class for embedded Dirichlet problems |
| CConstantSphere | The constant on a sphere problem |
| CCosineSphere | The cos(theta) on a sphere problem |
| CInhomoConstantSphere | The constant on a sphere problem, with inhomogeneity |
| CY20Sphere | The Y_2^0 on a sphere problem |
| CEwaldNuclearPotentialFunctor | |
| CF | Simple class for testing the solver |
| CFermiNucDistFunctor | |
| CFiniteNucleusPotential | |
| CFunctorInterfaceWrapper | |
| CGaussian< T, NDIM > | |
| CGaussian< T, NDIM > | |
| CGaussianFunctor | |
| CGaussianFunctor | |
| CGaussianNucleusFunctor | |
| CGaussianPotential | Computes the electrostatic potential due to a Gaussian charge distribution |
| CGuess | |
| CH2Potential | |
| CMolecularGuessDensityFunctor | |
| CMolecularGuessDensityFunctor | |
| CMolecularNuclearChargeDensityFunctor | |
| CMolecularNuclearChargeDensityFunctor | |
| CMolecularNuclearPotentialFunctor2 | |
| CMolecularPotentialFunctor | |
| CMolecularPotentialFunctor | |
| CMolecularSurface | |
| CMolecularVolumeComplementMask | |
| CMolecularVolumeExponentialSwitch | Switches between positive values Vint and Vext with special log derivative |
| CMolecularVolumeExponentialSwitchLogGrad | Returns the requested component of the derivative of the log of MolecularVolumeExponentialSwitch |
| CMolecularVolumeExponentialSwitchReciprocal | Computes the reciprocal of MolecularVolumeExponentialSwitch |
| CMolecularVolumeMask | |
| CMolecularVolumeMaskGrad | |
| CNcOverR | |
| COnesFunctor | |
| COpFExact | |
| CPotentialBasisFunctor | |
| CQfunc | Result of the convolution |
| CRadiusFunctor | |
| CRadiusSquareFunctor | |
| CSphere | |
| CSplitterFunctor | |
| CVderiv | |
| Calpha_functor | |
| Cbeta_functor | |
| Cmadchem::AtomicAttractionFunctor | |
| Cmadchem::AtomicBasisFunctor | |
| Cmadchem::CorePotentialDerivativeFunctor | |
| Cmadchem::MolecularDerivativeFunctor | |
| Cmadchem::MolecularGuessDensityFunctor | |
| Cmadchem::MolecularSecondDerivativeFunctor | |
| Cmadness::BasisFunctions::CartesianGaussian | |
| Cmadness::BasisFunctions::SolidHarmonicGaussian | |
| Cmadness::CoreOrbitalDerivativeFunctor | |
| Cmadness::CoreOrbitalFunctor | |
| Cmadness::DipoleFunctor | A MADNESS functor to compute either x, y, or z |
| Cmadness::DipoleFunctor | A MADNESS functor to compute either x, y, or z |
| Cmadness::MolecularCorePotentialFunctor | |
| Cmadness::MolecularPotentialFunctor | |
| Cmadness::MomentFunctor | A MADNESS functor to compute the cartesian moment x^i * y^j * z^k (i, j, k integer and >= 0) |
| Cmadness::NuclearCorrelationFactor::RX_functor | Compute the derivative of R wrt the displacement of atom A, coord axis |
| Cmadness::NuclearCorrelationFactor::R_functor | |
| Cmadness::NuclearCorrelationFactor::U1X_functor | Compute the derivative of U1 wrt the displacement of atom A, coord axis |
| Cmadness::NuclearCorrelationFactor::U1_atomic_functor | U1 functor for a specific atom |
| Cmadness::NuclearCorrelationFactor::U1_dot_U1_functor | Functor for a local U1 dot U1 potential |
| Cmadness::NuclearCorrelationFactor::U1_functor | Functor for the local part of the U1 potential – NOTE THE SIGN |
| Cmadness::NuclearCorrelationFactor::U2X_functor | Compute the derivative of U2 wrt the displacement of atom A |
| Cmadness::NuclearCorrelationFactor::U2_atomic_functor | U2 functor for a specific atom |
| Cmadness::NuclearCorrelationFactor::U2_functor | |
| Cmadness::NuclearCorrelationFactor::U3X_functor | Compute the derivative of U3 wrt the displacement of atom A, coord axis |
| Cmadness::NuclearCorrelationFactor::U3_atomic_functor | U3 functor for a specific atom |
| Cmadness::NuclearCorrelationFactor::U3_functor | |
| Cmadness::NuclearCorrelationFactor::square_times_V_derivative_functor | |
| Cmadness::NuclearCorrelationFactor::square_times_V_functor | |
| Cmadness::NuclearDensityFunctor | Default functor for the nuclear charge density |
| Cmadness::ProjRLMFunctor | |
| Cmadness::SAPFunctor | SAPFunctor = Interpolated Atomic Potential for 1 atom |
| Cmadness::Solver< T, NDIM >::GuessDensity | |
| Cmadness::VLocalFunctor | |
| Cmadness::WignerSeitzPotentialFunctor | Evaluates Wigner-Seitz-truncated potential in the simulation cell, due to periodic or nonperiodic source functions |
| Cmadness::asymptotic_slater | |
| Cmadness::atomic_attraction | |
| Cmadness::guessfactory::GaussFunctor | |
| Cmadness::guessfactory::PlaneWaveFunctor | Creates a plane-wave: sin (or cos) with argument (npi/L*x) |
| ►Cmadness::guessfactory::PolynomialFunctor | Project a general 3D polynomial to the MRA Grid |
| Cmadness::guessfactory::PolynomialTrigonometricsFunctor | |
| Cmadness::harmonic_potential_boxed | Functor for the diamagnetic term in a box |
| Cncf | |
| Cslymer::Gaussian_Functor | |
| Cstepfunction | |
| Cuexact | |
| Cuexact | |
| ►Cmadness::FunctionFunctorInterface< double, NDIM > | |
| CFunctorInterfaceWrapper | |
| CGaussianGuess< NDIM > | N-dimensional real-valued Gaussian function |
| Cmadness::DomainMaskSDFFunctor< NDIM > | Framework for combining a signed distance function (sdf) with a domain mask to produce MADNESS functions |
| Cmadness::ScalingFunctionFunctor< NDIM, std::enable_if_t< std::greater{}(NDIM, 1)> > | |
| Cmadness::int_factor_functor< NDIM > | Functor for the correction factor, which is multiplied with the exchange correlation potential |
| Cmadness::lr_pot_functor< NDIM > | Functor for the 1/r potential to induce the correct asymptotic behaviour of the exchange correlation potential |
| Cxc_functor< NDIM > | Functor for the exchange correlation potential |
| ►Cmadness::FunctionFunctorInterface< double_complex, 1 > | |
| CPsiExact | |
| CQMtest | |
| ►Cmadness::FunctionFunctorInterface< double_complex, 3 > | |
| CAtomicBasisFunctor< Q > | |
| CExactSpinor | |
| CGuess | |
| CPWFunctor | |
| Cmadness::WSTAtomicBasisFunctor | |
| Cmadness::Znemo::p_orbital | |
| Cmadness::Znemo::s_orbital | |
| ►Cmadness::FunctionFunctorInterface< double_complex, NDIM > | |
| Cmadness::ComplexExp< NDIM > | |
| ►Cmadness::FunctionFunctorInterface< Q, 3 > | |
| CAtomicBasisFunctor< Q > | |
| CExpFunctor< Q > | |
| CExpFunctor< Q > | |
| CExpFunctor3d< Q > | |
| CExpFunctor3d< Q > | |
| ►Cmadness::FunctionFunctorInterface< resultT, NDIM > | |
| CBinaryOp< resultT, L, R, opT, NDIM > | Returns a new functor combining two functors via operation op(left,right) |
| Cmadness::FunctionNode< T, NDIM > | FunctionNode holds the coefficients, etc., at each node of the 2^NDIM-tree |
| Cmadness::PoolTaskInterface::FunctionPointerGrabber< T > | Object that is used to convert function and member function pointers into void* |
| Cmadness::Future< T > | A future is a possibly yet unevaluated value |
| Cmadness::Future< bool > | |
| Cmadness::Future< Future< T > > | A future of a future is forbidden (by deleted constructor) |
| Cmadness::Future< valueT > | |
| Cmadness::Future< void > | Specialization of Future<void> for internal convenience. This does nothing useful! |
| Cmadness::future_to_ref< T > | |
| Cmadness::future_to_ref< const Future< T > & > | |
| Cmadness::future_to_ref< Future< T > & > | |
| Cmadness::future_to_ref< Future< T > * > | |
| Cmadness::future_to_ref< Future< T > > | |
| Cmadness::FutureImpl< void > | Specialization of FutureImpl<void> for internal convenience. This does nothing useful! |
| CG1 | |
| Cgauss< T, NDIM > | |
| Cgauss_1d | |
| Cgaussian | |
| Cmadness::GaussianConvolution1DCache< Q > | |
| Cmadness::GaussianGenericFunctor< Q > | |
| Cmadness::GFit< T, NDIM > | |
| Cmadness::Gnuplot | |
| ►Cmadness::gridbase | |
| Cmadness::dftgrid< NDIM > | |
| Cmadness::molecular_grid< NDIM > | Given a molecule, return a suitable grid |
| Cmadness::randomgrid< NDIM > | Grid with random points around the origin, with a Gaussian distribution |
| CGridBuilder | |
| CGroundStateCalculation | |
| Cmadness::Group | A collection of processes |
| CSafeMPI::Group | |
| Cmadness::WorldGopInterface::GroupAllReduceTag | |
| Cmadness::WorldGopInterface::GroupBcastTag | |
| Cmadness::WorldGopInterface::GroupLazySyncTag | |
| Cmadness::WorldGopInterface::GroupReduceTag | |
| Cmadness::GTHPseudopotential< Q > | |
| CGygiPot | |
| Cmadness::hartree_convolute_leaf_op< T, NDIM, LDIM, opT > | |
| Cmadness::hartree_leaf_op< T, NDIM > | Returns true if the result of a hartree_product is a leaf node (compute norm & error) |
| Cmadness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT > | Hartree product of two LDIM functions to yield a NDIM = 2*LDIM function |
| Cmadness::Hash< T > | Hash functor |
| Cmadness::Hash< hashT > | |
| Cmadness::Hash< int > | |
| Cmadness::Hash< Key< NDIM > > | |
| Cmadness::Hash< keyT > | |
| Cmadness::Hash_private::HashIterator< hashT > | Iterator for hash |
| Cmadness::World::hashuniqueT | |
| Cmadness::World::hashvoidp | |
| Cmadness::RMI::RmiTask::header | |
| Cmadness::detail::helper< T, N > | |
| Cmadness::detail::helper< T, 0 > | |
| Cmadness::detail::helper< T, 1 > | |
| CHO_function< NDIM > | |
| ►Cmadness::IEigSolverObserver< T, NDIM > | |
| Cmadness::DFT< T, NDIM > | |
| Cmadness::HartreeFock< T, NDIM > | |
| Cmadness::imag_op< Q, NDIM > | |
| Cmadness::detail::imagop< NDIM > | |
| Cmadness::Group::Impl | |
| CSafeMPI::Group::Impl | |
| CSafeMPI::Intracomm::Impl | |
| ►Cmadness::IndexIterator | |
| Cmadness::HighDimIndexIterator | |
| Cmadness::LowDimIndexIterator | |
| Cmadness::NonstandardIndexIterator | |
| Cmadness::Info | POD holding some basic functions and some intermediates for the CC2 calculation |
| ►Cmadness::detail::info_base< memfunT > | |
| Cmadness::detail::info< memfunT > | |
| Cmadness::InitParameters | |
| Cinputfile | |
| CInputParameters | |
| Cmadness::insert_op< T, NDIM > | Insert/replaces the coefficients into the function |
| ►Cstd::integral_constant | |
| Cmadness::detail::ArgCount< a1T, a2T, a3T, a4T, a5T, a6T, a7T, a8T, a9T > | |
| Cmadness::meta::taskattr_is_last_arg< argsT > | |
| ►CSafeMPI::Intracomm | Wrapper around MPI_Comm. Has a shallow copy constructor; use Create(Get_group()) for deep copy |
| Cmadness::WorldMpiInterface | This class wraps/extends the MPI interface for World |
| Cmadness::smooth< T, NDIM >::inv_mask_functor | |
| Cmadness::MacroTask< taskT >::io_redirect | RAII class to redirect cout to a file |
| Cmadness::is_archive< T, Enabler > | Checks if T is an archive type |
| Cmadness::is_default_serializable< Archive, T > | std::true_type if T can be serialized to Archive without specialized serialize() method |
| Cmadness::detail::is_functor< fnT, Enabler > | |
| Cmadness::is_input_archive< T, Enabler > | Checks if T is an input archive type |
| Cmadness::is_output_archive< T, Enabler > | Checks if T is an output archive type |
| ►Cstd::is_trivially_copyable | |
| Cmadness::is_trivially_copyable< T > | Trait for trivial (=bitwise) copyability of T, defaults to std::is_trivially_copyable<T> but can be specialized as needed |
| Cmadness::is_trivially_serializable< T > | |
| Cmadness::IsSupported< TypeData, typename, bool > | |
| Cmadness::IsSupported< TypeData, ReturnType, true > | |
| Cmadness::BoxSurfaceDisplacementRange< NDIM >::Iterator | Iterator class for lazy generation of surface points |
| Cmadness::KahanAccumulator< T, Enabler > | |
| Cmadness::KahanAccumulator< Complex, std::enable_if_t<!std::is_floating_point_v< Complex > > > | Implements Kahan summation for complex numbers |
| Cmadness::KahanAccumulator< Real > | |
| Cmadness::KahanAccumulator< Real, std::enable_if_t< std::is_floating_point_v< Real > > > | Implements Kahan summation for real numbers |
| Cmadness::KernelRange | |
| CKey | |
| Cmadness::Key< NDIM > | Key is the index for a node of the 2^NDIM-tree |
| Cmadness::Key< OPDIM > | |
| CKeyChildIterator | |
| Cmadness::KeyChildIterator< NDIM > | Iterates in lexical order thru all children of a key |
| CKPeriodicBSHOperator | |
| CKPoint | |
| Cmadness::KPoint | |
| Cmadness::Znemo::landau_wave_function | Following Doucot Pascier 2005 |
| CLargeNode | |
| Cmadness::meta::last_type< Ts > | |
| Cmadness::meta::last_type< T0 > | |
| ►Cmadness::meta::last_type< T1, Ts... > | |
| Cmadness::meta::last_type< T0, T1, Ts... > | |
| Cmadness::WorldGopInterface::LazySyncTag | |
| Clbcost< T, NDIM > | |
| CLBCost | |
| Cmadness::LBCost | |
| Cmadness::lbcost< T, NDIM > | |
| Cmadness::LBNodeDeux< NDIM > | |
| Cmadness::Leaf_op< T, NDIM, opT, specialboxT > | |
| Cmadness::leaf_op< T, NDIM > | |
| ►Cmadness::Leaf_op< T, NDIM, SeparatedConvolution< double, NDIM >, Specialbox_op< T, NDIM > > | |
| Cmadness::Leaf_op_other< T, NDIM > | |
| Clinked_list | |
| Cmadness::LoadBalanceDeux< NDIM > | |
| Cmadness::LoadBalImpl< D > | |
| Cmadness::Localizer | |
| Cmadness::XCOperator< T, NDIM >::logme | Simple structure to take the pointwise logarithm of a function, shifted by +14 |
| Cmadness::XCOperator< T, NDIM >::logme::logme1 | |
| Cmadness::LowRankFunction< T, NDIM, LDIM > | LowRankFunction represents a hi-dimensional (NDIM) function as a sum of products of low-dimensional (LDIM) functions |
| Cmadness::LowRankFunctionFactory< T, NDIM, LDIM > | |
| CLProjector | |
| ►Cmadness::LRFunctorBase< T, NDIM, LDIM > | Low-rank functor is what the LowRankFunction will represent |
| Cmadness::LRFunctorF12< T, NDIM, LDIM > | |
| Cmadness::LRFunctorPure< T, NDIM, LDIM > | |
| Cmadness::MacroTask< taskT > | |
| ►Cmadness::MacroTaskBase | Base class |
| ►Cmadness::MacroTaskIntermediate< MacroTask > | |
| Cmadness::MacroTask< taskT >::MacroTaskInternal | |
| Cmadness::MacroTaskIntermediate< macrotaskT > | |
| ►Cmadness::MacroTaskOperationBase | |
| CMicroTask< T, NDIM > | |
| CMicroTask1 | |
| CMicroTask2 | |
| CMixedTupleTask< elementT, elementR > | This task won't do anything, is mostly to check if the combinations compile |
| CScalarTask | |
| CTupleTask | |
| CVectorOfScalarTask | |
| Cmadness::Coulomb< T, NDIM >::MacroTaskCoulomb | |
| Cmadness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeRow | |
| Cmadness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeSimple | |
| Cmadness::MP3::MacroTaskMP3 | Helper class for calculating the MP3 energy contributions |
| Cmadness::MacroTaskComputeCorrelationEnergy | |
| Cmadness::MacroTaskConstantPart | |
| Cmadness::MacroTaskIteratePair | |
| Cmadness::MacroTaskMp2ConstantPart | |
| Cmadness::MacroTaskMp2UpdatePair | |
| Cmadness::MacroTaskSinglesPotentialEx | |
| Cmadness::MacroTaskSinglesPotentialGs | |
| ►Cmadness::MacroTaskPartitioner | Partition one (two) vectors into 1D (2D) batches |
| Cmadness::Coulomb< T, NDIM >::MacroTaskCoulomb::MacroTaskPartitionerCoulomb | |
| Cmadness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeRow::MacroTaskPartitionerRow | Custom partitioning for the exchange operator in exchangeoperator.h |
| Cmadness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeSimple::MacroTaskPartitionerExchange | Custom partitioning for the exchange operator in exchangeoperator.h |
| Cmadness::MP3::MacroTaskMP3::Partitioner | |
| Cmadness::MacroTaskConstantPart::ConstantPartPartitioner | |
| Cmadness::MacroTaskIteratePair::IteratePairPartitioner | |
| Cmadness::MacroTaskMp2ConstantPart::ConstantPartPartitioner | |
| Cmadness::MacroTaskMp2UpdatePair::UpdatePairPartitioner | |
| Cmadness::meta::make_void< Ts > | |
| Cmany_to_many_op< NDIM > | Struct to test the multi_to_multi_op_values |
| CMary | |
| Cmadness::smooth< T, NDIM >::mask_functor | |
| Cmatrix< FLOAT > | |
| ►CMatrixOperator | Class defining an operator in matrix form, fixed to size (4,4) |
| CMetric | |
| Cmadness::max_of_x_1_smooth | |
| Cmadness::detail::memfunc_enabler_base< objT, memfnT, enableT > | |
| Cmadness::detail::memfunc_enabler_base< objT, resT(baseT::*)(paramT...) const, typename std::enable_if< std::is_base_of< baseT, objT >::value >::type > | |
| Cmadness::detail::memfunc_enabler_base< objT, resT(baseT::*)(paramT...), typename std::enable_if< std::is_base_of< baseT, objT >::value >::type > | |
| ►Cmadness::detail::memfunc_enabler_base< std::decay< objT >::type, memfnT > | |
| ►Cmadness::detail::memfunc_enabler< objT, memfnT > | |
| Cmadness::detail::memfunc_enabler< const objT *, memfnT > | |
| Cmadness::detail::memfunc_enabler< const objT *const, memfnT > | |
| Cmadness::detail::memfunc_enabler< const std::shared_ptr< objT > &, memfnT > | |
| Cmadness::detail::memfunc_enabler< const std::shared_ptr< objT >, memfnT > | |
| Cmadness::detail::memfunc_enabler< objT *, memfnT > | |
| Cmadness::detail::memfunc_enabler< objT *const, memfnT > | |
| Cmadness::detail::memfunc_enabler< std::shared_ptr< objT > &, memfnT > | |
| Cmadness::detail::memfunc_enabler< std::shared_ptr< objT >, memfnT > | |
| Cmadness::detail::memfunc_traits< returnT(objT::*)(argTs...) const > | Member function traits in the spirit of boost function traits |
| Cmadness::detail::memfunc_traits< returnT(objT::*)(argTs...)> | Member function traits in the spirit of boost function traits |
| Cmadness::detail::MemFuncWrapper< ptrT, memfnT, resT > | Functor wrapper for object and member function pointers |
| Cmadness::detail::MemFuncWrapper< ptrT, memfnT, void > | Functor wrapper for object and member function pointers |
| Cmadness::MemoryMeasurer::MemInfo | |
| Cmadness::PNOPairs::MemInfo | |
| Cmadness::MemoryMeasurer::MemKey | |
| Cmadness::MemoryMeasurer | Measure the memory usage of all FunctionImpl objects of all worlds |
| Cmadness::merging_operator | |
| CMiniDFT | |
| CMolecularEntity | |
| ►CMolecularMaskBase | |
| CMolecularSurface | |
| CMolecularVolumeComplementMask | |
| CMolecularVolumeMask | |
| CMolecularVolumeMaskGrad | |
| Cmadness::Molecule | |
| Cmadness::MP3 | |
| CMPI_Status | |
| Cmadness::World::MpiRequestTester | |
| Cmadness::mul_leaf_op< T, NDIM > | |
| Cmadness::FunctionImpl< T, NDIM >::multiply_op< LDIM > | Perform this multiplication: h(1,2) = f(1,2) * g(1) |
| Cmadness::munging_operator | |
| ►Cmadness::Mutex | Mutex using pthread mutex operations |
| Cmadness::RMI::RmiTask | |
| Cmadness::Random | A random number generator (portable, vectorized, and thread-safe) |
| Cmadness::WorldAmInterface | Implements AM interface |
| Cmadness::WorldAmInterface::SendReq | |
| Cmadness::MutexWaiter | |
| Cmadness::MyTimer | Timer structure |
| Cmyunaryop< T, NDIM > | |
| Cmyunaryop_square< T, NDIM > | |
| Cncf_cusp | |
| Cncf_singularity | |
| ►CNO_DEFAULTS | Disables default copy constructor and assignment operators |
| Cmadness::Future< std::vector< Future< T > > > | Specialization of Future for a vector of Futures |
| Cmadness::Hash_private::HashAccessor< hashT, lockmode > | |
| ►Cmadness::MutexReaderWriter | |
| Cmadness::Hash_private::entry< keyT, valueT > | |
| ►Cmadness::PthreadConditionVariable | Simple wrapper for Pthread condition variable with its own mutex |
| Cmadness::DQueue< madness::PoolTaskInterface * > | |
| Cmadness::DQueue< T > | A thread safe, fast but simple doubled-ended queue |
| Cmadness::World | A parallel world class |
| Cmadness::WorldTaskQueue | Multi-threaded queue to manage and run tasks |
| Cmadness::detail::ArgHolder< Arg > | A wrapper object for holding task function argument objects |
| CNode | |
| Cmadness::meta::nonesuch | |
| Cmadness::NonlinearSolverND< NDIM > | A simple Krylov-subspace nonlinear equation solver |
| Cmadness::detail::noop< A, B > | |
| Cmadness::noop< T, NDIM > | |
| CNotStreammable | |
| ►Cmadness::NuclearCorrelationFactor | ABC for the nuclear correlation factors |
| Cmadness::AdhocNuclearCorrelationFactor | This ncf has no information about itself, only U2 and U1 assigned |
| Cmadness::GaussSlater | A nuclear correlation factor class |
| Cmadness::GradientalGaussSlater | A nuclear correlation factor class |
| Cmadness::LinearSlater | A nuclear correlation factor class |
| Cmadness::Polynomial< N > | A nuclear correlation factor class |
| Cmadness::PseudoNuclearCorrelationFactor | |
| Cmadness::Slater | A nuclear correlation factor class |
| Cmadness::poly4erfc | |
| COmega | |
| Cmadness::op_leaf_op< T, NDIM, opT > | |
| Cmadness::Operator< T > | A generic operator: takes in one T and produces another T |
| ►Cmadness::Operator< Function< double, 3 > > | |
| CDirichletCondIntOp | The operator needed for solving for  with GMRES |
| CRealFuncIdentOp | Identity operator for a real function |
| CRealFuncLinearOp | |
| ►Cmadness::Operator< Function< std::complex< double >, 3 > > | |
| CComplexFuncIdentOp | Identity operator for a complex function |
| CComplexFuncLinearOp | |
| ►Cmadness::Operator< Vector< double, 3 > > | |
| CRealVecIdentOp | Identity operator for real vectors |
| CRealVecLinearOp | Arbitrary operator for real vectors |
| ►Cmadness::Operator< Vector< std::complex< double >, 3 > > | |
| CComplexVecIdentOp | Identity operator for complex vectors |
| CComplexVecLinearOp | Arbitrary operator for complex vectors |
| Cmadness::OperatorInfo | |
| ►Cmadness::OptimizationTargetInterface | The interface to be provided by functions to be optimized |
| CCoreFittingTarget | |
| CFred | Wrapper around vector demonstrating interface necessary |
| CTest | |
| CTest | |
| CTest2 | |
| CTest2 | |
| Cmadness::CC2 | |
| Cmadness::MP2 | Class for computing the first order wave function and MP2 pair energies |
| Cmadness::MolecularEnergy | |
| ►Cmadness::MolecularOptimizationTargetInterface | |
| ►Cmadness::NemoBase | |
| ►Cmadness::Nemo | The Nemo class |
| Cmadness::OEP | |
| Cmadness::Znemo | |
| COptimizationTargetInterface | The interface to be provided by functions to be optimized |
| ►Cmadness::OptimizerInterface | The interface to be provided by optimizers |
| CMySteepestDescent | |
| CQuasiNewton | Optimization via quasi-Newton (BFGS or SR1 update) |
| CSteepestDescent | Optimization via steepest descent |
| Cmadness::MolecularOptimizer | Molecular optimizer derived from the QuasiNewton optimizer |
| Cmadness::QuasiNewton | Optimization via quasi-Newton (BFGS or SR1 update) |
| Cmadness::SteepestDescent | Unconstrained minimization via steepest descent |
| COptimizerInterface | The interface to be provided by optimizers |
| Cmadness::OrbitalIterator | Iterates the third index for pair coupling |
| COutputWriter | |
| Cmadness::WorldContainerImpl< keyT, valueT, hashfunT >::P2Op | |
| Cmadness::PairEnergies | POD structure for energies |
| Cmadness::MP2::Pairs< T > | POD holding all electron pairs with easy access |
| Cmadness::Pairs< T > | |
| Cmadness::Pairs< double, 3 > | |
| Cmadness::MP2::Pairs< madness::ElectronPair > | |
| Cmadness::PairVectorMap | |
| ►Cmadness::archive::ParallelSerializableObject | Objects that implement their own parallel archive interface should derive from this class |
| Cmadness::Function< double, 3 > | |
| Cmadness::Function< std::complex< double >, 3 > | |
| Cmadness::Function< T, LDIM > | |
| Cmadness::Function< double, NDIM > | |
| Cmadness::Function< double, 6 > | |
| Cmadness::WorldContainer< madness::Key, Node > | |
| Cmadness::WorldContainer< keyT, nodeT > | |
| Cmadness::CCFunction< T, NDIM > | Structure for a CC Function 3D which holds an index and a type |
| Cmadness::CCPair | |
| Cmadness::CCPairFunction< T, NDIM > | 6D function, either in full or low rank form, possibly including an 2-particle function |
| Cmadness::CC_vecfunction | A helper structure which holds a map of functions |
| Cmadness::ElectronPair | Enhanced POD for the pair functions |
| Cmadness::Function< T, NDIM > | A multiresolution adaptive numerical function |
| Cmadness::MolecularOrbitals< T, NDIM > | |
| Cmadness::WorldContainer< keyT, valueT, hashfunT > | Makes a distributed container with specified attributes |
| Cmadness::CCConvolutionOperator< T, NDIM >::Parameters | Parameter class |
| Cmadness::ParametrizedExchange | |
| Cmadness::particle< PDIM > | |
| Cmadness::particle< NDIM/2 > | |
| CPbar_omega | Computes term k at quadrature point t in infinte Fourier-space sum defining Pbar |
| Cmadness::PCM | Interface class to the PCMSolver library |
| Cmadness::detail::PendingMsg | Common base class for pending messages to ensure in-order processing |
| Cmadness::permutation | Permutations in physisists notation: <ij | kl> = (ik | jl), loop over ik<jl |
| Cmadness::pg_operator | This class implements the symmetry operations (not the point groups) |
| CplotCoords | |
| CPlotter | |
| Cmadness::PNOPairs | POD for PNO code |
| Cpod_deserialize_dispatch< DoSerialize > | |
| Cpod_deserialize_dispatch< false > | |
| Cpod_deserialize_dispatch< true > | |
| Cpod_serialize_dispatch< DoSerialize > | |
| Cpod_serialize_dispatch< false > | |
| Cpod_serialize_dispatch< true > | |
| CPointGroup | |
| Cmadness::WorldGopInterface::PointToPointTag | |
| Cmadness::FunctionImpl< T, NDIM >::pointwise_multiplier< LDIM > | |
| Cslymer::PolynomialCoeffs | Array for storing coefficients of a polynomial of three variables with specified degree |
| Cmadness::PotentialManager | |
| Cmadness::Znemo::potentials | |
| CGygiPot::Pow< T, DIM > | |
| CGygiPot::Pow_beta_one< T, DIM > | |
| Cslymer::PrimitiveGaussian | A primitive Gaussian function |
| Cmadness::printleveler | |
| Cmadness::WorldTaskQueue::ProbeAllDone | |
| Cmadness::ProcessKey< Key, Tag > | Key object that includes the process information |
| Cmadness::ProfileStat< T > | Simple container for parallel profile statistic |
| Cmadness::ProfileStat< double > | |
| Cmadness::ProfileStat< unsigned long > | |
| Cmadness::FunctionImpl< T, NDIM >::project_out_op< LDIM > | Project the low-dim function g on the hi-dim function f: result(x) = <f(x,y) | g(y)> |
| Cmadness::projector_irrep | |
| ►Cmadness::ProjectorBase | |
| Cmadness::Projector< double, NDIM > | |
| Cmadness::Projector< double_complex, NDIM > | |
| Cmadness::QProjector< double, 3 > | |
| Cmadness::QProjector< double_complex, 3 > | |
| Cmadness::StrongOrthogonalityProjector< double, 3 > | |
| Cmadness::OuterProjector< projT, projQ > | Outer product of two projectors |
| Cmadness::Projector< T, NDIM > | Simple projector class |
| Cmadness::QProjector< T, NDIM > | Orthogonality projector |
| Cmadness::StrongOrthogonalityProjector< T, NDIM > | SO projector class |
| Cmadness::ProjRLMStore | |
| ►CPropertyBase | |
| CDipoleVector | |
| CNuclearVector | |
| Cmadness::detail::ptr_traits< U > | |
| Cmadness::detail::ptr_traits< void > | Specialization of ptr_traits for type void |
| ►Cmadness::QCCalculationParametersBase | Class for holding the parameters for calculation |
| CDiracParameters | |
| CParameters | |
| Cmadness::CCParameters | |
| ►Cmadness::CalculationParameters | |
| CTestCalculationParameters | Helper class to set up a vector of possible values for a given key |
| Cmadness::Nemo::NemoCalculationParameters | Class holding parameters for a nemo calculation beyond the standard dft parameters from moldft |
| Cmadness::Complex_CIS_Parameters | |
| Cmadness::LowRankFunctionParameters | |
| Cmadness::MP2::Parameters | POD for MP2 keywords |
| Cmadness::MolecularOptimizationParameters | |
| Cmadness::Molecule::GeometryParameters | |
| Cmadness::Nemo_complex_Parameters | |
| Cmadness::OEP_Parameters | |
| ►Cmadness::PNOParameters | |
| Cmadness::F12Parameters | |
| Cmadness::PlotParameters | |
| Cmadness::ResponseParameters | |
| Cmadness::TDHF::TDHFParameters | TDHF parameter class |
| Cmadness::QCParameter | Structure holding the value for a given parameter |
| ►Cmadness::QCPropertyInterface | Class implementing properties of QC models |
| Cmadness::CC2 | |
| Cmadness::MP2 | Class for computing the first order wave function and MP2 pair energies |
| Cmadness::MolecularEnergy | |
| Cmadness::Nemo | The Nemo class |
| Cmadness::PNO | |
| Cmadness::TDHF | |
| Cmadness::Zcis | |
| Cmadness::Znemo | |
| Cmadness::qmsg | |
| Cmadness::R_times_arg_div_R | Compute the expression (\sum_i R_i)^(-1) \sum_i R_i arg(r,B,v_i) |
| Cmadness::RandomizedMatrixDecomposition< T > | |
| Cmadness::RandomState | |
| Cmadness::Range< iteratorT > | Range, vaguely a la Intel TBB, to encapsulate a random-access, STL-like start and end iterator with chunksize |
| Cmadness::real_op< Q, NDIM > | |
| Cmadness::detail::real_type< T > | |
| Cmadness::detail::real_type< std::complex< T > > | |
| Cmadness::detail::realop< NDIM > | |
| CGygiPot::Reciprocal< T, DIM > | |
| CSurfaceMoleculeInteraction::Reciprocal< T, NDIM > | |
| Cmadness::Recordlist< keyT > | |
| Cmadness::FunctionImpl< T, NDIM >::recursive_apply_op< opT, LDIM > | Recursive part of recursive_apply |
| Cmadness::FunctionImpl< T, NDIM >::recursive_apply_op2< opT > | Recursive part of recursive_apply |
| Cmadness::RecursiveMutex | Recursive mutex using pthread mutex operations |
| Cmadness::WorldGopInterface::ReduceTag | |
| Cmadness::archive::detail::Ref | |
| Crefop | |
| Crefpotfunctor | Reference potential for the Poisson solver of a Gaussian |
| Cmadness::detail::RemoteCounter | Remote reference counter |
| ►Cmadness::detail::RemoteCounterBase | Base class for remote counter implementation objects |
| Cmadness::detail::RemoteCounterImpl< T > | Remote counter implementation object |
| Cmadness::RemoteReference< T > | Simple structure used to manage references/pointers to remote instances |
| Cmadness::RemoteReference< FutureImpl< REMFUTURE(MEMFUN_RETURNT(memfunT)) > > | |
| Cmadness::RemoteReference< madness::FutureImpl< REMFUTURE(MEMFUN_RETURNT(memfunT)) > > | |
| Cmadness::RemoteReference< madness::FutureImpl< T > > | |
| Cmadness::remove_fcvr< T > | |
| Cmadness::remove_future< T > | Maps Future<T> to T |
| Cmadness::remove_future< const Future< T > & > | |
| Cmadness::remove_future< const Future< T > > | |
| Cmadness::remove_future< Future< T > & > | |
| Cmadness::remove_future< Future< T > && > | |
| Cmadness::remove_future< Future< T > > | This metafunction maps Future<T> to T |
| Cmadness::FunctionImpl< T, NDIM >::remove_internal_coeffs | Remove all coefficients of internal nodes |
| Cmadness::FunctionImpl< T, NDIM >::remove_leaf_coeffs | Remove all coefficients of leaf nodes |
| CSafeMPI::Request | |
| Cmadness::response_function_allocator | |
| Cmadness::response_matrix_allocator | |
| Cmadness::response_space | |
| Cmadness::KernelRange::Restrictor | Restrictor function |
| Cmadness::detail::result_of< fnT, Enabler > | |
| ►Cmadness::detail::result_of< decltype(&fnT::operator())> | |
| Cmadness::detail::result_of< fnT, typename std::enable_if< is_type< decltype(&fnT::operator())>::value >::type > | |
| Cmadness::detail::result_of< fnT, typename std::enable_if< function_traits< fnT >::value >::type > | |
| Cmadness::detail::result_of< fnT, typename std::enable_if< memfunc_traits< fnT >::value >::type > | |
| Cmadness::RMDFactory | Simple factory pattern for the RandomizedMatrixDecomposition |
| Cmadness::RMI | This class implements the communications server thread and provides the only send interface |
| ►Cmadness::RMISendReq | This for RMI server thread to manage lifetime of WorldAM messages that it is sending |
| Cmadness::WorldAmInterface::SendReq | |
| Cmadness::RMIStats | |
| Cmadness::Zcis::root | |
| Cmadness::ScalarResult< T > | |
| Cmadness::detail::scaleinplace< T, NDIM > | |
| Cmadness::ScalingFunctionFunctor< NDIM, Enabler > | This FunctionFunctorInterface evaluates Legendre scaling functions |
| Cmadness::SCF | |
| Cmadness::scf_data | |
| ►Cmadness::SCFOperatorBase< T, NDIM > | |
| Cmadness::Coulomb< double, 3 > | |
| Cmadness::Exchange< double, 3 > | |
| Cmadness::Fock< double, 3 > | |
| Cmadness::Kinetic< double, 3 > | |
| Cmadness::Nuclear< double, 3 > | |
| CMyDerivativeOperator< T, NDIM > | |
| Cmadness::Coulomb< T, NDIM > | |
| Cmadness::DNuclear< T, NDIM > | Derivative of the (regularized) nuclear potential wrt nuclear displacements |
| Cmadness::DerivativeOperator< T, NDIM > | |
| Cmadness::Exchange< T, NDIM > | |
| Cmadness::Fock< T, NDIM > | Computes matrix representation of the Fock operator |
| Cmadness::Kinetic< T, NDIM > | |
| Cmadness::Laplacian< T, NDIM > | Laplacian operator: \sum_i \nabla^2_i |
| Cmadness::LocalPotentialOperator< T, NDIM > | |
| Cmadness::Lz< T, NDIM > | Z component of the angular momentum |
| Cmadness::Nuclear< T, NDIM > | |
| Cmadness::XCOperator< T, NDIM > | Operator class for the handling of DFT exchange-correlation functionals |
| Cmadness::SCFOperatorBase< double, NDIM > | |
| Cmadness::SCFProtocol | Struct for running a protocol of subsequently tightening precision |
| Cmadness::ScopedMutex< mutexT > | Mutex that is applied/released at start/end of a scope |
| Cmadness::SeparatedConvolutionData< Q, NDIM > | SeparatedConvolutionData keeps data for all terms, all dimensions |
| Cmadness::SeparatedConvolutionInternal< Q, NDIM > | |
| Csgl_guess | |
| Cmadness::ShallowNode< T, NDIM > | Shallow-copy, pared-down version of FunctionNode, for special purpose only |
| Cmadness::GenericConvolution1D< Q, opT >::Shmoo | |
| CSigma_ncf_cusp | |
| Cmadness::SignedDFInterface< NDIM > | The interface for a signed distance function (sdf) |
| ►Cmadness::SignedDFInterface< 2 > | |
| Cmadness::SDFCircle | A circle (2 dimensions) |
| Cmadness::SDFRectangle | A rectangle (2 dimensions) |
| ►Cmadness::SignedDFInterface< 3 > | |
| ►Cmadness::SDFBox | A box (3 dimensions) |
| Cmadness::SDFCube | A cube (3 dimensions) |
| Cmadness::SDFCone | A cone (3 dimensions) |
| Cmadness::SDFCylinder | A cylinder (3 dimensions) |
| Cmadness::SDFEllipsoid | An ellipsoid (3 dimensions) |
| Cmadness::SDFParaboloid | A paraboloid (3 dimensions) |
| Cmadness::SDFPlane | A plane surface (3 dimensions) |
| Cmadness::SDFSphere | A spherical surface (3 dimensions) |
| Cmadness::SimpleCache< Q, NDIM > | Simplified interface around hash_map to cache stuff for 1D |
| Cmadness::SimpleCache< madness::ConvolutionData1D< Q >, 1 > | |
| Cmadness::SimpleCache< madness::ConvolutionData1D< Q >, 2 > | |
| Cmadness::SimpleCache< madness::SeparatedConvolutionData< double, NDIM >, 2 *NDIM > | |
| Cmadness::SimpleCache< madness::SeparatedConvolutionData< double, NDIM >, NDIM > | |
| Cmadness::SimpleCache< madness::SeparatedConvolutionData< Q, NDIM >, 2 *NDIM > | |
| Cmadness::SimpleCache< madness::SeparatedConvolutionData< Q, NDIM >, NDIM > | |
| Cmadness::SimpleCache< madness::SeparatedConvolutionData< T, NDIM >, 2 *NDIM > | |
| Cmadness::SimpleCache< madness::SeparatedConvolutionData< T, NDIM >, NDIM > | |
| Cmadness::SimpleCache< madness::Tensor< Q >, 1 > | |
| Cmadness::Function< T, NDIM >::SimpleUnaryOpWrapper | |
| Cslater | |
| Cmadness::apply_kernel_helper::slater_kernel | |
| Cmadness::slater_kernel | |
| Cmadness::slater_kernel_apply | |
| Cmadness::Slice | A slice defines a sub-range or patch of a dimension |
| Cmadness::SliceGenTensor< T > | |
| Cmadness::smooth< T, NDIM > | |
| Cmadness::Solver< T, NDIM > | The main class of the periodic DFT solver |
| CSolverInterface | The interface to be provided by solvers |
| Cmadness::SolverTargetInterface | The interface to be provided by targets for non-linear equation solver |
| CSolverTargetInterface | The interface to be provided by |
| ►Cmadness::Specialbox_op< T, NDIM > | |
| Cmadness::ElectronCuspyBox_op< T, NDIM > | |
| Cmadness::NuclearCuspyBox_op< T, NDIM > | |
| Cmadness::SpectralPropagator | Spectral propagtor in time. Refer to documentation of file spectralprop.h for math detail |
| Cmadness::SpectralPropagatorGaussLobatto | |
| Cmadness::spherical_box< NDIM > | 2-dimensional smooth mask that is 1 inside the radius and 0 outside |
| Cspherical_harmonic | |
| CSphericalHarmonics | Returns the complex value of a given spherical harmonic |
| ►Cmadness::Spinlock | Spinlock using pthread spinlock operations |
| Cmadness::FutureImpl< REMFUTURE(MEMFUN_RETURNT(memfunT)) > | |
| Cmadness::ConditionVariable | Scalable and fair condition variable (spins on local value) |
| Cmadness::DependencyInterface | Provides an interface for tracking dependencies |
| Cmadness::FutureImpl< T > | Implements the functionality of futures |
| Cmadness::Hash_private::bin< keyT, valueT > | |
| Cmadness::MutexFair | A scalable and fair mutex (not recursive) |
| Cmadness::MutexReaderWriter | |
| Cmadness::WorldProfileEntry | Used to store profiler info |
| CSpinor | Defines a 4-spinor |
| Cspinorallocator | |
| Cmadness::detail::squareinplace< T, NDIM > | |
| Cmadness::detail::StackBase< T, isPod > | Base class for Stack which implements basic memory operations for non-POD objects |
| ►Cmadness::detail::StackBase< T, std::is_standard_layout< T >::value &&std::is_trivial< T >::value > | |
| Cmadness::Stack< T, N > | Dynamically sized Stack with small stack size optimization |
| Cmadness::detail::StackBase< T, true > | Base class for Stack which implements basic memory operations for POD objects |
| CSafeMPI::Status | |
| Cmadness::Subspace< T, NDIM > | The SubspaceK class is a container class holding previous orbitals and residuals |
| CSubspace | Container class holding previous orbitals and residuals |
| Cmadness::SubspaceK< T, NDIM > | The SubspaceK class is a container class holding previous orbitals and residuals |
| CSurfaceMoleculeInteraction | |
| CSVPESolver | |
| Cmadness::TaggedKey< Key, Tag > | Key object that uses a tag to differentiate keys |
| Cmadness::detail::task_arg< T > | |
| Cmadness::detail::task_arg< Future< T > * > | |
| Cmadness::detail::task_arg< Future< T > > | |
| Cmadness::detail::task_arg< Future< void > > | |
| Cmadness::detail::task_arg< void > | |
| Cmadness::detail::task_result_type< fnT > | |
| ►Cmadness::TaskAttributes | Contains attributes of a task |
| ►Cmadness::PoolTaskInterface | Lowest level task interface |
| CAdder | |
| CGreet | |
| Cmadness::PoolTaskNull | A no-operation task used for various purposes |
| Cmadness::TaskInterface | All world tasks must be derived from this public interface |
| Cmadness::profiling::TaskEvent | Task event class |
| ►Cmadness::profiling::TaskEventListBase | Task event list base class |
| Cmadness::profiling::TaskEventList | A list of task events |
| Cmadness::TaskFunction< typename > | |
| Cmadness::detail::TaskHandlerInfo< refT, functionT > | Serialization container for sending tasks to remote nodes |
| Cmadness::TaskMemfun< typename > | |
| Cmadness::profiling::TaskProfiler | This class collects and prints task profiling data |
| Cmadness::TaskThreadEnv | Used to pass information about the thread environment to a user's task |
| CTbar_omega | Computes term k at quadrature point t in infinte Fourier-space sum defining Tbar |
| Cmadness::TDHF_allocator | |
| CPNOTensors::Tensor_IJ_IK< T > | |
| CPNOTensors::Tensor_IJ_IK< double > | |
| CPNOTensors::Tensor_IJ_KJ< T > | |
| CPNOTensors::Tensor_IJ_KJ< double > | |
| Cmadness::TensorArgs | TensorArgs holds the arguments for creating a LowRankTensor |
| Cmadness::TensorIterator< T, Q, R > | |
| Cmadness::TensorResultType< leftT, rightT > | TensorResultType<L,R>::type is the type of (L op R) where op is nominally multiplication |
| Cmadness::TensorTypeData< T > | Traits class to specify support of numeric types |
| Cmadness::TensorTypeFromId< id > | This provides the reverse mapping from integer id to type name |
| Ctest_multiop< T, NDIM > | |
| Cmadness::test_output | Small class for pretty printing of test output |
| ►Cmadness::ThreadBase | Simplified thread wrapper to hide pthread complexity |
| CPeasant | |
| CWorker | |
| ►Cmadness::Thread | Simplified thread wrapper to hide pthread complexity |
| Cmadness::ThreadPoolThread | ThreadPool thread object |
| Cmadness::ThreadBinder | |
| Cmadness::ThreadPool | A singleton pool of threads for dynamic execution of tasks |
| Cmadness::timer | |
| Cmadness::Timer | |
| Cmadness::Znemo::timer | |
| Cmadness::trajectory< NDIM > | |
| Cmadness::SeparatedConvolution< Q, NDIM >::Transformation | Too lazy for extended calling lists |
| Ctrue_if_n_gt_op | |
| Cmadness::true_op< NDIM > | |
| Ctrue_op | |
| Cmadness::FunctionImpl< T, NDIM >::true_refine_test | |
| ►Cstd::true_type | |
| Cmadness::Cloud::is_madness_function_vector< std::vector< Function< T, NDIM > > > | |
| Cmadness::Cloud::is_tuple< std::tuple< T... > > | |
| Cmadness::Cloud::is_vector< std::vector< Q > > | |
| Cmadness::MacroTask< taskT >::is_vector< std::vector< Q > > | |
| Cmadness::detail::is_arg_holder< ArgHolder< T > > | |
| Cmadness::detail::is_functor< fnT, typename std::enable_if< is_type< typename fnT::result_type >::value >::type > | |
| Cmadness::detail::is_type< typename > | |
| Cmadness::is_any_function_pointer< T, std::enable_if_t< std::is_member_function_pointer< T >::value||is_function_pointer_v< T > > > | |
| Cmadness::is_archive< archive::BinaryFstreamInputArchive > | |
| Cmadness::is_archive< archive::BinaryFstreamOutputArchive > | |
| Cmadness::is_archive< archive::BufferInputArchive > | |
| Cmadness::is_archive< archive::BufferOutputArchive > | |
| Cmadness::is_archive< archive::ContainerRecordInputArchive > | |
| Cmadness::is_archive< archive::ContainerRecordOutputArchive > | |
| Cmadness::is_archive< archive::MPIInputArchive > | |
| Cmadness::is_archive< archive::MPIOutputArchive > | |
| Cmadness::is_archive< archive::MPIRawInputArchive > | |
| Cmadness::is_archive< archive::MPIRawOutputArchive > | |
| Cmadness::is_archive< archive::ParallelInputArchive< localarchiveT > > | |
| Cmadness::is_archive< archive::ParallelOutputArchive< localarchiveT > > | |
| Cmadness::is_archive< archive::TextFstreamInputArchive > | |
| Cmadness::is_archive< archive::TextFstreamOutputArchive > | |
| Cmadness::is_archive< archive::VectorInputArchive > | |
| Cmadness::is_archive< archive::VectorOutputArchive > | |
| Cmadness::is_default_serializable_helper< Archive, archive::archive_array< T >, std::enable_if_t< is_default_serializable_helper< Archive, T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::BinaryFstreamInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::BinaryFstreamOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::BufferInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::BufferOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::ContainerRecordInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::ContainerRecordOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::MPIInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::MPIOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::MPIRawInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::MPIRawOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::ParallelInputArchive< localarchiveT >, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::ParallelOutputArchive< localarchiveT >, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::TextFstreamInputArchive, T, std::enable_if_t< is_iostreammable_v< T >||is_any_function_pointer_v< T > > > | |
| Cmadness::is_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 > > > | |
| Cmadness::is_default_serializable_helper< archive::VectorInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_default_serializable_helper< archive::VectorOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > | |
| Cmadness::is_function_pointer< T, std::enable_if_t< std::is_function< typename std::remove_pointer< T >::type >::value > > | |
| Cmadness::is_future< Future< T > > | |
| Cmadness::is_input_archive< archive::BinaryFstreamInputArchive > | |
| Cmadness::is_input_archive< archive::BufferInputArchive > | |
| Cmadness::is_input_archive< archive::ContainerRecordInputArchive > | |
| Cmadness::is_input_archive< archive::MPIInputArchive > | |
| Cmadness::is_input_archive< archive::MPIRawInputArchive > | |
| Cmadness::is_input_archive< archive::ParallelInputArchive< localarchiveT > > | |
| Cmadness::is_input_archive< archive::TextFstreamInputArchive > | |
| Cmadness::is_input_archive< archive::VectorInputArchive > | |
| Cmadness::is_madness_function< madness::Function< T, NDIM > > | |
| Cmadness::is_madness_function_vector< std::vector< typename madness::Function< T, NDIM > > > | |
| Cmadness::is_output_archive< archive::BinaryFstreamOutputArchive > | |
| Cmadness::is_output_archive< archive::BufferOutputArchive > | |
| Cmadness::is_output_archive< archive::ContainerRecordOutputArchive > | |
| Cmadness::is_output_archive< archive::MPIOutputArchive > | |
| Cmadness::is_output_archive< archive::MPIRawOutputArchive > | |
| Cmadness::is_output_archive< archive::ParallelOutputArchive< localarchiveT > > | |
| Cmadness::is_output_archive< archive::TextFstreamOutputArchive > | |
| Cmadness::is_output_archive< archive::VectorOutputArchive > | |
| Cmadness::is_scalar_result< madness::ScalarResult< T > > | |
| Cmadness::is_scalar_result< madness::ScalarResultImpl< T > > | |
| Cmadness::is_scalar_result_ptr< std::shared_ptr< madness::ScalarResultImpl< T > > > | |
| Cmadness::is_scalar_result_ptr_vector< std::vector< std::shared_ptr< typename madness::ScalarResultImpl< T > > > > | |
| Cmadness::is_scalar_result_vector< std::vector< typename madness::ScalarResult< T > > > | |
| Cmadness::is_text_archive< archive::TextFstreamInputArchive > | |
| Cmadness::is_text_archive< archive::TextFstreamOutputArchive > | |
| Cmadness::is_tuple< std::tuple< T... > > | |
| Cmadness::is_vector< std::vector< Q > > | |
| Cmadness::meta::conjunction<... > | |
| CTTT | |
| ►Cmadness::TwoBodyFunctionComponentBase | |
| Cmadness::TwoBodyFunctionPureComponent< T, NDIM > | Two-body, explicitly 6-dimensional function |
| Cmadness::TwoBodyFunctionSeparatedComponent< T, NDIM > | |
| Cmadness::twoscale_cache_class | |
| Ctype_printer< T > | |
| Cmadness::meta::typelist< P > | |
| Cmadness::unaryexp< NDIM > | |
| Cunaryexp< T, NDIM > | |
| Cunaryexp< double_complex, NDIM > | |
| Cmadness::UnaryOpStructure< NDIM > | Computes the corrected exchange correlation potential using the multipole approximation |
| Cmadness::uniqueidT | Class for unique global IDs |
| CUop | |
| Cmadness::valarray_allocator | |
| Cmadness::Vector< T, N > | A simple, fixed dimension vector |
| Cmadness::Vector< double, 3 > | |
| Cmadness::Vector< double, NDIM > | |
| Cmadness::Vector< Translation, NDIM > | |
| Cmadness::vector_function_allocator< T, NDIM > | |
| Cmadness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM > | Given a ket and the 1- and 2-electron potentials, construct the function V phi |
| Cw_file | |
| CWalker1 | |
| Cmadness::WorldAbsMaxOp< T > | |
| Cmadness::WorldAbsMinOp< T > | |
| Cmadness::WorldBitAndOp< T > | |
| Cmadness::WorldBitOrOp< T > | |
| Cmadness::WorldBitXorOp< T > | |
| Cmadness::WorldContainerIterator< internal_iteratorT > | Iterator for distributed container wraps the local iterator |
| ►Cmadness::WorldDCPmapInterface< keyT > | Interface to be provided by any process map |
| Cmadness::LevelPmap< keyT > | A pmap that locates children on odd levels with their even level parents |
| Cmadness::SimplePmap< keyT > | A simple process map |
| Cmadness::WorldDCDefaultPmap< keyT, hashfunT > | Default process map is "random" using madness::hash(key) |
| Cmadness::WorldDCLocalPmap< keyT, hashfunT > | Local process map will always return the current process as owner |
| ►Cmadness::WorldDCPmapInterface< int > | |
| CTestPmap | |
| ►Cmadness::WorldDCPmapInterface< Key< 3 > > | |
| CLevelPmap | |
| CLevelPmap | |
| CLevelPmapX | |
| CPartitionPmap | A pmap that spatially decomposes the domain and by default slightly overdcomposes to attempt to load balance |
| ►Cmadness::WorldDCPmapInterface< Key< D > > | |
| Cmadness::MyPmap< D > | Procmap implemented using Tree of TreeCoords |
| ►Cmadness::WorldDCPmapInterface< Key< NDIM > > | |
| Cmadness::LBDeuxPmap< NDIM > | |
| ►Cmadness::WorldDCRedistributeInterface< keyT > | |
| Cmadness::WorldContainerImpl< keyT, valueT, hashfunT > | Internal implementation of distributed container to facilitate shallow copy |
| Cmadness::WorldGopInterface | Provides collectives that interoperate with the AM and task interfaces |
| CSafeMPI::Intracomm::WorldInitObject | |
| Cmadness::WorldLogicAndOp< T > | |
| Cmadness::WorldLogicOrOp< T > | |
| Cmadness::WorldMaxOp< T > | |
| Cmadness::WorldMemInfo | Used to output memory statistics and control tracing, etc |
| Cmadness::WorldMinOp< T > | |
| Cmadness::detail::WorldMpi | MPI singleton that manages MPI setup and teardown for MADNESS |
| ►Cmadness::detail::WorldMpiRuntime | MPI runtime reference counter |
| Cmadness::WorldMpiInterface | This class wraps/extends the MPI interface for World |
| Cmadness::WorldMultOp< T > | |
| ►Cmadness::WorldObjectBase | Base class for WorldObject, useful for introspection |
| ►Cmadness::WorldObject< Array > | |
| CArray | |
| CArray | |
| CArray | |
| CArray | |
| ►Cmadness::WorldObject< Foo > | |
| CFoo | |
| CFoo | |
| ►Cmadness::WorldObject< TestFutureForwarding > | |
| CTestFutureForwarding | |
| ►Cmadness::WorldObject< BinSorter< T, inserterT > > | |
| Cmadness::BinSorter< T, inserterT > | A parallel bin sort across MPI processes |
| ►Cmadness::WorldObject< DerivativeBase< T, NDIM > > | |
| ►Cmadness::DerivativeBase< T, NDIM > | Tri-diagonal operator traversing tree primarily for derivative operator |
| Cmadness::Derivative< T, NDIM > | Implements derivatives operators with variety of boundary conditions on simulation domain |
| ►Cmadness::WorldObject< FunctionImpl< T, NDIM > > | |
| Cmadness::FunctionImpl< T, NDIM > | FunctionImpl holds all Function state to facilitate shallow copy semantics |
| Cmadness::WorldObject< SeparatedConvolution< double, NDIM > > | |
| ►Cmadness::WorldObject< MacroTaskQ > | |
| Cmadness::MacroTaskQ | |
| ►Cmadness::WorldObject< ScalarResultImpl< T > > | |
| Cmadness::ScalarResultImpl< T > | Helper class for returning the result of a task, which is not a madness Function, but a simple scalar |
| ►Cmadness::WorldObject< SeparatedConvolution< Q, NDIM > > | |
| Cmadness::SeparatedConvolution< Q, NDIM > | Convolutions in separated form (including Gaussian) |
| ►Cmadness::WorldObject< WorldContainerImpl< keyT, valueT, hashfunT > > | |
| Cmadness::WorldContainerImpl< keyT, valueT, hashfunT > | Internal implementation of distributed container to facilitate shallow copy |
| Cmadness::WorldObject< SeparatedConvolution< T, NDIM > > | |
| Cmadness::WorldObject< FunctionImpl< Q, NDIM > > | |
| Cmadness::WorldObject< FunctionImpl< R, NDIM > > | |
| ►Cmadness::WorldObject< Derived > | Implements most parts of a globally addressable object (via unique ID) |
| Cmadness::FunctionImpl< Q, NDIM > | |
| Cmadness::FunctionImpl< R, NDIM > | |
| Cmadness::SeparatedConvolution< double, NDIM > | |
| Cmadness::SeparatedConvolution< double, 3 > | |
| Cmadness::SeparatedConvolution< T, NDIM > | |
| Cmadness::detail::WorldObjectTaskHelper< objT, memfnT, Enabler > | |
| Cmadness::detail::WorldObjectTaskHelper< objT, memfnT, typename std::enable_if< std::is_base_of< std::enable_shared_from_this< objT >, objT >::value >::type > | |
| Cmadness::WorldProfile | Singleton-like class for holding profiling data and functionality |
| Cmadness::WorldProfileObj | |
| Cmadness::detail::WorldPtr< T > | A global pointer address, valid anywhere in the world |
| Cmadness::detail::WorldPtr< madness::detail::RemoteCounterBase > | |
| Cmadness::WorldSumOp< T > | |
| Cmolresponse::write_response_input | Will write a test input and remove it from disk upon destruction |
| Cmadness::write_test_input | Will write a test input and remove it from disk upon destruction |
| Cmolresponse::write_test_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 |
| CWSTFunctional | |
| CwstFunctor< Q > | |
| ►Cmadness::X_space | |
| Cmadness::X_vector | |
| Cmadness::xc_functional | Class to compute the energy functional |
| Cmadness::xc_kernel_apply | Class to compute terms of the kernel |
| Cmadness::xc_lda_potential | Compute the spin-restricted LDA potential using unaryop (only for the initial guess) |
| Cmadness::xc_potential | Class to compute terms of the potential |
| Cxcfunc_data_point | |
| Cmadness::XCfunctional | Simplified interface to XC functionals |
| CXi | Following Dyall: p 104f |
| Cmadness::XNonlinearSolver< T, C, Alloc > | Generalized version of NonlinearSolver not limited to a single madness function |
| Cmadness::RandomizedMatrixDecomposition< T >::Y_former | Functor for forming Y = matrix * randomvector |
| CYetAnotherWrapperClass | |
1.9.8
