Namespaces
namespace	arg_holder

Classes
struct	absinplace

struct	absop

struct	abssqop

struct	abssquareinplace

struct	adqtest

struct	ArgCount

struct	ArgCountHelper

struct	ArgCountHelper< void >

class	ArgHolder
	A wrapper object for holding task function argument objects. More...

struct	callable_enabler

struct	callable_enabler< callableT, std::enable_if_t< callable_traits< callableT >::value > >

struct	callable_traits
	Function traits in the spirit of boost function traits. More...

struct	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. More...

struct	DefaultInitPtr
	Default pointer to a. object of type `T`. More...

struct	DefaultInitPtr< std::shared_ptr< T > >
	Default shared pointer to an object of type `T`. More...

class	DeferredCleanup
	Deferred cleanup of shared_ptr's. More...

class	DistCache
	Distributed caching utility. More...

class	ForEachRootTask
	Apply an operation to a range of iterators. More...

struct	function_enabler

struct	function_enabler_helper
	Behave like a lazy `std::enable_if`. More...

struct	function_enabler_helper< false, returnT >
	Specialization that disables `type` when `B` is false. More...

struct	function_traits
	Function traits in the spirit of boost function traits. More...

struct	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.) More...

struct	function_traits< resultT(*&)(argTs...), void >
	Function trait specialization for a reference to a free function pointer. More...

struct	function_traits< resultT(*)(argTs...), void >
	Function trait specialization for a free function pointer. More...

struct	helper

struct	helper< T, 0 >

struct	helper< T, 1 >

struct	imagop

struct	info

struct	info_base

struct	is_arg_holder

struct	is_arg_holder< ArgHolder< T > >

struct	is_functor

struct	is_functor< fnT, typename std::enable_if< is_type< typename fnT::result_type >::value >::type >

struct	is_type

struct	memfunc_enabler

struct	memfunc_enabler< const objT *, memfnT >

struct	memfunc_enabler< const objT *const, memfnT >

struct	memfunc_enabler< const std::shared_ptr< objT > &, memfnT >

struct	memfunc_enabler< const std::shared_ptr< objT >, memfnT >

struct	memfunc_enabler< objT *, memfnT >

struct	memfunc_enabler< objT *const, memfnT >

struct	memfunc_enabler< std::shared_ptr< objT > &, memfnT >

struct	memfunc_enabler< std::shared_ptr< objT >, memfnT >

struct	memfunc_enabler_base

struct	memfunc_enabler_base< objT, resT(baseT::*)(paramT...) const, typename std::enable_if< std::is_base_of< baseT, objT >::value >::type >

struct	memfunc_enabler_base< objT, resT(baseT::*)(paramT...), typename std::enable_if< std::is_base_of< baseT, objT >::value >::type >

struct	memfunc_traits
	Member function traits in the spirit of boost function traits. More...

struct	memfunc_traits< returnT(objT::*)(argTs...) const >
	Member function traits in the spirit of boost function traits. More...

struct	memfunc_traits< returnT(objT::*)(argTs...)>
	Member function traits in the spirit of boost function traits. More...

class	MemFuncWrapper
	Functor wrapper for object and member function pointers. More...

class	MemFuncWrapper< ptrT, memfnT, void >
	Functor wrapper for object and member function pointers. More...

struct	noop

struct	PendingMsg
	Common base class for pending messages to ensure in-order processing. More...

struct	ptr_traits

struct	ptr_traits< void >
	Specialization of `ptr_traits` for type `void`. More...

struct	real_type

struct	real_type< std::complex< T > >

struct	realop

class	RemoteCounter
	Remote reference counter. More...

class	RemoteCounterBase
	Base class for remote counter implementation objects. More...

class	RemoteCounterImpl
	Remote counter implementation object. More...

struct	result_of

struct	result_of< fnT, typename std::enable_if< function_traits< fnT >::value >::type >

struct	result_of< fnT, typename std::enable_if< is_type< decltype(&fnT::operator())>::value >::type >

struct	result_of< fnT, typename std::enable_if< memfunc_traits< fnT >::value >::type >

struct	scaleinplace

struct	squareinplace

class	StackBase
	Base class for Stack which implements basic memory operations for non-POD objects. More...

class	StackBase< T, true >
	Base class for `Stack` which implements basic memory operations for POD objects. More...

struct	task_arg

struct	task_arg< Future< T > * >

struct	task_arg< Future< T > >

struct	task_arg< Future< void > >

struct	task_arg< void >

struct	task_result_type

struct	TaskHandlerInfo
	Serialization container for sending tasks to remote nodes. More...

class	WorldMpi
	MPI singleton that manages MPI setup and teardown for MADNESS. More...

class	WorldMpiRuntime
	MPI runtime reference counter. More...

struct	WorldObjectTaskHelper

struct	WorldObjectTaskHelper< objT, memfnT, typename std::enable_if< std::is_base_of< std::enable_shared_from_this< objT >, objT >::value >::type >

class	WorldPtr
	A global pointer address, valid anywhere in the world. More...

Typedefs
typedef Future< void >	voidT

Functions
void	combine_hash (hashT &seed, hashT hash)
	Internal use only.

void	compare_fn_addresses (void addresses_in, void addresses_inout, int len, MPI_Datatype type)

template<typename objT >
void	deferred_cleanup (World &world, const std::shared_ptr< objT > &p, bool assume_p_is_unique)
	Defer the cleanup of a shared pointer to the end of the next fence.

template<typename ptrT , typename memfnT , typename resT >
memfnT	get_mem_func_ptr (const MemFuncWrapper< ptrT, memfnT, resT > &wrapper)
	Returns the member function pointer from a wrapper.

unsigned short	htons_x (unsigned short a)

template<typename T = int>
double	mynorm (int t)

template<typename T >
T	mynorm (std::complex< T > t)

template<typename T >
T	mynorm (T t)

template<typename T >
double	norm (const T &t)

template<typename T >
double	norm (const Tensor< T > &t)

std::ostream &	operator<< (std::ostream &out, const RemoteCounter &counter)

template<typename T , typename U >
bool	operator<= (const WorldPtr< T > &left, const WorldPtr< U > &right)
	Less-than-equal-to comparison operator.

template<typename T , typename U >
bool	operator> (const WorldPtr< T > &left, const WorldPtr< U > &right)
	Greater-than comparison operator.

template<typename T , typename U >
bool	operator>= (const WorldPtr< T > &left, const WorldPtr< U > &right)
	Greater-than-equal-to comparison operator.

static const uniqueidT &	peek (const AmArg &arg)
	Extract the unique object ID from an incoming active message header.

bool &	print_meminfo_flag_accessor ()

bool &	print_meminfo_keepstreamopen_accessor ()

void	print_mutex_error (int error_number)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T , typename a9T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, a8T &a8, a9T &a9)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, a8T &a8, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, a2T &a2, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, a1T &a1, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT >
std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (Future< void > &result, fnT fn, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T , typename a9T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, a8T &a8, a9T &a9)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, a8T &a8, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, a7T &a7, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, a6T &a6, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, a5T &a5, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, a4T &a4, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T , typename a3T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, a3T &a3, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T , typename a2T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, a2T &a2, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT , typename a1T >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, a1T &a1, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

template<typename fnT >
std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type	run_function (typename task_result_type< fnT >::futureT &result, fnT fn, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)

void	swap (RemoteCounter &l, RemoteCounter &r)

template<typename T >
void	swap (WorldPtr< T > &l, WorldPtr< T > &r)
	Swap the content of `l` with `r`.

ThreadTag &	thread_tag_accessor ()

template<typename Char >
const Char *	Vm_cstr ()

template<>
const char *	Vm_cstr< char > ()

template<>
const wchar_t *	Vm_cstr< wchar_t > ()

template<typename objT , typename memfnT >
MemFuncWrapper< const objT *, memfnT, typename result_of< memfnT >::type >	wrap_mem_fn (const objT &obj, memfnT memfn)
	Create a member function wrapper (`MemFuncWrapper`) from a const object and a member function pointer.

template<typename objT , typename memfnT >
MemFuncWrapper< const objT *, memfnT, typename result_of< memfnT >::type >	wrap_mem_fn (const objT *obj, memfnT memfn)
	Create a member function wrapper (`MemFuncWrapper`) from a const pointer and a member function pointer.

template<typename objT , typename memfnT >
MemFuncWrapper< std::shared_ptr< objT >, memfnT, typename result_of< memfnT >::type >	wrap_mem_fn (const std::shared_ptr< objT > &obj, memfnT memfn)
	Create a member function wrapper (`MemFuncWrapper`) from a const shared pointer and a member function pointer.

template<typename objT , typename memfnT >
MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::type >	wrap_mem_fn (objT &obj, memfnT memfn)
	Create a member function wrapper (`MemFuncWrapper`) from an object and a member function pointer.

template<typename objT , typename memfnT >
MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::type >	wrap_mem_fn (objT *obj, memfnT memfn)
	Create a member function wrapper (`MemFuncWrapper`) from a pointer and a member function pointer.

template<typename objT , typename memfnT >
MemFuncWrapper< std::shared_ptr< objT >, memfnT, typename result_of< memfnT >::type >	wrap_mem_fn (std::shared_ptr< objT > &obj, memfnT memfn)
	Create a member function wrapper (`MemFuncWrapper`) from a shared pointer and a member function pointer.

Variables
Mutex	printmutex

Detailed Description

Todo:: Description needed

Typedef Documentation

◆ voidT

typedef Future<void> madness::detail::voidT

Future<void> is an empty object which is used as a placeholder for unused arguments.

Function Documentation

◆ combine_hash()

void madness::detail::combine_hash	(	hashT &	seed,
		hashT	hash
	)

inline

Internal use only.

References madness::nonlinear_vector_solver().

Referenced by madness::hash_combine(), madness::hash_range(), std::hash_value(), and madness::hash_value().

◆ compare_fn_addresses()

void madness::detail::compare_fn_addresses	(	void *	addresses_in,
		void *	addresses_inout,
		int *	len,
		MPI_Datatype *	type
	)

References compare_fn_addresses(), MADNESS_ASSERT, MPI_LONG, and madness::type().

Referenced by madness::RMI::assert_aslr_off(), and compare_fn_addresses().

◆ deferred_cleanup()

template<typename objT >

void madness::detail::deferred_cleanup	(	World &	world,
		const std::shared_ptr< objT > &	p,
		bool	assume_p_is_unique
	)

inline

Defer the cleanup of a shared pointer to the end of the next fence.

Call this function before destroying a shared pointer. If the shared pointer is the last reference to the object, or assume_p_is_unique is true, it is placed in the deferred deletion list. Otherwise, nothing is done with the pointer.

Referenced by madness::WorldContainer< keyT, valueT, hashfunT >::~WorldContainer().

◆ get_mem_func_ptr()

template<typename ptrT , typename memfnT , typename resT >

memfnT madness::detail::get_mem_func_ptr ( const MemFuncWrapper< ptrT, memfnT, resT > & wrapper )

Returns the member function pointer from a wrapper.

Template Parameters

ptrT	Pointer type.
memfnT	Member function pointer type.
resT	Member function return type.

Parameters

wrapper Wrapper to the member function.

Returns: The member function pointer.

Referenced by madness::TaskFn< fnT, arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T >::get_func().

◆ htons_x()

unsigned short madness::detail::htons_x ( unsigned short a )

inline

References a.

Referenced by madness::plotpovray().

◆ mynorm() [1/3]

template<typename T = int>

double madness::detail::mynorm ( int t )

References madness::nonlinear_vector_solver().

◆ mynorm() [2/3]

template<typename T >

T madness::detail::mynorm ( std::complex< T > t )

◆ mynorm() [3/3]

template<typename T >

T madness::detail::mynorm ( T t )

Referenced by madness::Tensor< T >::normf().

◆ norm() [1/2]

template<typename T >

double madness::detail::norm ( const T & t )

References std::abs().

Referenced by madness::adq1().

◆ norm() [2/2]

template<typename T >

double madness::detail::norm ( const Tensor< T > & t )

References madness::Tensor< T >::normf().

◆ operator<<()

std::ostream & madness::detail::operator<<	(	std::ostream &	out,
		const RemoteCounter &	counter
	)

References madness::nonlinear_vector_solver().

◆ operator<=()

template<typename T , typename U >

bool madness::detail::operator<=	(	const WorldPtr< T > &	left,
		const WorldPtr< U > &	right
	)

Less-than-equal-to comparison operator.

This operator does a lexicographical comparison of world ID, rank, and pointer (in that order).

Template Parameters

T	One pointer type.
U	Another pointer type.

Parameters

[in]	left	One pointer.
[in]	right	The other pointer.

Returns: True if the lexicographical comparison of world ID, rank, and pointer is true; false otherwise.

◆ operator>()

template<typename T , typename U >

bool madness::detail::operator>	(	const WorldPtr< T > &	left,
		const WorldPtr< U > &	right
	)

Greater-than comparison operator.

This operator does a lexicographical comparison of world ID, rank, and pointer (in that order).

Template Parameters

T	One pointer type.
U	Another pointer type.

Parameters

[in]	left	One pointer.
[in]	right	The other pointer.

Returns: True if the lexicographical comparison of world ID, rank, and pointer is true; false otherwise.

◆ operator>=()

template<typename T , typename U >

bool madness::detail::operator>=	(	const WorldPtr< T > &	left,
		const WorldPtr< U > &	right
	)

Greater-than-equal-to comparison operator.

This operator does a lexicographical comparison of world ID, rank, and pointer (in that order).

Template Parameters

T	One pointer type.
U	Another pointer type.

Parameters

[in]	left	One pointer.
[in]	right	The other pointer.

Returns: True if the lexicographical comparison of world ID, rank, and pointer is true; false otherwise.

◆ peek()

static const uniqueidT & madness::detail::peek ( const AmArg & arg )

inlinestatic

Extract the unique object ID from an incoming active message header.

We deserialize the header and all arguments at the same time to simplify the code. However, it is common that when sending a message to an item in a container to include a pointer to the container itself. But this breaks if the container is not initialized since the deserialization throws if the object is not initialized (which seems preferable to a hidden race condition). Hence, we use this routine to extract the unique ID from the very front of the info structure. For efficiency we here rely upon the serialization of info being opaque and the ID being at the front of info.

Todo:: Verify parameter description.

Parameters

[in] arg The active message header.

References madness::arg().

Referenced by madness::WorldObject< Derived >::handler(), and madness::WorldObject< Derived >::spawn_remote_task_handler().

◆ print_meminfo_flag_accessor()

bool & madness::detail::print_meminfo_flag_accessor ( )

References madness::nonlinear_vector_solver().

Referenced by madness::print_meminfo_disable(), madness::print_meminfo_enable(), and madness::print_meminfo_enabled().

◆ print_meminfo_keepstreamopen_accessor()

bool & madness::detail::print_meminfo_keepstreamopen_accessor ( )

References madness::nonlinear_vector_solver().

Referenced by madness::print_meminfo_keep_ostream_open(), and madness::print_meminfo_keep_ostream_open().

◆ print_mutex_error()

void madness::detail::print_mutex_error ( int error_number )

References madness::nonlinear_vector_solver().

Referenced by madness::Mutex::lock(), madness::RecursiveMutex::lock(), madness::Spinlock::lock(), madness::PthreadConditionVariable::lock(), madness::Mutex::unlock(), madness::RecursiveMutex::unlock(), madness::Spinlock::unlock(), and madness::PthreadConditionVariable::unlock().

◆ run_function() [1/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T , typename a9T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		a6T &	a6,
		a7T &	a7,
		a8T &	a8,
		a9T &	a9
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [2/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		a6T &	a6,
		a7T &	a7,
		a8T &	a8,
		const voidT &
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [3/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		a6T &	a6,
		a7T &	a7,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [4/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		a6T &	a6,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [5/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [6/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [7/20]

template<typename fnT , typename a1T , typename a2T , typename a3T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [8/20]

template<typename fnT , typename a1T , typename a2T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [9/20]

template<typename fnT , typename a1T >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		a1T &	a1,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, and madness::Future< T >::set().

◆ run_function() [10/20]

template<typename fnT >

std::enable_if< std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	Future< void > &	result,
		fnT	fn,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References madness::Future< T >::set().

Referenced by madness::WorldObject< Derived >::handler(), madness::TaskFn< fnT, arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T >::run(), and madness::WorldObject< Derived >::send_am().

◆ run_function() [11/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T , typename a9T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		a6T &	a6,
		a7T &	a7,
		a8T &	a8,
		a9T &	a9
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [12/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T , typename a8T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		a6T &	a6,
		a7T &	a7,
		a8T &	a8,
		const voidT &
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [13/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T , typename a7T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		a6T &	a6,
		a7T &	a7,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [14/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T , typename a6T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		a6T &	a6,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [15/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T , typename a5T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		a5T &	a5,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, madness::nonlinear_vector_solver(), and madness::Future< T >::set().

◆ run_function() [16/20]

template<typename fnT , typename a1T , typename a2T , typename a3T , typename a4T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		a4T &	a4,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [17/20]

template<typename fnT , typename a1T , typename a2T , typename a3T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		a3T &	a3,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [18/20]

template<typename fnT , typename a1T , typename a2T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		a2T &	a2,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, a2, and madness::Future< T >::set().

◆ run_function() [19/20]

template<typename fnT , typename a1T >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		a1T &	a1,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References a1, and madness::Future< T >::set().

◆ run_function() [20/20]

template<typename fnT >

std::enable_if<!std::is_void< typenamedetail::result_of< fnT >::type >::value >::type madness::detail::run_function	(	typename task_result_type< fnT >::futureT &	result,
		fnT	fn,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &	,
		const voidT &
	)

inline

References madness::Future< T >::set().

◆ swap() [1/2]

void madness::detail::swap	(	RemoteCounter &	l,
		RemoteCounter &	r
	)

inline

References madness::detail::RemoteCounter::swap().

◆ swap() [2/2]

template<typename T >

void madness::detail::swap	(	WorldPtr< T > &	l,
		WorldPtr< T > &	r
	)

Swap the content of l with r.

Template Parameters

T	The world pointer type.

Parameters

[in,out]	l	One world pointer.
[in,out]	r	The other world pointer.

References madness::detail::WorldPtr< T >::swap().

Referenced by madness::detail::RemoteCounter::swap(), and madness::RemoteReference< T >::swap().

◆ thread_tag_accessor()

ThreadTag & madness::detail::thread_tag_accessor ( )

inline

References madness::ThreadTag_NonMADNESS.

Referenced by madness::is_madness_thread(), madness::is_main_thread(), madness::set_thread_tag(), and madness::set_thread_tag().

◆ Vm_cstr()

template<typename Char >

const Char * madness::detail::Vm_cstr ( )

◆ Vm_cstr< char >()

template<>

const char * madness::detail::Vm_cstr< char > ( )

Referenced by madness::print_meminfo().

◆ Vm_cstr< wchar_t >()

template<>

const wchar_t * madness::detail::Vm_cstr< wchar_t > ( )

References L.

◆ wrap_mem_fn() [1/6]

template<typename objT , typename memfnT >

MemFuncWrapper< const objT *, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn	(	const objT &	obj,
		memfnT	memfn
	)

Create a member function wrapper (MemFuncWrapper) from a const object and a member function pointer.

Template Parameters

objT	The object type.
memfnT	The member function pointer type.

Parameters

[in]	obj	The object.
[in]	memfn	The member function pointer.

Returns: A wrapped member function pointer.

References madness::nonlinear_vector_solver().

◆ wrap_mem_fn() [2/6]

template<typename objT , typename memfnT >

MemFuncWrapper< const objT *, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn	(	const objT *	obj,
		memfnT	memfn
	)

Create a member function wrapper (MemFuncWrapper) from a const pointer and a member function pointer.

Template Parameters

objT	The object type.
memfnT	The member function pointer type.

Parameters

[in]	obj	Pointer to the object.
[in]	memfn	The member function pointer.

Returns: A wrapped member function pointer.

References madness::nonlinear_vector_solver().

◆ wrap_mem_fn() [3/6]

template<typename objT , typename memfnT >

MemFuncWrapper< std::shared_ptr< objT >, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn	(	const std::shared_ptr< objT > &	obj,
		memfnT	memfn
	)

Create a member function wrapper (MemFuncWrapper) from a const shared pointer and a member function pointer.

Template Parameters

objT	The object type.
memfnT	The member function pointer type.

Parameters

[in]	obj	Shared pointer to the object.
[in]	memfn	The member function pointer.

Returns: A wrapped member function pointer.

References madness::nonlinear_vector_solver().

◆ wrap_mem_fn() [4/6]

template<typename objT , typename memfnT >

MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn	(	objT &	obj,
		memfnT	memfn
	)

Create a member function wrapper (MemFuncWrapper) from an object and a member function pointer.

Template Parameters

objT	The object type.
memfnT	The member function pointer type.

Parameters

[in]	obj	The object.
[in]	memfn	The member function pointer.

Returns: A wrapped member function pointer.

References madness::nonlinear_vector_solver().

Referenced by madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::activate(), madness::FunctionImpl< T, NDIM >::add_op::activate(), madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::activate(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::activate(), madness::FunctionImpl< T, NDIM >::recursive_apply_op< opT, LDIM >::activate(), madness::FunctionImpl< T, NDIM >::recursive_apply_op2< opT >::activate(), madness::FunctionImpl< T, NDIM >::project_out_op< LDIM >::activate(), and madness::WorldTaskQueue::add().

◆ wrap_mem_fn() [5/6]

template<typename objT , typename memfnT >

MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn	(	objT *	obj,
		memfnT	memfn
	)

Create a member function wrapper (MemFuncWrapper) from a pointer and a member function pointer.

Template Parameters

objT	The object type.
memfnT	The member function pointer type.

Parameters

[in]	obj	Pointer to the object.
[in]	memfn	The member function pointer.

Returns: A wrapped member function pointer.

References madness::nonlinear_vector_solver().

◆ wrap_mem_fn() [6/6]

template<typename objT , typename memfnT >

MemFuncWrapper< std::shared_ptr< objT >, memfnT, typename result_of< memfnT >::type > madness::detail::wrap_mem_fn	(	std::shared_ptr< objT > &	obj,
		memfnT	memfn
	)

Create a member function wrapper (MemFuncWrapper) from a shared pointer and a member function pointer.

Template Parameters

objT	The object type.
memfnT	The member function pointer type.

Parameters

[in]	obj	Shared pointer to the object.
[in]	memfn	The member function pointer.

Returns: A wrapped member function pointer.

References madness::nonlinear_vector_solver().

Variable Documentation

◆ printmutex

Mutex madness::detail::printmutex

Referenced by madness::print(), and madness::print_error().

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ voidT

Function Documentation

◆ combine_hash()

◆ compare_fn_addresses()

◆ deferred_cleanup()

◆ get_mem_func_ptr()

◆ htons_x()

◆ mynorm() [1/3]

◆ mynorm() [2/3]

◆ mynorm() [3/3]

◆ norm() [1/2]

◆ norm() [2/2]

◆ operator<<()

◆ operator<=()

◆ operator>()

◆ operator>=()

◆ peek()

◆ print_meminfo_flag_accessor()

◆ print_meminfo_keepstreamopen_accessor()

◆ print_mutex_error()

◆ run_function() [1/20]

◆ run_function() [2/20]

◆ run_function() [3/20]

◆ run_function() [4/20]

◆ run_function() [5/20]

◆ run_function() [6/20]

◆ run_function() [7/20]

◆ run_function() [8/20]

◆ run_function() [9/20]

◆ run_function() [10/20]

◆ run_function() [11/20]

◆ run_function() [12/20]

◆ run_function() [13/20]

◆ run_function() [14/20]

◆ run_function() [15/20]

◆ run_function() [16/20]

◆ run_function() [17/20]

◆ run_function() [18/20]

◆ run_function() [19/20]

◆ run_function() [20/20]

◆ swap() [1/2]

◆ swap() [2/2]

◆ thread_tag_accessor()

◆ Vm_cstr()

◆ Vm_cstr< char >()

◆ Vm_cstr< wchar_t >()

◆ wrap_mem_fn() [1/6]

◆ wrap_mem_fn() [2/6]

◆ wrap_mem_fn() [3/6]

◆ wrap_mem_fn() [4/6]

◆ wrap_mem_fn() [5/6]

◆ wrap_mem_fn() [6/6]

Variable Documentation

◆ printmutex