MADNESS  0.10.1
Namespaces | Functions
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

 madness
 File holds all helper structures necessary for the CC_Operator and CC2 class.
 

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. More...
 
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]. More...
 
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]. More...
 
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 More...
 
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]) More...
 
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. More...
 
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]) More...
 
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]) More...
 
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 More...
 
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 More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > > madness::copy (World &world, const Function< T, NDIM > &v, const unsigned int n, bool fence=true)
 Returns a vector of n deep copies of a function. More...
 
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. More...
 
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. More...
 
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 More...
 
template<typename T , std::size_t NDIM>
Function< T, NDIMmadness::div (const std::vector< Function< T, NDIM > > &v, bool do_refine=false, bool fence=true)
 shorthand div operator More...
 
template<typename T , typename R , std::size_t NDIM>
Function< TENSOR_RESULT_TYPE(T, R), NDIMmadness::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]. More...
 
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]. More...
 
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]. More...
 
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 More...
 
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] More...
 
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>
std::vector< Function< T, NDIM > > madness::grad (const Function< T, NDIM > &f, bool refine=false, bool fence=true)
 shorthand gradient operator More...
 
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) More...
 
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]) More...
 
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]) More...
 
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 More...
 
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. More...
 
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 More...
 
template<typename T , std::size_t NDIM>
DistributedMatrix< Tmadness::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]) More...
 
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]) More...
 
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. More...
 
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]. More...
 
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]. More...
 
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]. More...
 
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 More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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()) More...
 
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 More...
 
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] More...
 
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] More...
 
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 More...
 
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] More...
 
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] More...
 
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 More...
 
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] More...
 
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 More...
 
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) More...
 
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 More...
 
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) More...
 
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 More...
 
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. More...
 
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) More...
 
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 More...
 
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 More...
 
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 More...
 
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 More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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]. More...
 
template<typename T , std::size_t NDIM>
Function< T, NDIMmadness::sum (World &world, const std::vector< Function< T, NDIM > > &f, bool fence=true)
 Returns new function — q = sum_i f[i]. More...
 
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...
 
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]. More...
 
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]. More...
 
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. More...
 
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. More...
 
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) More...
 
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) More...
 

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);
Fcwf copy(Fcwf psi)
Definition: fcwf.cc:338

) compress: convert multiwavelet representation to legendre representation

compress(world, vector, fence);
void compress(World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
Compress a vector of functions.
Definition: vmra.h:133

) reconstruct: convert representation to multiwavelets

reconstruct(world, vector, fence);
const std::vector< Function< T, NDIM > > & reconstruct(const std::vector< Function< T, NDIM > > &v)
reconstruct a vector of functions
Definition: vmra.h:156

) make_nonstandard: convert to non-standard form

make_nonstandard(world, v, fence);
static const double v
Definition: hatom_sf_dirac.cc:20
void make_nonstandard(World &world, std::vector< Function< T, NDIM > > &v, bool fence=true)
Generates non-standard form of a vector of functions.
Definition: vmra.h:245

) standard: convert to standard form

standard(world, v, fence);
void standard(World &world, std::vector< Function< T, NDIM > > &v, bool fence=true)
Generates standard form of a vector of functions.
Definition: vmra.h:260

) truncate: truncating vectors of functions to desired precision

truncate(world, v, tolerance, fence);
std::vector< Spinor > truncate(std::vector< Spinor > arg)
Definition: dirac-hatom.cc:499

) 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 )
std::vector< Fcwf > transform(World &world, std::vector< Fcwf > &a, Tensor< std::complex< double >> U)
Definition: fcwf.cc:477

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);
void set_thresh(World &world, std::vector< Function< T, NDIM > > &v, double thresh, bool fence=true)
Sets the threshold in a vector of functions.
Definition: vmra.h:1251
static const double thresh
Definition: rk.cc:45

Arithmetic Operations on arrays of functions

) conjugation: conjugate a vector of complex functions

) add ) sub ) mul

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

) inner ) matrix_inner ) norm_tree ) normalize ) norm2