madness::FunctionImpl< T, NDIM >::multiply_op< LDIM > Struct Template Reference

perform this multiplication: h(1,2) = f(1,2) * g(1) More...

#include <funcimpl.h>

Collaboration diagram for madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >:

Public Types
typedef CoeffTracker< T, LDIM >	ctL
typedef CoeffTracker< T, NDIM >	ctT
typedef multiply_op< LDIM >	this_type

Public Member Functions
	multiply_op ()
	multiply_op (implT *h1, const ctT &f1, const ctL &g1, const int particle1)
Future< this_type >	activate () const
this_type	forward_ctor (implT *h1, const ctT &f1, const ctL &g1, const int particle)
this_type	make_child (const keyT &child) const
std::pair< bool, coeffT >	operator() (const Key< NDIM > &key) const
	apply this on a FunctionNode of f and g of Key key
bool	screen (const coeffT &fcoeff, const coeffT &gcoeff, const keyT &key) const
	return true if this will be a leaf node
template<typename Archive>
void	serialize (const Archive &ar)

Static Public Member Functions
static bool	randomize ()

Public Attributes
ctT	f
ctL	g
implT *	h
	the result function h(1,2) = f(1,2) * g(1)
int	particle
	if g is g(1) or g(2)

Detailed Description

template<typename T, std::size_t NDIM>
template<size_t LDIM>
struct madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >

perform this multiplication: h(1,2) = f(1,2) * g(1)

Member Typedef Documentation

ctL

template<typename T, std::size_t NDIM>

template<size_t LDIM>

typedef CoeffTracker<T,LDIM> madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::ctL

ctT

template<typename T, std::size_t NDIM>

template<size_t LDIM>

typedef CoeffTracker<T,NDIM> madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::ctT

this_type

template<typename T, std::size_t NDIM>

template<size_t LDIM>

typedef multiply_op<LDIM> madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::this_type

Constructor & Destructor Documentation

multiply_op() [1/2]

template<typename T, std::size_t NDIM>

template<size_t LDIM>

madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::multiply_op ( )

inline

References f, g, h, and particle.

multiply_op() [2/2]

template<typename T, std::size_t NDIM>

template<size_t LDIM>

madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::multiply_op ( implT * h1, const ctT & f1, const ctL & g1, const int particle1 )

inline

References f, f1, g, g1(), h, and particle.

Member Function Documentation

activate()

template<typename T, std::size_t NDIM>

template<size_t LDIM>

Future< this_type > madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::activate ( ) const

inline

References f, f1, forward_ctor(), g, g1(), h, particle, and madness::detail::wrap_mem_fn().

forward_ctor()

template<typename T, std::size_t NDIM>

template<size_t LDIM>

this_type madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::forward_ctor ( implT * h1, const ctT & f1, const ctL & g1, const int particle )

inline

References f1, g1(), and particle.

Referenced by activate().

make_child()

template<typename T, std::size_t NDIM>

template<size_t LDIM>

this_type madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::make_child ( const keyT & child ) const

inline

References madness::Key< NDIM >::break_apart(), f, g, h, and particle.

operator()()

template<typename T, std::size_t NDIM>

template<size_t LDIM>

std::pair< bool, coeffT > madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::operator() ( const Key< NDIM > & key ) const

inline

apply this on a FunctionNode of f and g of Key key

Parameters

[in]

key

key for FunctionNode in f and g, (g: broken into particles)

Returns

<this node is a leaf, coefficients of this node>

References madness::Key< NDIM >::break_apart(), madness::GenTensor< T >::convert(), f, g, h, madness::GenTensor< T >::is_of_tensortype(), madness::Key< NDIM >::level(), madness::GenTensor< T >::normalize(), particle, screen(), and madness::TT_2D.

randomize()

template<typename T, std::size_t NDIM>

template<size_t LDIM>

bool madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::randomize ( )

inlinestatic

screen()

template<typename T, std::size_t NDIM>

template<size_t LDIM>

bool madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::screen ( const coeffT & fcoeff, const coeffT & gcoeff, const keyT & key ) const

inline

return true if this will be a leaf node

use generalization of tnorm for a GenTensor

References g, madness::GenTensor< T >::get_svdtensor(), madness::GenTensor< T >::get_tensor(), h, madness::GenTensor< T >::is_full_tensor(), madness::GenTensor< T >::is_svd_tensor(), MADNESS_ASSERT, particle, and madness::FunctionImpl< T, NDIM >::truncate_tol().

Referenced by operator()().

serialize()

template<typename T, std::size_t NDIM>

template<size_t LDIM>

template<typename Archive>

void madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::serialize ( const Archive & ar )

inline

References f, g, h, and particle.

Member Data Documentation

f

template<typename T, std::size_t NDIM>

template<size_t LDIM>

ctT madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::f

Referenced by multiply_op(), multiply_op(), activate(), make_child(), operator()(), and serialize().

g

template<typename T, std::size_t NDIM>

template<size_t LDIM>

ctL madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::g

Referenced by multiply_op(), multiply_op(), activate(), make_child(), operator()(), screen(), and serialize().

h

template<typename T, std::size_t NDIM>

template<size_t LDIM>

implT* madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::h

the result function h(1,2) = f(1,2) * g(1)

Referenced by multiply_op(), multiply_op(), activate(), make_child(), operator()(), screen(), and serialize().

particle

template<typename T, std::size_t NDIM>

template<size_t LDIM>

int madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::particle

if g is g(1) or g(2)

Referenced by multiply_op(), multiply_op(), activate(), forward_ctor(), make_child(), operator()(), screen(), and serialize().

---

The documentation for this struct was generated from the following file:

• funcimpl.h