|
| template<std::size_t NDIM> |
| Function< double, NDIM > | madness::abs (const Function< double_complex, NDIM > &z, bool fence=true) |
| | Returns a new function that is the absolute value of the input. More...
|
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::abs (const Function< T, NDIM > &f, bool fence=true) |
| | Create a new function that is the abs of f - global comm only if not reconstructed. More...
|
| |
| template<typename T , std::size_t NDIM> |
| std::enable_if<!TensorTypeData< T >::iscomplex, Function< T, NDIM > >::type | madness::abs_square (const Function< T, NDIM > &f, bool fence=true) |
| | Create a new function that is the abs_square of f - global comm only if not reconstructed. More...
|
| |
| template<typename T , std::size_t NDIM> |
| std::enable_if< TensorTypeData< T >::iscomplex, Function< typename Tensor< T >::scalar_type, NDIM > >::type | madness::abs_square (const Function< T, NDIM > &f, bool fence=true) |
| | Create a new function that is the abs_square of f - global comm only if not reconstructed. More...
|
| |
| template<std::size_t NDIM> |
| Function< double, NDIM > | madness::abssq (const Function< double_complex, NDIM > &z, bool fence=true) |
| | Returns a new function that is the square of the absolute value of the input. More...
|
| |
| template<typename L , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::add (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true) |
| | Same as operator+ but with optional fence and no automatic compression. More...
|
| |
| template<typename opT , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > | madness::apply (const opT &op, const Function< R, NDIM > &f, bool fence=true) |
| | Apply operator in non-standard form. More...
|
| |
| template<typename opT , typename T , std::size_t LDIM> |
| Function< TENSOR_RESULT_TYPE(typename opT::opT, T), LDIM+LDIM > | madness::apply (const opT &op, const std::vector< Function< T, LDIM >> &f1, const std::vector< Function< T, LDIM >> &f2, bool fence=true) |
| | Apply operator on a hartree product of two low-dimensional functions. More...
|
| |
| template<typename opT , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > | madness::apply_1d_realspace_push (const opT &op, const Function< R, NDIM > &f, int axis, bool fence=true) |
| |
| template<typename opT , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > | madness::apply_only (const opT &op, const Function< R, NDIM > &f, bool fence=true) |
| | Apply operator ONLY in non-standard form - required other steps missing !! More...
|
| |
| template<typename L , typename R , typename opT , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::binary_op (const Function< L, NDIM > &left, const Function< R, NDIM > &right, const opT &op, bool fence=true) |
| | Generate new function = op(left,right) where op acts on the function values. More...
|
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::conj (const Function< T, NDIM > &f, bool fence=true) |
| | Return the complex conjugate of the input function with the same distribution and optional fence. More...
|
| |
| template<typename T , typename Q , std::size_t NDIM> |
| Function< Q, NDIM > | madness::convert (const Function< T, NDIM > &f, bool fence=true) |
| | Type conversion implies a deep copy. No communication except for optional fence. More...
|
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::copy (const Function< T, NDIM > &f, bool fence=true) |
| | Create a new copy of the function with the same distribution and optional fence. More...
|
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::copy (const Function< T, NDIM > &f, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool fence=true) |
| | Create a new copy of the function with different distribution and optional fence. More...
|
| |
| std::shared_ptr< FunctionFunctorInterface< double, 3 > > | madness::func (new opT(g)) |
| |
| template<typename L , typename R , std::size_t NDIM> |
| void | madness::gaxpy (TENSOR_RESULT_TYPE(L, R) alpha, Function< L, NDIM > &left, TENSOR_RESULT_TYPE(L, R) beta, const Function< R, NDIM > &right, bool fence=true) |
| | adds beta*right only left: alpha*left + beta*right optional fence and no automatic compression More...
|
| |
| template<typename L , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::gaxpy_oop (TENSOR_RESULT_TYPE(L, R) alpha, const Function< L, NDIM > &left, TENSOR_RESULT_TYPE(L, R) beta, const Function< R, NDIM > &right, bool fence=true) |
| | Returns new function alpha*left + beta*right optional fence and no automatic compression. More...
|
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::gaxpy_oop_reconstructed (const double alpha, const Function< T, NDIM > &left, const double beta, const Function< T, NDIM > &right, const bool fence=true) |
| | Returns new function alpha*left + beta*right optional fence, having both addends reconstructed. More...
|
| |
| std::string | madness::get_mra_data_dir () |
| |
| template<typename T , std::size_t KDIM, std::size_t LDIM> |
| Function< T, KDIM+LDIM > | madness::hartree_product (const Function< T, KDIM > &left2, const Function< T, LDIM > &right2) |
| | Performs a Hartree product on the two given low-dimensional functions. More...
|
| |
| template<typename T , std::size_t KDIM, std::size_t LDIM, typename opT > |
| Function< T, KDIM+LDIM > | madness::hartree_product (const Function< T, KDIM > &left2, const Function< T, LDIM > &right2, const opT &op) |
| | Performs a Hartree product on the two given low-dimensional functions. More...
|
| |
| template<typename T , std::size_t KDIM, std::size_t LDIM> |
| Function< T, KDIM+LDIM > | madness::hartree_product (const std::vector< Function< T, KDIM >> &left, const std::vector< Function< T, LDIM >> &right) |
| | Performs a Hartree/outer product on the two given low-dimensional function vectors. More...
|
| |
| template<std::size_t NDIM> |
| Function< double, NDIM > | madness::imag (const Function< double_complex, NDIM > &z, bool fence=true) |
| | Returns a new function that is the imaginary part of the input. More...
|
| |
| template<typename T , std::size_t LDIM, typename R , std::size_t KDIM> |
| Function< TENSOR_RESULT_TYPE(T, R), KDIM+LDIM-2 > | madness::inner (const Function< T, LDIM > &f, const Function< R, KDIM > &g, const std::tuple< int > v1, const std::tuple< int > v2) |
| | Computes the partial scalar/inner product between two functions, returns a low-dim function. More...
|
| |
| template<typename T , std::size_t LDIM, typename R , std::size_t KDIM> |
| Function< TENSOR_RESULT_TYPE(T, R), KDIM+LDIM-4 > | madness::inner (const Function< T, LDIM > &f, const Function< R, KDIM > &g, const std::tuple< int, int > v1, const std::tuple< int, int > v2) |
| | Computes the partial scalar/inner product between two functions, returns a low-dim function. More...
|
| |
| template<typename T , std::size_t LDIM, typename R , std::size_t KDIM> |
| Function< TENSOR_RESULT_TYPE(T, R), KDIM+LDIM-6 > | madness::inner (const Function< T, LDIM > &f, const Function< R, KDIM > &g, const std::tuple< int, int, int > v1, const std::tuple< int, int, int > v2) |
| | Computes the partial scalar/inner product between two functions, returns a low-dim function. More...
|
| |
| return f | madness::inner (g) |
| |
| return f | madness::inner_adaptive (func) |
| |
| template<std::size_t NDIM, typename T , std::size_t LDIM, typename R , std::size_t KDIM, std::size_t CDIM = (KDIM + LDIM - NDIM) / 2> |
| Function< TENSOR_RESULT_TYPE(T, R), NDIM > | madness::innerXX (const Function< T, LDIM > &f, const Function< R, KDIM > &g, const std::array< int, CDIM > v1, const std::array< int, CDIM > v2, int task=0) |
| | Computes the partial scalar/inner product between two functions, returns a low-dim function. More...
|
| |
| template<std::size_t NDIM, typename T , std::size_t LDIM, typename R , std::size_t KDIM, std::size_t CDIM = (KDIM + LDIM - NDIM) / 2> |
| std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | madness::innerXX (const Function< T, LDIM > &f, const std::vector< Function< R, KDIM >> &vg, const std::array< int, CDIM > v1, const std::array< int, CDIM > v2, int task=0) |
| | Computes the partial scalar/inner product between two functions, returns a low-dim function. More...
|
| |
| template<class T , std::size_t NDIM> |
| void | madness::load (Function< T, NDIM > &f, const std::string name) |
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::map_and_mirror (const Function< T, NDIM > &f, const std::vector< long > &map, const std::vector< long > &mirror, bool fence=true) |
| | This is replaced with mirror(map(f)), optional fence. More...
|
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::mapdim (const Function< T, NDIM > &f, const std::vector< long > &map, bool fence=true) |
| | Generate a new function by reordering dimensions ... optional fence. More...
|
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::mirror (const Function< T, NDIM > &f, const std::vector< long > &mirrormap, bool fence=true) |
| | Generate a new function by mirroring within the dimensions .. optional fence. More...
|
| |
| template<typename L , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::mul (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true) |
| | Same as operator* but with optional fence and no automatic reconstruction. More...
|
| |
| template<typename Q , typename T , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(Q, T), NDIM > | madness::mul (const Function< T, NDIM > &f, const Q alpha, bool fence=true) |
| | Returns new function equal to f(x)*alpha with optional fence. More...
|
| |
| template<typename Q , typename T , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(Q, T), NDIM > | madness::mul (const Q alpha, const Function< T, NDIM > &f, bool fence=true) |
| | Returns new function equal to alpha*f(x) with optional fence. More...
|
| |
| template<typename L , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::mul_sparse (const Function< L, NDIM > &left, const Function< R, NDIM > &right, double tol, bool fence=true) |
| | Sparse multiplication — left and right must be reconstructed and if tol!=0 have tree of norms already created. More...
|
| |
| template<typename T , typename opT , std::size_t NDIM> |
| Function< T, NDIM > | madness::multiop_values (const opT &op, const std::vector< Function< T, NDIM > > &vf) |
| |
| template<typename T , std::size_t NDIM, std::size_t LDIM> |
| Function< T, NDIM > | madness::multiply (const Function< T, NDIM > f, const Function< T, LDIM > g, const int particle, const bool fence=true) |
| | multiply a high-dimensional function with a low-dimensional function More...
|
| |
| template<typename L , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::operator* (const Function< L, NDIM > &left, const Function< R, NDIM > &right) |
| | Multiplies two functions with the new result being of type TensorResultType<L,R> More...
|
| |
| template<typename Q , typename T , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(Q, T), NDIM > | madness::operator* (const Function< T, NDIM > &f, const Q alpha) |
| | Returns new function equal to f(x)*alpha. More...
|
| |
| template<typename Q , typename T , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(Q, T), NDIM > | madness::operator* (const Q alpha, const Function< T, NDIM > &f) |
| | Returns new function equal to alpha*f(x) More...
|
| |
| template<typename L , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::operator+ (const Function< L, NDIM > &left, const Function< R, NDIM > &right) |
| | Adds two functions with the new result being of type TensorResultType<L,R> More...
|
| |
| template<typename T , typename R , std::size_t NDIM> |
| IsSupported< TensorTypeData< R >, Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type | madness::operator+ (const Function< T, NDIM > &f, R r) |
| |
| template<typename T , typename R , std::size_t NDIM> |
| IsSupported< TensorTypeData< R >, Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type | madness::operator+ (R r, const Function< T, NDIM > &f) |
| |
| template<typename L , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::operator- (const Function< L, NDIM > &left, const Function< R, NDIM > &right) |
| | Subtracts two functions with the new result being of type TensorResultType<L,R> More...
|
| |
| template<typename T , typename R , std::size_t NDIM> |
| IsSupported< TensorTypeData< R >, Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type | madness::operator- (const Function< T, NDIM > &f, R r) |
| |
| template<typename T , typename R , std::size_t NDIM> |
| IsSupported< TensorTypeData< R >, Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type | madness::operator- (R r, const Function< T, NDIM > &f) |
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::project (const Function< T, NDIM > &other, int k=FunctionDefaults< NDIM >::get_k(), double thresh=FunctionDefaults< NDIM >::get_thresh(), bool fence=true) |
| |
| template<std::size_t NDIM> |
| Function< double, NDIM > | madness::real (const Function< double, NDIM > &z, bool fence=true) |
| | Returns a new function that is the real part of the input. More...
|
| |
| template<std::size_t NDIM> |
| Function< double, NDIM > | madness::real (const Function< double_complex, NDIM > &z, bool fence=true) |
| | Returns a new function that is the real part of the input. More...
|
| |
| template<class T , std::size_t NDIM> |
| void | madness::save (const Function< T, NDIM > &f, const std::string name) |
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::square (const Function< T, NDIM > &f, bool fence=true) |
| | Create a new function that is the square of f - global comm only if not reconstructed. More...
|
| |
| void | madness::startup (World &world, int argc, char **argv, bool doprint=false, bool make_stdcout_nice_to_reals=true) |
| |
| template<typename L , typename R , std::size_t NDIM> |
| Function< TENSOR_RESULT_TYPE(L, R), NDIM > | madness::sub (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true) |
| | Same as operator- but with optional fence and no automatic compression. More...
|
| |
| template<typename T , std::size_t NDIM> |
| std::enable_if_t< NDIM%2==0, Function< T, NDIM > > | madness::swap_particles (const Function< T, NDIM > &f) |
| | swap particles 1 and 2 More...
|
| |
| template<typename T , std::size_t NDIM> |
| Function< T, NDIM > | madness::symmetrize (const Function< T, NDIM > &f, const std::string symmetry, bool fence=true) |
| | symmetrize a function 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 T , typename opT , std::size_t NDIM> |
| | madness::TENSOR_RESULT_TYPE (T, typename opT::value_type) inner(const Function< T |
| | Computes the scalar/inner product between an MRA function and an external functor. More...
|
| |
| template<typename T , typename opT , std::size_t NDIM> |
| | madness::TENSOR_RESULT_TYPE (T, typename opT::value_type) inner(const opT &g |
| | Computes the scalar/inner product between an MRA function and an external functor. More...
|
| |
| template<typename Q , typename opT , std::size_t NDIM> |
| Function< typename opT::resultT, NDIM > | madness::unary_op (const Function< Q, NDIM > &func, const opT &op, bool fence=true) |
| | Out of place application of unary operation to function values with optional fence. More...
|
| |
| template<typename Q , typename opT , std::size_t NDIM> |
| Function< typename opT::resultT, NDIM > | madness::unary_op_coeffs (const Function< Q, NDIM > &func, const opT &op, bool fence=true) |
| | Out of place application of unary operation to scaling function coefficients with optional fence. More...
|
| |
| template<typename L , typename R , std::size_t D> |
| std::vector< Function< TENSOR_RESULT_TYPE(L, R), D > > | madness::vmulXX (const Function< L, D > &left, const std::vector< Function< R, D > > &vright, double tol, bool fence=true) |
| | Use the vmra/mul(...) interface instead. More...
|
| |
