| Cmadness::abs_op< Q, NDIM > | |
| Cmadness::abs_square_op< Q, NDIM > | |
| Cmadness::detail::absinplace< T, 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::tr1::add_const< T > | Add_const<T>::type will be const T |
| Cmadness::tr1::add_const< const T > | Add_const<T>::type will be const T |
| Cmadness::FunctionImpl< T, NDIM >::add_op | Add two functions f and g: result=alpha * f + beta * g |
| Cstd::tr1::gtest_internal::AddRef< T > | |
| Cstd::tr1::gtest_internal::AddRef< T & > | |
| Ctesting::internal::AddReference< T > | |
| Ctesting::internal::AddReference< T & > | |
| Cmadness::detail::adqtest | |
| Cmadness::allocator< T, NDIM > | |
| Cmadness::AmArg | World active message that extends an RMI message |
| CAtomicBasisSet::AnalysisSorter< T > | |
| Cmadness::AtomicBasisSet::AnalysisSorter< T > | |
| Cmadness::apply_kernel_functor | |
| Cmadness::archive::archive_array< T > | Wrapper for dynamic arrays and pointers |
| Cmadness::archive::archive_ptr< T > | Wrapper for opaque pointer ... bitwise copy of the pointer ... no remapping performed |
| Cmadness::archive::archive_typeinfo< T > | |
| Cmadness::archive::ArchiveImpl< Archive, T > | Default implementation of wrap_store and wrap_load |
| Cmadness::archive::ArchiveImpl< Archive, archive_array< T > > | Partial specialization for archive_array |
| Cmadness::archive::ArchiveImpl< Archive, T[n]> | Partial specialization for fixed dimension array redirects to archive_array |
| Cmadness::archive::ArchiveImpl< ParallelInputArchive, archive_array< T > > | Read archive array and broadcast |
| Cmadness::archive::ArchiveImpl< ParallelInputArchive, T > | |
| Cmadness::archive::ArchiveImpl< ParallelInputArchive, T[n]> | Forward fixed size array to archive_array |
| Cmadness::archive::ArchiveImpl< ParallelOutputArchive, archive_array< T > > | Write archive array only from process zero |
| Cmadness::archive::ArchiveImpl< ParallelOutputArchive, T > | |
| Cmadness::archive::ArchiveImpl< ParallelOutputArchive, T[n]> | Forward fixed size array to archive_array |
| Cmadness::archive::ArchiveLoadImpl< Archive, T > | Default load of a thingy via serialize(ar,t) |
| 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 > > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, FunctionImpl< T, NDIM > * > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, Future< T > > | Deserialize a future into an unassigned future |
| Cmadness::archive::ArchiveLoadImpl< Archive, Future< void > > | Deserialize a future into an unassigned future |
| Cmadness::archive::ArchiveLoadImpl< Archive, Future< Void > > | Deserialize a future into an unassigned future |
| Cmadness::archive::ArchiveLoadImpl< Archive, GenTensor< T > > | Deserialize a tensor ... existing tensor is replaced |
| Cmadness::archive::ArchiveLoadImpl< Archive, Key< NDIM > > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::array< T, N > > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::complex< T > > | Deserialize a complex number |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::map< T, Q > > | Deserialize an STL map. Map is NOT cleared; duplicate elements are replaced |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::shared_ptr< const FunctionImpl< T, NDIM > > > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::shared_ptr< FunctionImpl< T, NDIM > > > | |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::string > | Deserialize STL string. Clears & resizes as necessary |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::vector< bool > > | Deserialize STL vector<bool>. Clears & resizes as necessary |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::vector< Future< T > > > | Deserialize a future into an unassigned future |
| Cmadness::archive::ArchiveLoadImpl< Archive, std::vector< T > > | Deserialize STL vector. Clears & resizes as necessary |
| Cmadness::archive::ArchiveLoadImpl< Archive, Tensor< T > > | Deserialize a tensor ... existing tensor is replaced |
| Cmadness::archive::ArchiveLoadImpl< Archive, World * > | |
| Cmadness::archive::ArchiveLoadImpl< BinaryFstreamInputArchive, Key< NDIM > > | |
| Cmadness::archive::ArchiveLoadImpl< BufferInputArchive, const WorldObject< Derived > * > | |
| Cmadness::archive::ArchiveLoadImpl< BufferInputArchive, WorldObject< Derived > * > | |
| Cmadness::archive::ArchiveLoadImpl< ParallelInputArchive, Function< T, NDIM > > | |
| Cmadness::archive::ArchiveLoadImpl< ParallelInputArchive, WorldContainer< keyT, valueT > > | |
| Cmadness::archive::ArchivePrePostImpl< Archive, T > | Default implementation of pre/postamble |
| Cmadness::archive::ArchivePrePostImpl< BufferInputArchive, T > | |
| Cmadness::archive::ArchivePrePostImpl< BufferOutputArchive, T > | |
| Cmadness::archive::ArchivePrePostImpl< MPIInputArchive, T > | |
| Cmadness::archive::ArchivePrePostImpl< MPIOutputArchive, T > | |
| Cmadness::archive::ArchivePrePostImpl< MPIRawInputArchive, T > | |
| Cmadness::archive::ArchivePrePostImpl< MPIRawOutputArchive, T > | |
| Cmadness::archive::ArchivePrePostImpl< ParallelInputArchive, T > | Disable type info for parallel input archives |
| Cmadness::archive::ArchivePrePostImpl< ParallelOutputArchive, T > | Disable type info for parallel output archives |
| Cmadness::archive::ArchivePrePostImpl< TextFstreamInputArchive, T > | |
| Cmadness::archive::ArchivePrePostImpl< TextFstreamOutputArchive, T > | |
| Cmadness::archive::ArchiveSerializeImpl< Archive, T > | Default symmetric serialization of a non-fundamental thingy |
| Cmadness::archive::ArchiveSerializeImpl< Archive, std::pair< T, Q > > | (de)Serialize an STL pair |
| Cmadness::archive::ArchiveStoreImpl< Archive, T > | Default store of a thingy via serialize(ar,t) |
| 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 > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, FunctionImpl< T, NDIM > * > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, Future< T > > | Serialize an assigned future |
| Cmadness::archive::ArchiveStoreImpl< Archive, Future< void > > | Serialize an assigned future |
| Cmadness::archive::ArchiveStoreImpl< Archive, Future< Void > > | Serialize an assigned future |
| Cmadness::archive::ArchiveStoreImpl< Archive, GenTensor< T > > | Serialize a tensor |
| Cmadness::archive::ArchiveStoreImpl< Archive, Key< NDIM > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::array< T, N > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::complex< T > > | Serialize a complex number |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::map< T, Q > > | Serialize an STL map (crudely) |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::shared_ptr< const FunctionImpl< T, NDIM > > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::shared_ptr< FunctionImpl< T, NDIM > > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::string > | Serialize STL string |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::vector< bool > > | Serialize STL vector<bool> (as plain array of bool) |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::vector< Future< T > > > | |
| Cmadness::archive::ArchiveStoreImpl< Archive, std::vector< T > > | Serialize STL vector |
| Cmadness::archive::ArchiveStoreImpl< Archive, Tensor< T > > | Serialize a tensor |
| Cmadness::archive::ArchiveStoreImpl< Archive, World * > | |
| Cmadness::archive::ArchiveStoreImpl< BufferOutputArchive, const WorldObject< Derived > * > | |
| Cmadness::archive::ArchiveStoreImpl< BufferOutputArchive, WorldObject< Derived > * > | |
| Cmadness::archive::ArchiveStoreImpl< ParallelOutputArchive, Function< T, NDIM > > | |
| Cmadness::archive::ArchiveStoreImpl< ParallelOutputArchive, WorldContainer< keyT, valueT > > | Write container to parallel archive with optional fence |
| Cmadness::detail::ArgCountHelper< T > | |
| Cmadness::detail::ArgCountHelper< void > | |
| Cmadness::tr1::array::array< T, N > | Array idential to C++0X arrays |
| Cmadness::tr1::array::array< double, N > | |
| Cmadness::tr1::array::array< function, N > | |
| Cmadness::tr1::array::array< Function< double, 3 >, N > | |
| Cmadness::tr1::array::array< int, N > | |
| Cmadness::tr1::array::array< real_tensor, 118 > | |
| Cmadness::tr1::array::array< std::complex< double >, N > | |
| Cmadness::tr1::array::array< std::shared_ptr< madness::Convolution1D< Q > >, NDIM > | |
| Cmadness::tr1::array::array< T, 0 > | |
| Cmadness::tr1::array::array< Translation, N > | |
| Ctesting::internal::AssertHelper | |
| Ctesting::AssertionResult | |
| ►Cmadness::Atom | |
| CHydrogen | Hydrogen atom |
| CAtom | Abstract Atom class |
| Cmadness::AtomCore | |
| CAtomCore | |
| 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+inc, read+dec, dec+test operations |
| Cmadness::Function< T, NDIM >::autorefine_square_op | |
| Cmadness::Barrier | |
| ►Cmadness::archive::BaseArchive | Base class for all archives classes |
| ►Cmadness::archive::BaseInputArchive | Base class for input archives classes |
| Cmadness::archive::BinaryFstreamInputArchive | Wraps an archive around a binary file stream for input |
| Cmadness::archive::BufferInputArchive | Wraps an archive around a memory buffer for input |
| Cmadness::archive::MPIInputArchive | |
| Cmadness::archive::MPIRawInputArchive | |
| Cmadness::archive::ParallelInputArchive | An archive for storing local or parallel data wrapping BinaryFstreamInputArchive |
| Cmadness::archive::TextFstreamInputArchive | Wraps an archive around a text file stream for input |
| Cmadness::archive::VectorInputArchive | Wraps an archive around an STL vector for input |
| ►Cmadness::archive::BaseOutputArchive | Base class for output archives classes |
| Cmadness::archive::BinaryFstreamOutputArchive | Wraps an archive around a binary file stream for output |
| Cmadness::archive::BufferOutputArchive | Wraps an archive around a memory buffer for output |
| Cmadness::archive::MPIOutputArchive | |
| Cmadness::archive::MPIRawOutputArchive | |
| Cmadness::archive::ParallelOutputArchive | An archive for storing local or parallel data wrapping BinaryFstreamOutputArchive |
| Cmadness::archive::TextFstreamOutputArchive | Wraps an archive around a text file stream 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::BaseParallelArchive< BinaryFstreamInputArchive > | |
| Cmadness::archive::ParallelInputArchive | An archive for storing local or parallel data wrapping BinaryFstreamInputArchive |
| ►Cmadness::archive::BaseParallelArchive< BinaryFstreamOutputArchive > | |
| Cmadness::archive::ParallelOutputArchive | An archive for storing local or parallel data wrapping BinaryFstreamOutputArchive |
| ►Cmadness::BaseTensor | The base class for tensors defines generic capabilities |
| ►Cmadness::Tensor< T > | A tensor is a multidimension array |
| Cmadness::GenTensor< T > | |
| Cmadness::BindNullaryConstMemFun< T, resultT > | Simple binder for const member functions with no arguments |
| Cmadness::BindNullaryConstMemFun< T, void > | Specialization of BindNullaryConstMemFun for void return |
| Cmadness::BindNullaryMemFun< T, resultT > | Simple binder for member functions with no arguments |
| Cmadness::BindNullaryMemFun< T, void > | Specialization of BindNullaryMemFun for void return |
| ►Ctesting::internal::bool_constant< bool_value > | |
| Ctesting::internal::is_pointer< T > | |
| Ctesting::internal::is_pointer< T * > | |
| ►Ctesting::internal::bool_constant< ImplicitlyConvertible< const T *, const ::ProtocolMessage * >::value||ImplicitlyConvertible< const T *, const ::proto2::Message * >::value > | |
| Ctesting::internal::IsAProtocolMessage< T > | |
| Cmadness::BoundaryConditions< NDIM > | This class is used to specify boundary conditions for all operatorsExterior boundary conditions (i.e., on the simulation domain) are associated with operators (not functions). The types of boundary conditions available are in the enum BCType |
| Cmadness::BoundaryConditions< 3 > | |
| Cmadness::BoundaryConditions< 6 > | |
| Cstd::tr1::gtest_internal::ByRef< T > | |
| Cstd::tr1::gtest_internal::ByRef< T & > | |
| Cmadness::CalculationParameters | |
| ►Cmadness::CallbackInterface | This class used for callbacks (e.g., for dependency tracking) |
| ►Cmadness::DependencyInterface | Provides interface for tracking dependencies |
| Cmadness::Future< std::vector< Future< T > > > | Specialization of Future for vector of Futures |
| ►Cmadness::TaskInterface | All world tasks must be derived from this public interface |
| Cmadness::detail::ForEachRootTask< rangeT, opT > | Apply an operation to a range of iterators |
| Cmadness::detail::ForEachTask< rangeT, opT > | Apply an operation to a range of iterators |
| 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 |
| Cmadness::LocalizeBoys< T > | |
| Cmadness::SystolicMatrixAlgorithm< T > | Base class for parallel algorithms that employ a systolic loop to generate all row pairs in parallel |
| Cmadness::TaskFn< fnT, arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T > | Wrap a callable object and its arguments into a task function |
| Cmadness::SystolicMatrixAlgorithm< double > | |
| Cmadness::SystolicMatrixAlgorithm< double > | |
| Cmadness::WorldTaskQueue | Multi-threaded queue to manage and run tasks |
| CCFFT | |
| Cmadness::detail::CheckedArrayDeleter< T > | Checked array pointer delete functor |
| Cmadness::detail::CheckedDeleter< T > | Checked pointer delete functor |
| Cmadness::detail::CheckedFree< T > | Deleter to free memory for a shared_ptr using free() |
| Cmadness::CIS | Holds all machinery to compute excited state properties |
| 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 > | |
| Ctesting::internal::CompileAssert< bool > | |
| Ctesting::internal::CompileAssertTypesEqual< T1, T2 > | |
| Ctesting::internal::CompileAssertTypesEqual< T, T > | |
| 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 >, Q > | |
| Cmadness::ConcurrentHashMap< Key< NDIM >, Tensor< Q > > | |
| Cmadness::ConcurrentHashMap< uniqueidT, void *, uniqueidT > | |
| 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 |
| Cmadness::conj_op< Q, NDIM > | |
| Cmadness::tr1::shptr::detail::const_cast_tag | |
| Ctesting::internal::ConstCharPtr | |
| 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) |
| CCoreOrbital | |
| Cmadness::CoreOrbital | |
| Cmadness::CorePotential | Represents a core potential |
| CCorePotential | Represents a core potential |
| CCorePotentialManager | |
| Cmadness::CorePotentialManager | |
| Cmadness::LoadBalanceDeux< NDIM >::CostPerProc | |
| CCoupledPurturbation | |
| CCubicInterpolationTable< T > | An class for 1-D data interpolation based on cubic polynomials |
| CCubicInterpolationTable< complexd > | |
| CCubicInterpolationTable< double > | |
| CCubicInterpolationTable< double_complex > | |
| Cmadness::default_allocator< T > | |
| Cmadness::detail::DefaultInitPtr< T > | |
| Cmadness::detail::DefaultInitPtr< std::shared_ptr< T > > | |
| Cmadness::detail::DeferredCleanup | Deferred cleanup of shared_ptr's |
| Cmadness::DeferredDeleter< ptrT, deleterT > | Deferred deleter for smart pointers |
| CDFTSolventSolver | |
| CDirichletLBCost< NDIM > | |
| Cmadness::disable_if_c< B, returnT > | Disable_if from Boost for conditionally instantiating templates based on type |
| ►Cmadness::disable_if_c< Cond::value, returnT > | |
| Cmadness::disable_if< Cond, returnT > | Disable_if from Boost for conditionally instantiating templates based on type |
| Cmadness::disable_if_c< true, returnT > | Disable_if from Boost for conditionally instantiating templates based on type |
| 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::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_consolidate_buffer | |
| Cmadness::FunctionImpl< T, NDIM >::do_convert_to_color | |
| Cmadness::FunctionImpl< T, NDIM >::do_err_box< opT > | |
| Cmadness::FunctionImpl< T, NDIM >::do_gaxpy_inplace< Q, R > | |
| Cmadness::FunctionImpl< T, NDIM >::do_inner_ext_local | |
| 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_keep_sum_coeffs | Keep only the sum coefficients in each node |
| Cmadness::FunctionImpl< T, NDIM >::do_mapdim | Map this on f |
| Cmadness::FunctionImpl< T, NDIM >::do_merge_trees< Q, R > | Merge the coefficent boxes of this into other's tree |
| Cmadness::FunctionImpl< T, NDIM >::do_norm2sq_local | |
| Cmadness::FunctionImpl< T, NDIM >::do_op_args< OPDIM > | Laziness |
| 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 |
| Cmadness::DQStats | |
| Cmadness::tr1::shptr::detail::dynamic_cast_tag | |
| Cmadness::EigSolver< T, NDIM > | |
| ►Cmadness::EigSolverOp< 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::tr1::enable_if< B, returnT > | Std::enable_if is similar to boost::enable_if_c for conditionally instantiating templates based on type |
| Cmadness::tr1::enable_if< false, returnT > | Std::enable_if is similar to boost::enable_if_c for conditionally instantiating templates based on type |
| Cmadness::enable_if_c< B, returnT > | Enable_if_c from Boost for conditionally instantiating templates based on type |
| ►Cmadness::enable_if_c< Cond::value, returnT > | |
| Cmadness::enable_if< Cond, returnT > | Enable_if from Boost for conditionally instantiating templates based on type |
| Cmadness::enable_if_c< false, returnT > | Enable_if_c from Boost for conditionally instantiating templates based on type |
| Cmadness::tr1::shptr::detail::enable_if_convertible_impl< bool > | |
| Cmadness::tr1::shptr::detail::enable_if_convertible_impl< false > | |
| ►Cmadness::tr1::shptr::detail::enable_if_convertible_impl< sp_convertible< Y, T >::value > | |
| Cmadness::tr1::shptr::detail::enable_if_convertible< Y, T > | |
| Cmadness::tr1::shptr::detail::enable_if_convertible_impl< true > | |
| Cmadness::tr1::shptr::enable_shared_from_this< T > | |
| Cmadness::tr1::shptr::enable_shared_from_this2< T > | |
| Ctesting::internal::EnableIf< bool > | |
| Ctesting::internal::EnableIf< true > | |
| CEnvelopedPulse | |
| Ctesting::Environment | |
| Ctesting::internal::EqHelper< lhs_is_null_literal > | |
| Ctesting::internal::EqHelper< true > | |
| Cmadness::error_leaf_op< T, NDIM > | Returns true if the node is well represented compared to its parent |
| Cmadness::tr1::shptr::detail::esft2_deleter_wrapper | |
| CExampleClass1 | Every class should be documented (this is the brief line) |
| CExampleClass2 | Brief documentation of second example class in group |
| ►Cexception | |
| Cmadness::MadnessException | Most exceptions thrown in MADNESS should be derived from these |
| Cmadness::TensorException | Tensor is intended to throw only TensorExceptions |
| Cmadness::tr1::shptr::bad_weak_ptr | |
| Cmpfr::conversion_overflow | |
| CSafeMPI::Exception | SafeMPI exception object |
| Cmadness::exoperators | |
| Ctesting::internal::FilePath | |
| Ctesting::internal::FloatingPoint< RawType > | |
| Ctesting::internal::FormatForComparison< ToPrint, OtherOperand > | |
| Ctesting::internal::FormatForComparison< ToPrint[N], OtherOperand > | |
| CFrequencyHandler | |
| Cmadness::function_real2complex_op< Q, NDIM > | |
| Cmadness::tr1::detail::function_traits< returnT(*)()> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T)> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T, arg2T)> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T, arg2T, arg3T)> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T, arg2T, arg3T, arg4T)> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T, arg2T, arg3T, arg4T, arg5T)> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T)> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T)> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T)> | Function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::function_traits< returnT(*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T)> | Function traits in the spirt of boost function traits |
| Cmadness::FunctionCommonData< T, NDIM > | FunctionCommonData holds all Function data common for given k |
| Cmadness::FunctionCommonData< double, NDIM > | |
| Cmadness::FunctionCommonData< Q, NDIM > | |
| Cmadness::FunctionCommonData< R, NDIM > | |
| Cmadness::FunctionCommonData< std::complex< double >, NDIM > | |
| 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::FGFactory< T, NDIM > | Factory to set up an ElectronRepulsion Function |
| ►Cmadness::FunctionFactory< double, 6 > | |
| Cmadness::TwoElectronFactory | Factory for generating TwoElectronInterfaces |
| ►Cmadness::FunctionFunctorInterface< T, NDIM > | Abstract base class interface required for functors used as input to Functions |
| 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 |
| CParserHandler< T, NDIM > | |
| ►Cmadness::FunctionFunctorInterface< complexd, NDIM > | |
| ►CbaseWF | |
| CBoundWF | |
| CExpikr | |
| CGaussian | |
| ►CScatteringWF | |
| CPhiK | |
| CPhikl | |
| ►Cmadness::FunctionFunctorInterface< double, 3 > | |
| CFrequencyIncident | |
| Cgauss_function | Gauss_function structure is needed to mimic noise |
| CGaussian | |
| ►CGaussianBF | Abstract Gaussian basis function. Must be overriden to specify angular momenta (s, p, d, etc.) |
| CDBF | A d basis function |
| CPBF | A p basis function |
| CSBF | An s basis function |
| Cmadness::AtomicBasisFunctor | |
| Cmadness::CoreOrbitalDerivativeFunctor | |
| Cmadness::CoreOrbitalFunctor | |
| Cmadness::CorePotentialDerivativeFunctor | |
| Cmadness::diffuse_functions | Functor that adds diffuse 1s functions on given coordinates with given signs (phases) |
| 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::MolecularDerivativeFunctor | |
| Cmadness::MolecularGuessDensityFunctor | |
| 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::ProjRLMFunctor | |
| Cmadness::Solver< T, NDIM >::GuessDensity | |
| Cmadness::VLocalFunctor | |
| CMolecularNuclearChargeDensityFunctor | |
| CMolecularNuclearChargeDensityFunctor | |
| 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 | |
| Cnoise | Try to create noise using random gauss functions |
| CTimeIncident | |
| CTipMolecule | Setup the tip-molecule problem |
| Cmadness::FunctionFunctorInterface< double, 6 > | |
| ►Cmadness::FunctionFunctorInterface< double, NDIM > | |
| Cmadness::DomainMaskSDFFunctor< NDIM > | Framework for combining a signed distance function (sdf) with a domain mask to produce MADNESS functions |
| ►Cmadness::TwoElectronInterface< double, 6 > | |
| Cmadness::BSHFunctionInterface | Function like f(x) = exp(-mu x)/x |
| Cmadness::ElectronRepulsionInterface | Function like f(x)=1/x |
| Cmadness::FGInterface | Function like f(x) = (1 - 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) |
| CYl0 | |
| ►Cmadness::FunctionFunctorInterface< double_complex, 3 > | |
| Cmadness::WSTAtomicBasisFunctor | |
| ►Cmadness::FunctionFunctorInterface< double_complex, NDIM > | |
| Cmadness::ComplexExp< NDIM > | |
| Cmadness::FunctionFunctorInterface< Q, 3 > | |
| Cmadness::FunctionFunctorInterface< Q, NDIM > | |
| Cmadness::FunctionFunctorInterface< R, NDIM > | |
| Cmadness::FunctionFunctorInterface< std::complex< double >, 3 > | |
| Cmadness::FunctionFunctorInterface< std::complex< double >, NDIM > | |
| Cmadness::FunctionNode< T, NDIM > | FunctionNode holds the coefficients, etc., at each node of the 2^NDIM-tree |
| Cmadness::Future< T > | A future is a possibly yet unevaluated value |
| Cmadness::Future< bool > | |
| Cmadness::Future< detail::ReferenceWrapper< T > > | Future for holding ReferenceWrapper objects |
| Cmadness::Future< Future< T > > | A future of a future is forbidden (by private constructor) |
| Cmadness::Future< valueT > | |
| Cmadness::Future< Void > | Specialization of Future<Void> for internal convenience ... does nothing useful! |
| Cmadness::Future< void > | Specialization of Future<void> for internal convenience ... does nothing useful! |
| Cmadness::FutureImpl< void > | Specialization of FutureImpl<void> for internal convenience ... does nothing useful! |
| Cmadness::FutureImpl< Void > | Specialization of FutureImpl<Void> for internal convenience ... does nothing useful! |
| Cmadness::GaussianConvolution1DCache< Q > | |
| Cmadness::GaussianGenericFunctor< Q > | |
| Cstd::tr1::gtest_internal::Get< k > | |
| Cstd::tr1::gtest_internal::Get< 0 > | |
| Cstd::tr1::gtest_internal::Get< 1 > | |
| Cstd::tr1::gtest_internal::Get< 2 > | |
| Cstd::tr1::gtest_internal::Get< 3 > | |
| Cstd::tr1::gtest_internal::Get< 4 > | |
| Cstd::tr1::gtest_internal::Get< 5 > | |
| Cstd::tr1::gtest_internal::Get< 6 > | |
| Cstd::tr1::gtest_internal::Get< 7 > | |
| Cstd::tr1::gtest_internal::Get< 8 > | |
| Cstd::tr1::gtest_internal::Get< 9 > | |
| Cmadness::get_derivatives | |
| Cmadness::GFit< T, NDIM > | |
| Cmadness::Group | A collection of processes |
| CSafeMPI::Group | |
| Ctesting::internal::GTestFlagSaver | |
| Ctesting::internal::GTestLog | |
| Ctesting::internal::GTestMutexLock | |
| Cmadness::GTHPseudopotential< Q > | |
| Cmadness::GTHPseudopotential< double > | |
| 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::has_result_type< T > | |
| Cmadness::Hash< T > | Hash functor |
| Cmadness::Hash_private::HashIterator< hashT > | Iterator for hash |
| Cmadness::RMI::RmiTask::header | |
| Cmadness::detail::helper< T, N > | |
| Cmadness::detail::helper< T, 0 > | |
| Cmadness::detail::helper< T, 1 > | |
| Cmadness::tr1::detail::Host< B, D > | |
| ►Cmadness::IEigSolverObserver< T, NDIM > | |
| Cmadness::DFT< T, NDIM > | |
| Cmadness::HartreeFock< T, NDIM > | |
| Cmadness::if_c< Cond, T1, T2 > | Enable_if_same (from Boost?) for conditionally instantiating templates if two types are equal |
| ►Cmadness::if_c< Cond::value, T1, T2 > | |
| Cmadness::if_< Cond, T1, T2 > | |
| Cmadness::if_c< false, T1, T2 > | |
| Cmadness::imag_op< Q, NDIM > | |
| Cmadness::detail::imagop< NDIM > | |
| Ctesting::internal::ImplicitlyConvertible< From, To > | |
| ►Cmadness::IndexIterator | |
| Cmadness::HighDimIndexIterator | |
| Cmadness::LowDimIndexIterator | |
| Cmadness::NonstandardIndexIterator | |
| ►Cmadness::detail::info_base< memfunT > | |
| Cmadness::detail::info< memfunT > | |
| CInputParameters | |
| Cmadness::insert_op< T, NDIM > | |
| ►Cmadness::tr1::integral_constant< T, val > | |
| Cmadness::detail::ArgCount< a1T, a2T, a3T, a4T, a5T, a6T, a7T, a8T, a9T > | |
| Cmadness::tr1::is_array< T > | Is_array<T>::value will be true if T is an array type |
| Cmadness::tr1::is_array< T[n]> | Is_array<T>::value will be true if T is an array type |
| Cmadness::tr1::is_const< T > | Is_const<T>::value will be true if T is const |
| Cmadness::tr1::is_const< const T > | Is_const<T>::value will be true if T is const |
| Cmadness::tr1::is_floating_point< T > | Is_floating_point<T>::value will be true if T is a fundamental floating-point type |
| Cmadness::tr1::is_pointer< T > | Is_pointer<T>::value will be true if T is a pointer type |
| Cmadness::tr1::is_pointer< T * > | Is_pointer<T>::value will be true if T is a pointer type |
| Cmadness::tr1::is_reference< T > | Is_reference<T>::value will be true if T is a reference type |
| Cmadness::tr1::is_reference< T & > | Is_reference<T>::value will be true if T is a reference type |
| Cmadness::tr1::is_same< A, B > | Is_same<A,B> returns true if A and B are the same type |
| Cmadness::tr1::is_same< A, A > | Is_same<A,B> returns true if A and B are the same type |
| Cmadness::tr1::is_void< T > | True if T is void |
| Cmadness::tr1::is_void< void > | True if T is void |
| Cmadness::tr1::integral_constant< unsigned int, ArgCountHelper< a1T >::value+ArgCountHelper< a2T >::value+ArgCountHelper< a3T >::value+ArgCountHelper< a4T >::value+ArgCountHelper< a5T >::value+ArgCountHelper< a6T >::value+ArgCountHelper< a7T >::value+ArgCountHelper< a8T >::value+ArgCountHelper< a9T >::value > | |
| ►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::tr1::is_arithmetic< T > | |
| ►Cmadness::tr1::is_base_of< B, D > | |
| Cmadness::archive::is_archive< T > | Checks that T is an archive type |
| Cmadness::archive::is_input_archive< T > | Checks that T is an input archive type |
| Cmadness::archive::is_output_archive< T > | Checks that T is an output archive type |
| Cmadness::tr1::is_base_of< BaseArchive, T > | |
| Cmadness::tr1::is_base_of< BaseInputArchive, T > | |
| Cmadness::tr1::is_base_of< BaseOutputArchive, T > | |
| Cmadness::tr1::is_compound< T > | |
| Cmadness::is_derived_from< A, B > | True if A is derived from B and is not B |
| Cmadness::tr1::is_function< T > | Is_function<T>::value is true if T is a function pointer |
| Cmadness::tr1::is_fundamental< T > | Is_fundamental<T>::value will be true if T is a fundamental type |
| Cmadness::tr1::is_integral< T > | Is_integral<T>::value will be true if T is a fundamental integer type |
| Cmadness::tr1::is_member_function_pointer< T > | Is_member_function_pointer<T>::value is true if T is a member function pointer |
| Cmadness::tr1::is_object< T > | |
| Cmadness::is_serializable< T > | This defines stuff that is serialiable by default rules ... basically anything contiguous |
| Cmadness::IsSupported< TypeData, typename, bool > | |
| Cmadness::IsSupported< TypeData, ReturnType, true > | |
| Ctesting::internal::IteratorTraits< Iterator > | |
| Ctesting::internal::IteratorTraits< const T * > | |
| Ctesting::internal::IteratorTraits< T * > | |
| Cmadness::kain_solver_helper_struct | The structure needed if the kain solver shall be used |
| Cmadness::Key< NDIM > | Key is the index for a node of the 2^NDIM-tree |
| Cmadness::Key< OPDIM > | |
| Cmadness::KeyChildIterator< NDIM > | Iterates in lexical order thru all children of a key |
| Cmadness::KPoint | |
| CKPoint | |
| Cmadness::lazy_disable_if_c< B, returnT > | Lazy_disable_if_c from Boost for conditionally instantiating templates based on type |
| ►Cmadness::lazy_disable_if_c< Cond::value, returnT > | |
| Cmadness::lazy_disable_if< Cond, returnT > | Lazy_disable_if from Boost for conditionally instantiating templates based on type |
| Cmadness::lazy_disable_if_c< true, returnT > | Lazy_disable_if_c from Boost for conditionally instantiating templates based on type |
| Cmadness::lazy_enable_if_c< B, returnT > | Lazy_enable_if_c from Boost for conditionally instantiating templates based on type |
| ►Cmadness::lazy_enable_if_c< Cond::value, returnT > | |
| Cmadness::lazy_enable_if< Cond, returnT > | Lazy_enable_if from Boost for conditionally instantiating templates based on type |
| Cmadness::lazy_enable_if_c< false, returnT > | Lazy_enable_if_c from Boost for conditionally instantiating templates based on type |
| ►Cmadness::lazy_enable_if_c< function_traits< fnT >::value||has_result_type< fnT >::value, task_result_type< fnT > > | |
| Cmadness::detail::function_enabler< fnT > | |
| ►Cmadness::lazy_enable_if_c< std::is_member_function_pointer< memfnT >::value, task_result_type< memfnT > > | |
| ►Cmadness::lazy_enable_if< std::is_member_function_pointer< memfnT >, task_result_type< memfnT > > | |
| Cmadness::detail::memfunc_enabler< memfnT > | |
| Cmadness::LBCost | |
| Cmadness::lbcost< T, NDIM > | |
| Cmadness::LBNodeDeux< NDIM > | |
| Cmadness::leaf_op< T, NDIM > | Returns true if the function has a leaf node at key (works only locally) |
| Ctesting::internal::linked_ptr< T > | |
| Ctesting::internal::linked_ptr_internal | |
| Cmadness::LoadBalanceDeux< NDIM > | |
| Cmadness::LoadBalImpl< D > | |
| Cmadness::make_fxc | |
| CScatteringWF::MemberFuncPtr | |
| Cmadness::tr1::detail::memfunc_traits< memfuncT > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)() const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)()> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T)> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T)> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T)> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T)> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T)> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T)> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T)> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T)> | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T) const > | Member function traits in the spirt of boost function traits |
| Cmadness::tr1::detail::memfunc_traits< returnT(objT::*)(arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T)> | Member function traits in the spirt of boost function traits |
| Cmadness::detail::MemFuncWrapper< ptrT, memfnT, resT > | |
| Cmadness::detail::MemFuncWrapper< ptrT, memfnT, void > | |
| Ctesting::Message | |
| CMolecularEntity | |
| ►CMolecularMaskBase | |
| CMolecularSurface | |
| CMolecularVolumeComplementMask | |
| CMolecularVolumeMask | |
| CMolecularVolumeMaskGrad | |
| CMolecularSystem | |
| Cmadness::Molecule | |
| CMolecule | |
| Cmadness::detail::MoveWrapper< T > | Wrapper for movable objects |
| CMPI_Status | |
| Cmpfr::mpreal | |
| Cmadness::mul_leaf_op< T, NDIM > | |
| Cmadness::FunctionImpl< T, NDIM >::multiply_op< LDIM > | Perform this multiplication: h(1,2) = f(1,2) * g(1) |
| Ctesting::internal::Mutex | |
| ►Cmadness::Mutex | Mutex using pthread mutex operations |
| Cmadness::Random | A random number generator (portable, vectorized, and thread-safe) |
| Cmadness::WorldAmInterface | Implements AM interface |
| Cmadness::MutexWaiter | |
| Ctesting::internal::NativeArray< Element > | |
| ►CNO_DEFAULTS | Disables default copy constructor and assignment operators |
| Cmadness::detail::ArgHolder< Arg > | A wrapper object for holding task function objects |
| Cmadness::Future< std::vector< Future< T > > > | Specialization of Future for 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 with full functionality wrapping an MPI communicator |
| Cmadness::WorldContainerImpl< keyT, valueT, hashfunT > | Internal implementation of distributed container to facilitate shallow copy |
| Cmadness::WorldTaskQueue | Multi-threaded queue to manage and run tasks |
| Cmadness::detail::NoDeleter< T > | Use this deleter with shared_ptr to do nothing for the pointer cleanup |
| Cmadness::NonlinearSolverND< NDIM > | A simple Krylov-subspace nonlinear equation solver |
| Cmadness::detail::noop< A, B > | |
| Cmadness::noop< T, NDIM > | |
| 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, NDIM > > | |
| CDirichletCondIntOp< NDIM > | The operator needed for solving for  with GMRES |
| ►Cmadness::Operator< vecfunc > | |
| CEFieldOperator | |
| ►Cmadness::OptimizationTargetInterface | The interface to be provided by functions to be optimized |
| Cmadness::MolecularEnergy | |
| Cmadness::MP2 | Class for computing the first order wave function and MP2 pair energies |
| Cmadness::Nemo | The Nemo class |
| ►Cmadness::OptimizerInterface | The interface to be provided by optimizers |
| Cmadness::QuasiNewton | Optimization via quasi-Newton (BFGS or SR1 update) |
| Cmadness::SteepestDescent | Unconstrained minimization via steepest descent |
| ►Ctesting::internal::OsStackTraceGetterInterface | |
| Ctesting::internal::OsStackTraceGetter | |
| COutputWriter | |
| ►Cmadness::archive::ParallelSerializableObject | Objects that implement their own parallel archive interface should derive from this |
| Cmadness::Function< double, 3 > | |
| Cmadness::Function< double, 6 > | |
| Cmadness::Function< double, NDIM > | |
| Cmadness::Function< std::complex< double >, 3 > | |
| Cmadness::Function< T, 3 > | |
| Cmadness::ElectronPair | Enhanced POD for the pair functions |
| Cmadness::Function< T, NDIM > | A multiresolution adaptive numerical function |
| Cmadness::WorldContainer< keyT, valueT, hashfunT > | Makes a distributed container with specified attributes |
| Cmadness::WorldContainer< keyT, nodeT > | |
| ►Cmu::ParserBase | Mathematical expressions parser (base parser engine) |
| Cmu::Parser | Mathematical expressions parser |
| Cmu::ParserComplex | Mathematical expressions parser |
| Cmu::ParserInt | Mathematical expressions parser |
| Cmu::ParserByteCode | Bytecode implementation of the Math Parser |
| Cmu::ParserCallback | Encapsulation of prototypes for a numerical parser function |
| Cmu::ParserError | Error class of the parser |
| Cmu::ParserErrorMsg | A class that handles the error messages |
| Cmu::ParserStack< TValueType > | Parser stack implementation |
| Cmu::Test::ParserTester | Test cases for unit testing |
| Cmu::ParserToken< TBase, TString > | Encapsulation of the data for a single formula token |
| Cmu::ParserToken< value_type, string_type > | |
| Cmu::ParserTokenReader | Token reader for the ParserBase class |
| Cmadness::detail::PendingMsg | |
| Cmadness::perturbed_vxc | |
| CPointGroup | |
| Cmadness::PotentialManager | |
| Cmadness::ProcessKey< Key, Tag > | Key object that included 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< T, NDIM > | Simple projector class for 1- and 2-particle projectors |
| Cmadness::Projector< double, 3 > | |
| Cmadness::ProjRLMStore | |
| Cmadness::detail::ptr_traits< U > | |
| Cmadness::detail::ptr_traits< void > | |
| CPurturbationOperator | |
| Cmadness::qmsg | |
| Ctesting::internal::Random | |
| Cmadness::RandomState | |
| Cmadness::Range< iteratorT > | Range vaguely a la Intel TBB encapsulates random-access STL-like start and end iterators with chunksize |
| Ctesting::internal::RE | |
| Creal_op< Q, NDIM > | |
| Cmadness::real_op< Q, NDIM > | |
| Cmadness::detail::realop< NDIM > | |
| 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::Reference< T > | Used to provide rvalue references to support move semantics |
| Cmadness::detail::ReferenceWrapper< T > | Reference wrapper class |
| 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< bool > > | |
| Cmadness::RemoteReference< madness::FutureImpl< REMFUTURE(MEMFUN_RETURNT(memfunT)) > > | |
| Cmadness::RemoteReference< madness::FutureImpl< T > > | |
| Cmadness::RemoteReference< madness::FutureImpl< valueT > > | |
| Cmadness::tr1::remove_const< T > | Remove_const<const T>::type will be T |
| Cmadness::tr1::remove_const< const T > | Remove_const<const T>::type will be T |
| Cmadness::tr1::remove_cv< T > | Remove_cv<const T>::type or remove_cv<volatile T>::type will be T |
| Cmadness::remove_fcvr< T > | |
| Cmadness::remove_future< T > | Boost-type-trait-like mapping of Future<T> to T |
| Cmadness::remove_future< Future< T > > | Boost-type-trait-like mapping of Future<T> to T |
| Cmadness::FunctionImpl< T, NDIM >::remove_internal_coeffs | |
| Cmadness::tr1::remove_pointer< T > | Remove_pointer<T*>::type will be T |
| Cmadness::tr1::remove_pointer< T * > | Remove_pointer<T>::type will be T |
| Cmadness::tr1::remove_reference< T > | Remove_reference<&T>::type will be T |
| Cmadness::tr1::remove_reference< T & > | Remove_reference<&T>::type will be T |
| Cmadness::tr1::remove_volatile< T > | Remove_volatile<volatile T>::type will be T |
| Cmadness::tr1::remove_volatile< volatile T > | Remove_volatile<volatile T>::type will be T |
| Ctesting::internal::RemoveConst< T > | |
| Ctesting::internal::RemoveConst< const T > | |
| Ctesting::internal::RemoveConst< const T[N]> | |
| Ctesting::internal::RemoveReference< T > | |
| Ctesting::internal::RemoveReference< T & > | |
| CSafeMPI::Request | |
| Cmadness::tr1::detail::result_of< fnT, Enabler > | |
| Cmadness::tr1::detail::result_of< fnT, typename enable_if_c< function_traits< fnT >::value >::type > | |
| Cmadness::tr1::detail::result_of< fnT, typename enable_if_c< memfunc_traits< fnT >::value >::type > | |
| Cmadness::ReturnWrapper< T > | Wrapper so that can return something even if returning void |
| Cmadness::ReturnWrapper< void > | Wrapper so that can return something even if returning void |
| Cmadness::RMI | |
| Cmadness::RMIStats | |
| Croot | POD holding excitation energy and response vector for a single excitation |
| Cstd::tr1::gtest_internal::SameSizeTuplePrefixComparator< kSize1, kSize2 > | |
| Cstd::tr1::gtest_internal::SameSizeTuplePrefixComparator< 0, 0 > | |
| Cstd::tr1::gtest_internal::SameSizeTuplePrefixComparator< k, k > | |
| Cmadness::detail::scaleinplace< T, NDIM > | |
| Cmadness::SCF | |
| CSCF | |
| CSCFParameters | |
| Ctesting::internal::scoped_ptr< T > | |
| Ctesting::internal::scoped_ptr< ::std::string > | |
| Ctesting::internal::scoped_ptr< ::std::stringstream > | |
| Ctesting::internal::scoped_ptr< const ::std::string > | |
| Cmadness::ScopedArray< ptrT > | Scoped array |
| Cmadness::ScopedArray< counterT > | |
| Cmadness::ScopedArray< int > | |
| Cmadness::ScopedArray< madness::AmArg *volatile > | |
| Cmadness::ScopedArray< madness::qmsg > | |
| Cmadness::ScopedArray< madness::RMI::Request > | |
| Cmadness::ScopedArray< SafeMPI::SafeMPI::Request > | |
| Cmadness::ScopedArray< SafeMPI::Status > | |
| Cmadness::ScopedArray< void * > | |
| Cmadness::ScopedArray< volatile counterT > | |
| Cmadness::ScopedMutex< mutexT > | Mutex that is applied/released at start/end of a scope |
| Cmadness::ScopedPtr< ptrT > | Scoped pointer |
| Ctesting::internal::ScopedTrace | |
| CScreenSolventPotential | |
| Cmadness::SeparatedConvolutionData< Q, NDIM > | SeparatedConvolutionData keeps data for all terms, all dimensions |
| Cmadness::SeparatedConvolutionInternal< Q, NDIM > | |
| Cmadness::ShallowNode< T, NDIM > | Shallow-copy, pared-down version of FunctionNode, for special purpose only |
| Cmadness::tr1::shptr::detail::shared_count | |
| Cmadness::tr1::shptr::shared_ptr< T > | |
| Cmadness::tr1::shptr::shared_ptr< C > | |
| Cmadness::tr1::shptr::shared_ptr< char > | |
| Cmadness::tr1::shptr::shared_ptr< detail::DeferredCleanup > | |
| Cmadness::tr1::shptr::shared_ptr< double > | |
| Cmadness::tr1::shptr::shared_ptr< FunctionFunctorInterface< double, 6 > > | |
| Cmadness::tr1::shptr::shared_ptr< FunctionImpl< T, MDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< Impl > | |
| Cmadness::tr1::shptr::shared_ptr< madness::CompositeFunctorInterface< T, NDIM, MDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::Convolution1D< Q > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::detail::WorldMpi > | |
| Cmadness::tr1::shptr::shared_ptr< madness::DomainMaskInterface > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FGInterface > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionFunctorInterface< double, NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionFunctorInterface< Q, NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionFunctorInterface< R, NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionFunctorInterface< std::complex< double >, NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionFunctorInterface< T, NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionImpl > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionImpl< double, NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionImpl< std::complex< double >, NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionImpl< T, MDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FunctionImpl< T, NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FutureImpl< bool > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FutureImpl< T > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::FutureImpl< valueT > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::GTHPseudopotential< double > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::HartreeFock > | |
| Cmadness::tr1::shptr::shared_ptr< madness::OptimizationTargetInterface > | |
| Cmadness::tr1::shptr::shared_ptr< madness::PotentialManager > | |
| Cmadness::tr1::shptr::shared_ptr< madness::SCF > | |
| Cmadness::tr1::shptr::shared_ptr< madness::SeparatedConvolution > | |
| Cmadness::tr1::shptr::shared_ptr< madness::SignedDFInterface< NDIM > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::WorldContainerImpl > | |
| Cmadness::tr1::shptr::shared_ptr< madness::WorldDCPmapInterface< keyT > > | |
| Cmadness::tr1::shptr::shared_ptr< madness::WorldDCPmapInterface< madness::Key< NDIM > > > | |
| Cmadness::tr1::shptr::shared_ptr< NuclearCorrelationFactor > | |
| Cmadness::tr1::shptr::shared_ptr< operatorT > | |
| Cmadness::tr1::shptr::shared_ptr< OptimizationTargetInterface > | |
| Cmadness::tr1::shptr::shared_ptr< ProcessID > | |
| Cmadness::tr1::shptr::shared_ptr< ProcMapImpl< D > > | |
| Cmadness::tr1::shptr::shared_ptr< Q > | |
| Cmadness::tr1::shptr::shared_ptr< resultT > | |
| Cmadness::tr1::shptr::shared_ptr< TENSOR_RESULT_TYPE(T, R) > | |
| Cmadness::tr1::shptr::shared_ptr< typename Tensor< Q >::scalar_type > | |
| Cmadness::tr1::shptr::shared_ptr< typename Tensor< T >::scalar_type > | |
| Cmadness::tr1::shptr::shared_ptr< valueT > | |
| Cmadness::tr1::shptr::shared_ptr< void > | |
| Cmadness::tr1::shptr::detail::shared_ptr_traits< T > | |
| Cmadness::tr1::shptr::detail::shared_ptr_traits< void > | |
| Cmadness::tr1::shptr::detail::shared_ptr_traits< void const > | |
| Cmadness::tr1::shptr::detail::shared_ptr_traits< void const volatile > | |
| Cmadness::tr1::shptr::detail::shared_ptr_traits< void volatile > | |
| Cmadness::GenericConvolution1D< Q, opT >::Shmoo | |
| 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< Tensor< Q >, 1 > | |
| Cmadness::Function< T, NDIM >::SimpleUnaryOpWrapper | |
| Ctesting::internal::SingleFailureChecker | |
| Cmadness::Slice | A slice defines a sub-range or patch of a dimension |
| Cmadness::SliceGenTensor< T > | |
| Cmadness::Solver< T, NDIM > | The main class of the periodic DFT solver
![\[ z = frac{x}{1 - y^2} \]](form_43.png)
|
| Cmadness::SolverInterface | The interface to be provided by solvers ... NOT USED ANYWHERE? |
| Cmadness::SolverTargetInterface | The interface to be provided by targets for non-linear equation solver |
| Cmadness::tr1::shptr::detail::sp_convertible< Y, T > | |
| ►Cmadness::tr1::shptr::detail::sp_counted_base | |
| Cmadness::tr1::shptr::detail::sp_counted_impl_p< X > | |
| Cmadness::tr1::shptr::detail::sp_counted_impl_pd< Y, D > | |
| Cmadness::tr1::shptr::detail::sp_empty | |
| Cmadness::tr1::shptr::detail::sp_nothrow_tag | |
| Cmadness::SpectralPropagator | Spectral propagtor in time. Refer to documentation of file spectralprop.h for math detail |
| Cmadness::SpectralPropagatorGaussLobatto | |
| ►Cmadness::Spinlock | Spinlock using pthread spinlock operations |
| Cmadness::FutureImpl< bool > | |
| Cmadness::FutureImpl< REMFUTURE(MEMFUN_RETURNT(memfunT)) > | |
| Cmadness::FutureImpl< valueT > | |
| Cmadness::ConditionVariable | Scalable and fair condition variable (spins on local value) |
| Cmadness::DependencyInterface | Provides 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 |
| Cmadness::Split | Dummy class a la Intel TBB used to distinguish splitting constructor |
| Cmadness::detail::squareinplace< T, NDIM > | |
| Cmadness::SRConf< T > | |
| Cmadness::Stack< T, N > | A simple, fixed-size, stack |
| Cmu::STATIC_ASSERTION_FAILURE< bool > | Static type checks |
| Cmu::STATIC_ASSERTION_FAILURE< true > | |
| Cmadness::tr1::shptr::detail::static_cast_tag | |
| Ctesting::internal::StaticAssertTypeEqHelper< T1, T2 > | |
| Ctesting::internal::StaticAssertTypeEqHelper< T, T > | |
| CSafeMPI::Status | |
| Ctesting::internal::String | |
| Cmadness::StrongOrthogonalityProjector< T, NDIM > | SO projector class |
| Cmadness::StrongOrthogonalityProjector< double, 3 > | |
| Cmadness::Subspace< T, NDIM > | The SubspaceK class is a container class holding previous orbitals and residuals |
| Cmadness::SubspaceK< T, NDIM > | The SubspaceK class is a container class holding previous orbitals and residuals |
| CSVPEColloidSolver | |
| Cmadness::TaggedKey< Key, Tag > | Key object that uses a tag to differentiate keys |
| Cmadness::detail::task_arg< T > | |
| Cmadness::detail::task_arg< arg1T > | |
| Cmadness::detail::task_arg< arg2T > | |
| Cmadness::detail::task_arg< arg3T > | |
| Cmadness::detail::task_arg< arg4T > | |
| Cmadness::detail::task_arg< arg5T > | |
| Cmadness::detail::task_arg< arg6T > | |
| Cmadness::detail::task_arg< arg7T > | |
| Cmadness::detail::task_arg< arg8T > | |
| Cmadness::detail::task_arg< arg9T > | |
| 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 |
| Cmadness::PoolTaskNull | A no-op task used for various purposes |
| Cmadness::TaskInterface | All world tasks must be derived from this public interface |
| Cmadness::TaskFunction< typename > | |
| Cmadness::detail::TaskHandlerInfo< refT, functionT > | |
| Cmadness::TaskMemfun< typename > | |
| Cmadness::TaskThreadEnv | Used to pass info about thread environment into users task |
| Cmadness::TDA | The TDA class: computes TDA and CIS calculations |
| Cmadness::TDA_DFT | |
| Cmadness::TDA_TIMER | Strucutre for TIMER |
| 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::TensorTrain< T > | |
| 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 |
| Ctesting::Test | |
| Ctesting::TestCase | |
| ►Ctesting::TestEventListener | |
| Ctesting::EmptyTestEventListener | |
| Ctesting::TestEventListeners | |
| ►Ctesting::internal::TestFactoryBase | |
| Ctesting::internal::TestFactoryImpl< TestClass > | |
| Ctesting::TestInfo | |
| Ctesting::TestPartResult | |
| Ctesting::TestPartResultArray | |
| ►Ctesting::TestPartResultReporterInterface | |
| Ctesting::internal::DefaultGlobalTestPartResultReporter | |
| Ctesting::internal::DefaultPerThreadTestPartResultReporter | |
| Ctesting::internal::HasNewFatalFailureHelper | |
| Ctesting::ScopedFakeTestPartResultReporter | |
| Ctesting::TestProperty | |
| Ctesting::internal::TestPropertyKeyIs | |
| Ctesting::TestResult | |
| Ctesting::internal::TestResultAccessor | |
| ►Cmadness::ThreadBase | Simplified thread wrapper to hide pthread complexity |
| ►Cmadness::Thread | Simplified thread wrapper to hide pthread complexity |
| Cmadness::ThreadPoolThread | ThreadPool thread object |
| Ctesting::internal::ThreadLocal< T > | |
| Ctesting::internal::ThreadLocal< std::vector< testing::internal::TraceInfo > > | |
| Ctesting::internal::ThreadLocal< testing::TestPartResultReporterInterface * > | |
| Cmadness::ThreadPool | A singleton pool of threads for dynamic execution of tasks |
| Cmadness::Timer | |
| CTiXmlAttributeSet | |
| ►CTiXmlBase | |
| CTiXmlAttribute | |
| ►CTiXmlNode | |
| CTiXmlComment | |
| CTiXmlDeclaration | |
| CTiXmlDocument | |
| CTiXmlElement | |
| CTiXmlText | |
| CTiXmlUnknown | |
| CTiXmlCursor | |
| CTiXmlHandle | |
| ►CTiXmlString | |
| CTiXmlOutStream | |
| ►CTiXmlVisitor | |
| CTiXmlPrinter | |
| Ctesting::internal::TraceInfo | |
| Cmadness::trajectory< NDIM > | |
| Cmadness::true_op< NDIM > | |
| Cmadness::FunctionImpl< T, NDIM >::true_refine_test | |
| Cstd::tr1::tuple<> | |
| Cstd::tr1::tuple<> | |
| Cstd::tr1::tuple_element< k, Tuple > | |
| Cstd::tr1::tuple_size< Tuple > | |
| Cstd::tr1::tuple_size< GTEST_0_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_1_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_2_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_3_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_4_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_5_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_6_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_7_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_8_TUPLE_(T) > | |
| Cstd::tr1::tuple_size< GTEST_9_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< kIndexValid, kIndex, Tuple > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 0, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 1, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 2, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 3, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 4, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 5, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 6, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 7, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 8, GTEST_10_TUPLE_(T) > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 9, GTEST_10_TUPLE_(T) > | |
| Ctesting::internal::TypeIdHelper< T > | |
| Ctesting::internal2::TypeWithoutFormatter< T, kTypeKind > | |
| Ctesting::internal2::TypeWithoutFormatter< T, kConvertibleToInteger > | |
| Ctesting::internal2::TypeWithoutFormatter< T, kProtobuf > | |
| Ctesting::internal::TypeWithSize< size > | |
| Ctesting::internal::TypeWithSize< 4 > | |
| Ctesting::internal::TypeWithSize< 8 > | |
| Ctesting::internal::TypeWithSize< sizeof(RawType)> | |
| Cmadness::uniqueidT | |
| Ctesting::UnitTest | |
| Ctesting::internal::UnitTestImpl | |
| Ctesting::internal::UnitTestOptions | |
| Ctesting::internal::UniversalPrinter< T > | |
| Ctesting::internal::UniversalPrinter< T & > | |
| Ctesting::internal::UniversalPrinter< T[N]> | |
| Ctesting::internal::UniversalTersePrinter< T > | |
| Ctesting::internal::UniversalTersePrinter< char * > | |
| Ctesting::internal::UniversalTersePrinter< const char * > | |
| Ctesting::internal::UniversalTersePrinter< T & > | |
| Ctesting::internal::UniversalTersePrinter< T[N]> | |
| Ctesting::internal::UniversalTersePrinter< wchar_t * > | |
| Cmadness::unperturbed_vxc | |
| Cmadness::UnwrapReference< T > | ReferenceWrapper type trait accessor |
| Cmadness::UnwrapReference< detail::ReferenceWrapper< T > > | |
| Cmadness::UnwrapReference< detail::ReferenceWrapper< T > const > | |
| Cmadness::UnwrapReference< detail::ReferenceWrapper< T > const volatile > | |
| Cmadness::UnwrapReference< detail::ReferenceWrapper< T > volatile > | |
| Cmadness::vecfunc< T, NDIM > | |
| Cmadness::Vector< T, N > | A simple, fixed dimension Coordinate |
| Cmadness::Vector< double, 3 > | |
| Cmadness::Vector< double, NDIM > | |
| Cmadness::Vector< function, 3 > | |
| Cmadness::Vector< Function< double, 3 >, 3 > | |
| Cmadness::Vector< int, 3 > | |
| Cmadness::Vector< std::complex< double >, 2 *NTRANS+1 > | |
| Cmadness::Vector< Translation, NDIM > | |
| Cmadness::VextCosFunctor< T > | A generic functor to compute external potential for TDDFT |
| Cmadness::Void | A type you can return when you want to return void ... use "return None" |
| Cmadness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM > | Given a ket and the 1- and 2-electron potentials, construct the function V phi |
| Cmadness::tr1::shptr::detail::weak_count | |
| Cmadness::tr1::shptr::weak_ptr< T > | |
| CWF | |
| 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::WorldDCPmapInterface< Key< 3 > > | |
| CLevelPmap | |
| CLevelPmap | |
| CLevelPmap | |
| CLevelPmap | |
| CLevelPmap | |
| CLevelPmap | |
| CLevelPmap | |
| CLevelPmap | |
| ►Cmadness::WorldDCPmapInterface< Key< D > > | |
| Cmadness::MyPmap< D > | Procmap implemented using Tree of TreeCoords |
| ►Cmadness::WorldDCPmapInterface< Key< NDIM > > | |
| CLevelPmap | |
| Cmadness::LBDeuxPmap< NDIM > | |
| Cmadness::WorldDCPmapInterface< madness::Key< 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 |
| 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::WorldObject< Derived > | Implements most parts of a globally addressable object (via unique ID) |
| Cmadness::FunctionImpl< double, NDIM > | |
| Cmadness::FunctionImpl< Q, NDIM > | |
| Cmadness::FunctionImpl< R, NDIM > | |
| Cmadness::FunctionImpl< std::complex< double >, NDIM > | |
| ►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, MDIM > | |
| Cmadness::FunctionImpl< T, NDIM > | FunctionImpl holds all Function state to facilitate shallow copy semantics |
| ►Cmadness::WorldObject< SeparatedConvolution< double, NDIM > > | |
| Cmadness::SeparatedConvolution< double, 3 > | |
| Cmadness::SeparatedConvolution< double, NDIM > | |
| ►Cmadness::WorldObject< SeparatedConvolution< Q, NDIM > > | |
| Cmadness::SeparatedConvolution< Q, NDIM > | Convolutions in separated form (including Gaussian) |
| ►Cmadness::WorldObject< SeparatedConvolution< T, NDIM > > | |
| Cmadness::SeparatedConvolution< T, NDIM > | |
| ►Cmadness::WorldObject< WorldContainerImpl< keyT, valueT, hashfunT > > | |
| Cmadness::WorldContainerImpl< keyT, valueT, hashfunT > | Internal implementation of distributed container to facilitate shallow copy |
| 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 > | |
| CWSTFunctional | |
| Cmadness::xc_functional | Class to compute the energy functional |
| Cxc_functional | Class to compute the energy functional |
| Cmadness::xc_kernel | Class to compute terms of the kernel |
| Cmadness::xc_lda_potential | Compute the spin-restricted LDA potential using unaryop (only for the initial guess) |
| Cxc_lda_potential | Compute the spin-restricted LDA potential using unaryop (only for the initial guess) |
| Cxc_potential | Class to compute terms of the potential |
| Cmadness::xc_potential | Class to compute terms of the potential |
| Cmadness::XCfunctional | Simplified interface to XC functionals |
| CXCfunctional | Simplified interface to XC functionals |
| Cmadness::xfunction | The Root structure is needed by the TDA class |
| Cmadness::XNonlinearSolver< T, C, Alloc > | Generalized version of NonlinearSolver not limited to a single madness function |
| ►Cfalse_type | |
| Cmadness::detail::is_movable< T > | Type trait for movable objects |
| Cmadness::is_derived_from< A, A > | True if A is derived from B and is not B |
| Cmadness::is_future< T > | Boost-type-trait-like testing of if a type is a future |
| Cmadness::is_reference_wrapper< T > | Type trait for reference wrapper |
| Cmadness::tr1::detail::function_traits< functionT > | Function traits in the spirt of boost function traits |
| ►Ctrue_type | |
| Cmadness::detail::is_movable< MoveWrapper< T > > | Type trait for movable objects |
| Cmadness::is_future< Future< T > > | Boost-type-trait-like testing of if a type is a future |
| Cmadness::is_reference_wrapper< detail::ReferenceWrapper< T > > | |
| Cmadness::is_reference_wrapper< detail::ReferenceWrapper< T > const > | |
| Cmadness::is_reference_wrapper< detail::ReferenceWrapper< T > const volatile > | |
| Cmadness::is_reference_wrapper< detail::ReferenceWrapper< T > volatile > | |
1.8.8