mra.h File Reference

Main include file for MADNESS and defines Function interface. More...

#include <madness/world/world.h>
#include <madness/misc/misc.h>
#include <madness/tensor/tensor.h>
#include <madness/mra/key.h>
#include <madness/mra/twoscale.h>
#include <madness/mra/legendre.h>
#include <madness/mra/indexit.h>
#include <madness/world/parar.h>
#include <madness/world/worlddc.h>
#include <madness/mra/funcdefaults.h>
#include <madness/mra/function_factory.h>
#include <madness/mra/lbdeux.h>
#include <madness/mra/funcimpl.h>
#include <madness/mra/funcplot.h>
#include <madness/mra/derivative.h>
#include <madness/mra/operator.h>
#include <madness/mra/functypedefs.h>
#include <madness/mra/vmra.h>

Include dependency graph for mra.h:

Go to the source code of this file.

Classes
singleton	madness::FunctionImpl< T, NDIM >
	FunctionImpl holds all Function state to facilitate shallow copy semantics. More...
class	madness::Function< T, NDIM >
	A multiresolution adaptive numerical function. More...
singleton	madness::FunctionNode< T, NDIM >
	FunctionNode holds the coefficients, etc., at each node of the 2^NDIM-tree. More...
singleton	madness::FunctionFactory< T, NDIM >
	FunctionFactory implements the named-parameter idiom for Function. More...
singleton	madness::FunctionFunctorInterface< T, NDIM >
	Abstract base class interface required for functors used as input to Functions. More...
struct	madness::leaf_op< T, NDIM >
	returns true if the function has a leaf node at key (works only locally) More...
struct	madness::mul_leaf_op< T, NDIM >
struct	madness::hartree_leaf_op< T, NDIM >
	returns true if the result of a hartree_product is a leaf node (compute norm & error) More...
struct	madness::hartree_convolute_leaf_op< T, NDIM, LDIM, opT >
struct	madness::op_leaf_op< T, NDIM, opT >
struct	madness::error_leaf_op< T, NDIM >
	returns true if the node is well represented compared to its parent More...
class	madness::Function< T, NDIM >
	A multiresolution adaptive numerical function. More...
struct	madness::Function< T, NDIM >::autorefine_square_op
struct	madness::Function< T, NDIM >::SimpleUnaryOpWrapper
struct	madness::detail::realop< NDIM >
struct	madness::detail::imagop< NDIM >
struct	madness::detail::abssqop< NDIM >
struct	madness::archive::ArchiveLoadImpl< ParallelInputArchive, Function< T, NDIM > >
struct	madness::archive::ArchiveStoreImpl< ParallelOutputArchive, Function< T, NDIM > >

Namespaces
	madness
	Holds machinery to set up Functions/FuncImpls using various Factories and Interfaces.
	madness::detail
	madness::archive

Macros
#define	FUNCTION_INSTANTIATE_1
#define	FUNCTION_INSTANTIATE_2
#define	FUNCTION_INSTANTIATE_3
#define	FUNCTION_INSTANTIATE_4
#define	FUNCTION_INSTANTIATE_5
#define	FUNCTION_INSTANTIATE_6

Functions
void	madness::startup (World &world, int argc, char **argv)
template<typename T , typename opT , int NDIM>
Function< T, NDIM >	madness::multiop_values (const opT &op, const std::vector< Function< T, NDIM > > &vf)
template<typename Q , typename T , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(Q, T), NDIM >	madness::mul (const Q alpha, const Function< T, NDIM > &f, bool fence=true)
	Returns new function equal to alpha*f(x) with optional fence. More...
template<typename Q , typename T , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(Q, T), NDIM >	madness::mul (const Function< T, NDIM > &f, const Q alpha, bool fence=true)
	Returns new function equal to f(x)*alpha with optional fence. More...
template<typename Q , typename T , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(Q, T), NDIM >	madness::operator* (const Function< T, NDIM > &f, const Q alpha)
	Returns new function equal to f(x)*alpha. More...
template<typename Q , typename T , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(Q, T), NDIM >	madness::operator* (const Q alpha, const Function< T, NDIM > &f)
	Returns new function equal to alpha*f(x) More...
template<typename L , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::mul_sparse (const Function< L, NDIM > &left, const Function< R, NDIM > &right, double tol, bool fence=true)
	Sparse multiplication — left and right must be reconstructed and if tol!=0 have tree of norms already created. More...
template<typename L , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::mul (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true)
	Same as operator* but with optional fence and no automatic reconstruction. More...
template<typename L , typename R , typename opT , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::binary_op (const Function< L, NDIM > &left, const Function< R, NDIM > &right, const opT &op, bool fence=true)
	Generate new function = op(left,right) where op acts on the function values. More...
template<typename Q , typename opT , std::size_t NDIM>
Function< typename opT::resultT, NDIM >	madness::unary_op (const Function< Q, NDIM > &func, const opT &op, bool fence=true)
	Out of place application of unary operation to function values with optional fence. More...
template<typename Q , typename opT , std::size_t NDIM>
Function< typename opT::resultT, NDIM >	madness::unary_op_coeffs (const Function< Q, NDIM > &func, const opT &op, bool fence=true)
	Out of place application of unary operation to scaling function coefficients with optional fence. More...
template<typename L , typename R , std::size_t D>
std::vector< Function < TENSOR_RESULT_TYPE(L, R), D > >	madness::vmulXX (const Function< L, D > &left, const std::vector< Function< R, D > > &vright, double tol, bool fence=true)
	Use the vmra/mul(...) interface instead. More...
template<typename L , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::operator* (const Function< L, NDIM > &left, const Function< R, NDIM > &right)
	Multiplies two functions with the new result being of type TensorResultType<L,R> More...
template<typename T , std::size_t KDIM, std::size_t LDIM>
Function< T, KDIM+LDIM >	madness::hartree_product (const Function< T, KDIM > &left2, const Function< T, LDIM > &right2)
	Performs a Hartree product on the two given low-dimensional functions. More...
template<typename T , std::size_t KDIM, std::size_t LDIM, typename opT >
Function< T, KDIM+LDIM >	madness::hartree_product (const Function< T, KDIM > &left2, const Function< T, LDIM > &right2, const opT &op)
	Performs a Hartree product on the two given low-dimensional functions. More...
template<typename L , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::gaxpy_oop (TENSOR_RESULT_TYPE(L, R) alpha, const Function< L, NDIM > &left, TENSOR_RESULT_TYPE(L, R) beta, const Function< R, NDIM > &right, bool fence=true)
	Returns new function alpha*left + beta*right optional fence and no automatic compression. More...
template<typename L , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::add (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true)
	Same as operator+ but with optional fence and no automatic compression. More...
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::gaxpy_oop_reconstructed (const double alpha, const Function< T, NDIM > &left, const double beta, const Function< T, NDIM > &right, const bool fence=true)
	Returns new function alpha*left + beta*right optional fence, having both addends reconstructed. More...
template<typename L , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::operator+ (const Function< L, NDIM > &left, const Function< R, NDIM > &right)
	Adds two functions with the new result being of type TensorResultType<L,R> More...
template<typename L , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::sub (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true)
	Same as operator- but with optional fence and no automatic compression. More...
template<typename L , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(L, R), NDIM >	madness::operator- (const Function< L, NDIM > &left, const Function< R, NDIM > &right)
	Subtracts two functions with the new result being of type TensorResultType<L,R> More...
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::square (const Function< T, NDIM > &f, bool fence=true)
	Create a new function that is the square of f - global comm only if not reconstructed. More...
template<typename T , int NDIM>
Function< T, NDIM >	madness::abs (const Function< T, NDIM > &f, bool fence=true)
	Create a new function that is the abs of f - global comm only if not reconstructed. More...
template<typename T , int NDIM>
Function< T, NDIM >	madness::abs_square (const Function< T, NDIM > &f, bool fence=true)
	Create a new function that is the abs_square of f - global comm only if not reconstructed. More...
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::copy (const Function< T, NDIM > &f, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool fence=true)
	Create a new copy of the function with different distribution and optional fence. More...
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::copy (const Function< T, NDIM > &f, bool fence=true)
	Create a new copy of the function with the same distribution and optional fence. More...
template<typename T , typename Q , std::size_t NDIM>
Function< Q, NDIM >	madness::convert (const Function< T, NDIM > &f, bool fence=true)
	Type conversion implies a deep copy. No communication except for optional fence. More...
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::conj (const Function< T, NDIM > &f, bool fence=true)
	Return the complex conjugate of the input function with the same distribution and optional fence. More...
template<typename opT , typename T , std::size_t LDIM>
Function< TENSOR_RESULT_TYPE(typename opT::opT, T), LDIM+LDIM >	madness::apply (const opT &op, const Function< T, LDIM > &f1, const Function< T, LDIM > &f2, bool fence=true)
	Apply operator on a hartree product of two low-dimensional functions. More...
template<typename opT , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM >	madness::apply_only (const opT &op, const Function< R, NDIM > &f, bool fence=true)
	Apply operator ONLY in non-standard form - required other steps missing !! More...
template<typename opT , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM >	madness::apply (const opT &op, const Function< R, NDIM > &f, bool fence=true)
	Apply operator in non-standard form. More...
template<typename opT , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM >	madness::apply_1d_realspace_push (const opT &op, const Function< R, NDIM > &f, int axis, bool fence=true)
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::mapdim (const Function< T, NDIM > &f, const std::vector< long > &map, bool fence=true)
	Generate a new function by reordering dimensions ... optional fence. More...
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::symmetrize (const Function< T, NDIM > &f, const std::string symmetry, bool fence=true)
	symmetrize a function More...
template<typename T , std::size_t NDIM, std::size_t LDIM>
Function< T, NDIM >	madness::multiply (const Function< T, NDIM > f, const Function< T, LDIM > g, const int particle, const bool fence=true)
	multiply a high-dimensional function with a low-dimensional function More...
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::project (const Function< T, NDIM > &other, int k=FunctionDefaults< NDIM >::get_k(), double thresh=FunctionDefaults< NDIM >::get_thresh(), bool fence=true)
template<typename T , typename R , std::size_t NDIM>
	madness::TENSOR_RESULT_TYPE (T, R) inner(const Function<T
	Computes the scalar/inner product between two functions. More...
return f	madness::inner (g)
template<typename T , typename R , std::size_t NDIM>
IsSupported< TensorTypeData< R > , Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type	madness::operator+ (const Function< T, NDIM > &f, R r)
template<typename T , typename R , std::size_t NDIM>
IsSupported< TensorTypeData< R > , Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type	madness::operator+ (R r, const Function< T, NDIM > &f)
template<typename T , typename R , std::size_t NDIM>
IsSupported< TensorTypeData< R > , Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type	madness::operator- (const Function< T, NDIM > &f, R r)
template<typename T , typename R , std::size_t NDIM>
IsSupported< TensorTypeData< R > , Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type	madness::operator- (R r, const Function< T, NDIM > &f)
template<std::size_t NDIM>
Function< double, NDIM >	madness::real (const Function< double_complex, NDIM > &z, bool fence=true)
	Returns a new function that is the real part of the input. More...
template<std::size_t NDIM>
Function< double, NDIM >	madness::imag (const Function< double_complex, NDIM > &z, bool fence=true)
	Returns a new function that is the imaginary part of the input. More...
template<std::size_t NDIM>
Function< double, NDIM >	madness::abssq (const Function< double_complex, NDIM > &z, bool fence=true)
	Returns a new function that is the square of the absolute value of the input. More...

Variables
NDIM &	madness::f
NDIM const Function< R, NDIM > &	madness::g

Detailed Description

Main include file for MADNESS and defines Function interface.

Macro Definition Documentation

#define FUNCTION_INSTANTIATE_1

#define FUNCTION_INSTANTIATE_2

#define FUNCTION_INSTANTIATE_3

#define FUNCTION_INSTANTIATE_4

#define FUNCTION_INSTANTIATE_5

#define FUNCTION_INSTANTIATE_6