vmra.h File Reference

Defines operations on vectors of Functions. More...

#include <madness/mra/mra.h>
#include <madness/mra/derivative.h>
#include <madness/tensor/distributed_matrix.h>
#include <cstdio>

Include dependency graph for vmra.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
namespace	madness
	Namespace for all elements and tools of MADNESS.

Functions
template<typename T , std::size_t NDIM>
std::vector< Function< typename Tensor< T >::scalar_type, NDIM > >	madness::abssq (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Computes the square of a vector of functions — q[i] = abs(v[i])**2.
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::add (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true)
	Returns new vector of functions — q[i] = a + b[i].
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::add (World &world, const std::vector< Function< R, NDIM > > &b, const Function< T, NDIM > &a, bool fence=true)
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::add (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true)
	Returns new vector of functions — q[i] = a[i] + b[i].
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::append (const std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs)
	combine two vectors
template<typename T , typename R , std::size_t NDIM, std::size_t KDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::apply (const SeparatedConvolution< T, KDIM > &op, const std::vector< Function< R, NDIM > > f)
	Applies an operator to a vector of functions — q[i] = apply(op,f[i])
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::apply (World &world, const Derivative< T, NDIM > &D, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Applies a derivative operator to a vector of functions.
template<typename T , typename R , std::size_t NDIM, std::size_t KDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::apply (World &world, const SeparatedConvolution< T, KDIM > &op, const std::vector< Function< R, NDIM > > f)
	Applies an operator to a vector of functions — q[i] = apply(op,f[i])
template<typename opT , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > >	madness::apply (World &world, const std::vector< std::shared_ptr< opT > > &op, const std::vector< Function< R, NDIM > > f)
	Applies a vector of operators to a vector of functions — q[i] = apply(op[i],f[i])
template<typename T , std::size_t NDIM>
const std::vector< Function< T, NDIM > > &	madness::change_tree_state (const std::vector< Function< T, NDIM > > &v, const TreeState finalstate, const bool fence=true)
	change tree state of the functions
template<typename T , std::size_t NDIM>
const std::vector< Function< T, NDIM > > &	madness::compress (const std::vector< Function< T, NDIM > > &v)
	compress a vector of functions
template<typename T , std::size_t NDIM>
void	madness::compress (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Compress a vector of functions.
double	madness::conj (double x)
double	madness::conj (float x)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::conj (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Returns the complex conjugate of the vector of functions.
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< R, NDIM > >	madness::convert (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Returns a deep copy of a vector of functions.
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::copy (const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Returns a deep copy of a vector of functions.
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::copy (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Returns a deep copy of a vector of functions.
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::copy (World &world, const std::vector< Function< T, NDIM > > &v, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool fence=true)
	Returns a deep copy of a vector of functions.
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::copy_n (World &world, const Function< T, NDIM > &v, const unsigned int n, bool fence=true)
	Returns a vector of n deep copies of a function.
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::cross (const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, bool do_refine=false, bool fence=true)
	shorthand cross operator
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::div (const std::vector< Function< T, NDIM > > &v, bool do_refine=false, bool fence=true)
	shorthand div operator
template<typename T , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(T, R), NDIM >	madness::dot (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true)
	Multiplies and sums two vectors of functions r = \sum_i a[i] * b[i].
template<typename T , std::size_t NDIM>
bool	madness::ensure_tree_state_respecting_fence (const std::vector< Function< T, NDIM > > &v, const TreeState state, bool fence)
	ensure v has the requested tree state, change the tree state of v if necessary and no fence is given
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::flatten (const std::vector< std::vector< Function< T, NDIM > > > &vv)
template<typename T , typename Q , typename R , std::size_t NDIM>
void	madness::gaxpy (Q alpha, std::vector< Function< T, NDIM > > &a, Q beta, const std::vector< Function< R, NDIM > > &b, const bool fence)
	Generalized A*X+Y for vectors of functions -— a[i] = alpha*a[i] + beta*b[i].
template<typename T , typename Q , typename R , std::size_t NDIM>
void	madness::gaxpy (World &world, Q alpha, std::vector< Function< T, NDIM > > &a, Q beta, const std::vector< Function< R, NDIM > > &b, bool fence=true)
	Generalized A*X+Y for vectors of functions -— a[i] = alpha*a[i] + beta*b[i].
template<typename T , typename Q , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(Q, TENSOR_RESULT_TYPE(T, R)), NDIM > >	madness::gaxpy_oop (Q alpha, const std::vector< Function< T, NDIM > > &a, Q beta, const Function< R, NDIM > &b, bool fence=true)
	out-of-place gaxpy for a vectors and a function: result[i] = alpha * a[i] + beta * b
template<typename T , typename Q , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(Q, TENSOR_RESULT_TYPE(T, R)), NDIM > >	madness::gaxpy_oop (Q alpha, const std::vector< Function< T, NDIM > > &a, Q beta, const std::vector< Function< R, NDIM > > &b, bool fence=true)
	out-of-place gaxpy for two vectors: result[i] = alpha * a[i] + beta * b[i]
template<typename T , std::size_t NDIM>
std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > >	madness::get_impl (const std::vector< Function< T, NDIM > > &v)
template<typename T , std::size_t NDIM>
double	madness::get_size (const Function< T, NDIM > &f)
template<typename T , std::size_t NDIM>
double	madness::get_size (World &world, const std::vector< Function< T, NDIM > > &v)
template<typename T , std::size_t NDIM>
double	madness::get_size_local (const Function< T, NDIM > &f)
	return the size of a function for each rank
template<typename T , std::size_t NDIM>
double	madness::get_size_local (World &world, const std::vector< Function< T, NDIM > > &v)
	return the size of a vector of functions for each rank
template<typename T , std::size_t NDIM>
TreeState	madness::get_tree_state (const std::vector< Function< T, NDIM > > &v)
	get tree state of a vector of functions
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::grad (const Function< T, NDIM > &f, bool refine=false, bool fence=true)
	shorthand gradient operator
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::grad_ble_one (const Function< T, NDIM > &f, bool refine=false, bool fence=true)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::grad_ble_two (const Function< T, NDIM > &f, bool refine=false, bool fence=true)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::grad_bpsline_two (const Function< T, NDIM > &f, bool refine=false, bool fence=true)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::grad_bspline_one (const Function< T, NDIM > &f, bool refine=false, bool fence=true)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::grad_bspline_three (const Function< T, NDIM > &f, bool refine=false, bool fence=true)
template<typename T , std::size_t NDIM>
std::vector< Function< typename Tensor< T >::scalar_type, NDIM > >	madness::imag (const std::vector< Function< T, NDIM > > &v, bool fence=true)
	return the imaginary parts of the vector's function (if complex)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::impl2function (const std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > vimpl)
template<typename T , typename R , std::size_t NDIM>
Tensor< TENSOR_RESULT_TYPE(T, R) >	madness::inner (World &world, const Function< T, NDIM > &f, const std::vector< Function< R, NDIM > > &g)
	Computes the inner product of a function with a function vector - q(i) = inner(f,g[i])
template<typename T , typename R , std::size_t NDIM>
Tensor< TENSOR_RESULT_TYPE(T, R) >	madness::inner (World &world, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g)
	Computes the element-wise inner product of two function vectors - q(i) = inner(f[i],g[i])
template<typename T , std::size_t NDIM>
void	madness::load_balance (World &world, std::vector< Function< T, NDIM > > &vf)
template<typename T , size_t NDIM>
void	madness::load_function (World &world, std::vector< Function< T, NDIM > > &f, const std::string name)
	load a vector of functions
template<typename T , std::size_t NDIM>
void	madness::make_nonstandard (World &world, std::vector< Function< T, NDIM > > &v, bool fence=true)
	Generates non-standard form of a vector of functions.
template<typename T , std::size_t NDIM>
void	madness::make_redundant (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	change tree_state of a vector of functions to redundant
template<typename T , std::size_t NDIM>
DistributedMatrix< T >	madness::matrix_dot (const DistributedMatrixDistribution &d, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< T, NDIM > > &g, bool sym=false)
template<typename T , typename R , std::size_t NDIM>
Tensor< TENSOR_RESULT_TYPE(T, R)>	madness::matrix_dot (World &world, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, bool sym=false)
	Computes the matrix dot product of two function vectors - q(i,j) = dot(f[i],g[j])
template<typename T , typename R , std::size_t NDIM>
Tensor< TENSOR_RESULT_TYPE(T, R) >	madness::matrix_dot_old (World &world, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, bool sym=false)
	Computes the matrix dot product of two function vectors - q(i,j) = dot(f[i],g[j])
template<typename T , std::size_t NDIM>
DistributedMatrix< T >	madness::matrix_inner (const DistributedMatrixDistribution &d, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< T, NDIM > > &g, bool sym=false)
template<typename T , typename R , std::size_t NDIM>
Tensor< TENSOR_RESULT_TYPE(T, R) >	madness::matrix_inner (World &world, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, bool sym=false)
	Computes the matrix inner product of two function vectors - q(i,j) = inner(f[i],g[j])
template<typename T , typename R , std::size_t NDIM>
Tensor< TENSOR_RESULT_TYPE(T, R) >	madness::matrix_inner_old (World &world, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, bool sym=false)
	Computes the matrix inner product of two function vectors - q(i,j) = inner(f[i],g[j])
template<typename T , typename R , std::size_t NDIM>
std::vector< std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > >	madness::matrix_mul_sparse (World &world, const std::vector< Function< R, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, double tol, bool fence=true, bool symm=false)
	Outer product of a vector of functions with a vector of functions using sparsity.
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::mul (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &v, bool fence=true)
	Multiplies a function against a vector of functions — q[i] = a * v[i].
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::mul (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true)
	Multiplies two vectors of functions q[i] = a[i] * b[i].
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::mul_sparse (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &v, double tol, bool fence=true)
	Multiplies a function against a vector of functions using sparsity of a and v[i] — q[i] = a * v[i].
template<typename T , typename opT , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::multi_to_multi_op_values (const opT &op, const std::vector< Function< T, NDIM > > &vin, const bool fence=true)
	apply op on the input vector yielding an output vector of functions
template<typename T , std::size_t NDIM, std::size_t LDIM>
std::vector< Function< T, NDIM > >	madness::multiply (const Function< T, NDIM > f, const std::vector< Function< T, LDIM > > g, const std::tuple< int, int, int > v)
template<typename T , std::size_t NDIM>
double	madness::norm2 (World &world, const std::vector< Function< T, NDIM > > &v)
	Computes the 2-norm of a vector of functions.
template<typename T , std::size_t NDIM>
std::vector< double >	madness::norm2s (World &world, const std::vector< Function< T, NDIM > > &v)
	Computes the 2-norms of a vector of functions.
template<typename T , std::size_t NDIM>
Tensor< double >	madness::norm2s_T (World &world, const std::vector< Function< T, NDIM > > &v)
	Computes the 2-norms of a vector of functions.
template<typename T , std::size_t NDIM>
void	madness::norm_tree (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Makes the norm tree for all functions in a vector.
template<typename T , std::size_t NDIM>
void	madness::normalize (World &world, std::vector< Function< T, NDIM > > &v, bool fence=true)
	Normalizes a vector of functions — v[i] = v[i].scale(1.0/v[i].norm2())
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::operator* (const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &v)
	multiply a vector of functions with a function: r[i] = v[i] * a
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::operator* (const R fac, const std::vector< Function< T, NDIM > > &rhs)
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator* (const std::vector< Function< T, NDIM > > &rhs, const R fac)
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::operator* (const std::vector< Function< T, NDIM > > &v, const Function< R, NDIM > &a)
	multiply a vector of functions with a function: r[i] = a * v[i]
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator+ (const Function< T, NDIM > &lhs, const std::vector< Function< T, NDIM > > &rhs)
	result[i] = a + b[i]
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator+ (const std::vector< Function< T, NDIM > > &lhs, const Function< T, NDIM > &rhs)
	result[i] = a[i] + b
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator+ (const std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs)
	result[i] = a[i] + b[i]
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator+= (std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator- (const Function< T, NDIM > &lhs, const std::vector< Function< T, NDIM > > &rhs)
	result[i] = a - b[i]
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator- (const std::vector< Function< T, NDIM > > &lhs, const Function< T, NDIM > &rhs)
	result[i] = a[i] - b
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator- (const std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs)
	result[i] = a[i] - b[i]
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::operator-= (std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize (const std::vector< Function< T, NDIM > > &vf_in)
	orthonormalize the vectors
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_canonical (const std::vector< Function< T, NDIM > > &v, const double lindep)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_canonical (const std::vector< Function< T, NDIM > > &v, const Tensor< T > &ovlp, double lindep)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_cd (const std::vector< Function< T, NDIM > > &v)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_cd (const std::vector< Function< T, NDIM > > &v, Tensor< T > &ovlp)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_rrcd (const std::vector< Function< T, NDIM > > &v, const double tol)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_rrcd (const std::vector< Function< T, NDIM > > &v, Tensor< T > &ovlp, const double tol, Tensor< integer > &piv, int &rank)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_rrcd (const std::vector< Function< T, NDIM > > &v, Tensor< T > ovlp, const double tol)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_symmetric (const std::vector< Function< T, NDIM > > &v)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::orthonormalize_symmetric (const std::vector< Function< T, NDIM > > &v, const Tensor< T > &ovlp)
	symmetric orthonormalization (see e.g. Szabo/Ostlund)
template<typename T , std::size_t NDIM, std::size_t LDIM>
std::vector< Function< T, NDIM > >	madness::partial_mul (const Function< T, NDIM > f, const std::vector< Function< T, LDIM > > g, const int particle)
	multiply a high-dimensional function with a low-dimensional function
template<typename T , std::size_t NDIM>
void	madness::print_size (World &world, const std::vector< Function< T, NDIM > > &v, const std::string &msg="vectorfunction")
template<typename T , std::size_t NDIM>
std::vector< Function< typename Tensor< T >::scalar_type, NDIM > >	madness::real (const std::vector< Function< T, NDIM > > &v, bool fence=true)
	return the real parts of the vector's function (if complex)
template<typename T , std::size_t NDIM>
const std::vector< Function< T, NDIM > > &	madness::reconstruct (const std::vector< Function< T, NDIM > > &v)
	reconstruct a vector of functions
template<typename T , std::size_t NDIM>
void	madness::reconstruct (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Reconstruct a vector of functions.
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::reduce_rank (std::vector< Function< T, NDIM > > v, double thresh=0.0, bool fence=true)
	reduces the tensor rank of the coefficient tensor (if applicable)
template<typename T , std::size_t NDIM>
void	madness::refine (World &world, const std::vector< Function< T, NDIM > > &vf, bool fence=true)
	refine the functions according to the autorefine criteria
template<typename T , std::size_t NDIM>
void	madness::refine_to_common_level (World &world, std::vector< Function< T, NDIM > > &vf, bool fence=true)
	refine all functions to a common (finest) level
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::rot (const std::vector< Function< T, NDIM > > &v, bool do_refine=false, bool fence=true)
	shorthand rot operator
template<typename T , size_t NDIM>
void	madness::save_function (const std::vector< Function< T, NDIM > > &f, const std::string name)
	save a vector of functions
template<typename T , typename Q , std::size_t NDIM>
void	madness::scale (World &world, std::vector< Function< T, NDIM > > &v, const Q factor, bool fence=true)
	Scales inplace a vector of functions by the same.
template<typename T , typename Q , std::size_t NDIM>
void	madness::scale (World &world, std::vector< Function< T, NDIM > > &v, const std::vector< Q > &factors, bool fence=true)
	Scales inplace a vector of functions by distinct values.
template<typename T , std::size_t NDIM>
void	madness::set_impl (std::vector< Function< T, NDIM > > &v, const std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > vimpl)
template<typename T , std::size_t NDIM>
void	madness::set_thresh (World &world, std::vector< Function< T, NDIM > > &v, double thresh, bool fence=true)
	Sets the threshold in a vector of functions.
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::square (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
	Computes the square of a vector of functions — q[i] = v[i]**2.
template<typename T , std::size_t NDIM>
void	madness::standard (World &world, std::vector< Function< T, NDIM > > &v, bool fence=true)
	Generates standard form of a vector of functions.
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::sub (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true)
	Returns new vector of functions — q[i] = a[i] - b[i].
template<typename T , std::size_t NDIM>
Function< T, NDIM >	madness::sum (World &world, const std::vector< Function< T, NDIM > > &f, bool fence=true)
	Returns new function — q = sum_i f[i].
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.
template<typename L , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(L, R), NDIM > >	madness::transform (World &world, const std::vector< Function< L, NDIM > > &v, const Tensor< R > &c, double tol, bool fence)
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::transform (World &world, const std::vector< Function< T, NDIM > > &v, const DistributedMatrix< R > &c, bool fence=true)
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::transform (World &world, const std::vector< Function< T, NDIM > > &v, const Tensor< R > &c, bool fence=true)
	Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i].
template<typename T , typename R , std::size_t NDIM>
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > >	madness::transform_reconstructed (World &world, const std::vector< Function< T, NDIM > > &v, const Tensor< R > &c, bool fence=true)
	Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i].
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::truncate (std::vector< Function< T, NDIM > > v, double tol=0.0, bool fence=true)
	Truncates a vector of functions.
template<typename T , std::size_t NDIM>
void	madness::truncate (World &world, std::vector< Function< T, NDIM > > &v, double tol=0.0, bool fence=true)
	Truncates a vector of functions.
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::zero_functions (World &world, int n, bool fence=true)
	Generates a vector of zero functions (reconstructed)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::zero_functions_auto_tree_state (World &world, int n, bool fence=true)
	Generates a vector of zero functions, either compressed or reconstructed, depending on tensor type.
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::zero_functions_compressed (World &world, int n, bool fence=true)
	Generates a vector of zero functions (compressed)
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > >	madness::zero_functions_tree_state (World &world, int n, const TreeState state, bool fence=true)
	Generates a vector of zero functions with a given tree state.

Detailed Description

Defines operations on vectors of Functions.

This file defines a number of operations on vectors of functions. Assume v is a vector of NDIM-D functions of a certain type.

Operations on array of functions

) copying: deep copying of vectors of functions to vector of functions

vector2 = copy(world, vector1,fence);

) compress: convert multiwavelet representation to legendre representation

compress(world, vector, fence);

) reconstruct: convert representation to multiwavelets

reconstruct(world, vector, fence);

) make_nonstandard: convert to non-standard form

make_nonstandard(world, v, fence);

) standard: convert to standard form

standard(world, v, fence);

) truncate: truncating vectors of functions to desired precision

truncate(world, v, tolerance, fence);

) zero function: create a vector of zero functions of length n

v=zero(world, n);

) transform: transform a representation from one basis to another

transform(world, vector, tensor, tolerance, fence )

Setting thresh-hold for precision

) set_thresh: setting a finite thresh-hold for a vector of functions

void set_thresh(World& world, std::vector< Function<T,NDIM> >& v, double thresh, bool fence=true);

Arithmetic Operations on arrays of functions

) conjugation: conjugate a vector of complex functions

) add ) sub ) mul

• mul_sparse ) square ) gaxpy ) apply

Norms, inner-products, blas-1 like operations on vectors of functions

) inner ) matrix_inner ) norm_tree ) normalize ) norm2

• norm2s ) scale(world, v, alpha);