MADNESS 0.10.1
|
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>
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 Function< T, NDIM > &v, const unsigned int n, bool fence=true) |
Returns a vector of n deep copies of a function. | |
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 , 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> | |
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> | |
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 , 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 inner product of two function vectors - q(i,j) = inner(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_compressed (World &world, int n, bool fence=true) |
Generates a vector of zero functions (compressed) | |
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
) compress: convert multiwavelet representation to legendre representation
) reconstruct: convert representation to multiwavelets
) make_nonstandard: convert to non-standard form
) standard: convert to standard form
) truncate: truncating vectors of functions to desired precision
) zero function: create a vector of zero functions of length n
) transform: transform a representation from one basis to another
Setting thresh-hold for precision
) set_thresh: setting a finite thresh-hold for a vector of functions
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