Classes
class	Add
	Tile addition operation. More...

struct	ArgumentHelper

struct	ArgumentHelper< Future< T > >

struct	ArgumentHelper< std::pair< Future< T >, Future< U > > >

class	ArrayEvalImpl
	Distributed evaluator for `TiledArray::Array` objects. More...

class	ArrayImpl
	Tensor implementation and base for other tensor implementation objects. More...

class	ArrayIterator
	Distributed tensor iterator. More...

class	BinaryEvalImpl
	Binary, distributed tensor evaluator. More...

class	BinaryTransformIterator
	Binary transform iterator. More...

class	BinaryWrapper
	Binary tile operation wrapper. More...

class	Bitset
	Fixed size bitset. More...

class	BlockedPmap
	A blocked process map. More...

class	ComplexConjugate

class	ComplexConjugate< ComplexNegTag >
	Specialization of ComplexConjugate<S> for the case of a negative unit/identity factor. More...

class	ComplexConjugate< void >
	Specialization of ComplexConjugate<S> for the case of a unit/identity factor. More...

struct	ComplexNegTag

class	ContractReduce
	Contract and (sum) reduce operation. More...

class	ContractReduce< Result, Left, Right, TiledArray::detail::ComplexConjugate< Scalar > >
	Contract and reduce operation. More...

class	ContractReduce< Result, Left, Right, TiledArray::detail::ComplexConjugate< void > >
	Contract and (sum) reduce operation. More...

class	ContractReduceBase
	Contract and (sum) reduce base. More...

class	CyclicPmap
	Maps cyclically a sequence of indices onto a 2-d matrix of processes. More...

struct	default_world

class	DistEval
	Tensor expression object. More...

class	DistEvalImpl
	Distributed evaluator implementation object. More...

class	DistributedStorage
	Distributed storage container. More...

struct	eval_trait_base

struct	eval_trait_base< T, typename std::enable_if< has_member_type_eval_type< T >::value &&(detail::is_explicitly_convertible< T, typename T::eval_type >::value\|\|detail::is_explicitly_convertible< T, madness::Future< typename T::eval_type >>::value\|\|detail::is_implicitly_convertible< T, typename T::eval_type >::value\|\|detail::is_implicitly_convertible< T, madness::Future< typename T::eval_type >>::value)>::type >

struct	has_conversion_operator

struct	has_conversion_operator< From, To, typename std::enable_if< is_type< decltype(std::declval< From >().operator To())>::value >::type >

class	HashPmap
	Hashed process map. More...

struct	is_array

struct	is_array< DistArray< T, P > >

struct	is_array_tile
	Detect tiles used by `ArrayEvalImpl`. More...

struct	is_array_tile< TiledArray::detail::LazyArrayTile< T, Op > >

struct	is_bidirectional_iterator

struct	is_complex

struct	is_complex< std::complex< T > >

struct	is_contiguous_tensor

struct	is_contiguous_tensor< T >

struct	is_contiguous_tensor< T1, T2, Ts... >

struct	is_contiguous_tensor<>

struct	is_contiguous_tensor_helper

struct	is_contiguous_tensor_helper< btas::Tensor< T, Args... > >

struct	is_contiguous_tensor_helper< ShiftWrapper< T > >

struct	is_contiguous_tensor_helper< Tensor< T, A > >

struct	is_contiguous_tensor_helper< TensorInterface< T, Range > >

struct	is_convertible

struct	is_dense
	is_dense<T> is a true type if `T` is a dense array More...

struct	is_dense< DistArray< Tile, DensePolicy > >

struct	is_explicitly_convertible

struct	is_forward_iterator

struct	is_implicitly_convertible

struct	is_input_iterator

struct	is_integral_list

struct	is_integral_list_helper

struct	is_integral_list_helper< T, Ts... >

struct	is_integral_list_helper<>

struct	is_integral_pair

struct	is_integral_pair_

struct	is_integral_pair_< std::pair< T1, T2 >, typename std::enable_if< std::is_integral< T1 >::value &&std::is_integral< T2 >::value >::type >

struct	is_integral_pair_list

struct	is_integral_pair_list_helper

struct	is_integral_pair_list_helper< T, Ts... >

struct	is_integral_pair_list_helper<>

struct	is_integral_tuple

struct	is_integral_tuple< std::tuple< Ts... > >

struct	is_iterator

struct	is_iterator< const T *, void >

struct	is_iterator< const T *const, void >

struct	is_iterator< T *, void >

struct	is_iterator< T *const, void >

struct	is_iterator< T, typename std::enable_if< has_member_type_iterator_category< T >::value >::type >

struct	is_non_array_lazy_tile
	Detect a lazy evaluation tile that are not a `LazyArrayTile`. More...

struct	is_numeric

struct	is_numeric< bool >

struct	is_numeric< ComplexConjugate< S > >

struct	is_numeric< std::complex< T > >

struct	is_output_iterator

struct	is_pair

struct	is_pair< std::pair< T1, T2 > >

struct	is_random_iterator

struct	is_same_or_derived

struct	is_scalar

struct	is_scalar< std::complex< T > >

struct	is_shifted

struct	is_shifted< T >

struct	is_shifted< T1, T2, Ts... >

struct	is_shifted<>

struct	is_shifted_helper

struct	is_shifted_helper< ShiftWrapper< T > >

struct	is_strictly_ordered

struct	is_strictly_ordered_helper

struct	is_tensor

struct	is_tensor< T >

struct	is_tensor< T1, T2, Ts... >

struct	is_tensor<>

struct	is_tensor_helper

struct	is_tensor_helper< btas::Tensor< T, Args... > >

struct	is_tensor_helper< ShiftWrapper< const T > >

struct	is_tensor_helper< ShiftWrapper< T > >

struct	is_tensor_helper< Tensor< T, A > >

struct	is_tensor_helper< TensorInterface< T, R > >

struct	is_tensor_of_tensor

struct	is_tensor_of_tensor< T >

struct	is_tensor_of_tensor< T1, T2, Ts... >

struct	is_tensor_of_tensor<>

struct	is_tensor_of_tensor_helper

struct	is_tensor_of_tensor_helper< ShiftWrapper< T > >

struct	is_tensor_of_tensor_helper< Tensor< T, A > >

struct	is_tensor_of_tensor_helper< TensorInterface< T, RangeType > >

struct	is_tuple

struct	is_tuple_

struct	is_type

class	LazyArrayTile
	Lazy tile for on-the-fly evaluation of array tiles. More...

struct	make_void

class	Mult
	Tile multiplication operation. More...

struct	non_iterator_tag

class	Noop
	Tile no operation (noop) More...

struct	numeric_type
	Type trait for extracting the numeric type of tensors and arrays. More...

struct	numeric_type< Eigen::Array< T, Rows, Cols, Opts, MaxRows, MaxCols >, void >

struct	numeric_type< Eigen::Map< PlainObjectType, MapOptions, StrideType >, void >

struct	numeric_type< Eigen::Matrix< T, Rows, Cols, Opts, MaxRows, MaxCols >, void >

struct	numeric_type< T, typename std::enable_if< has_member_type_value_type< T >::value &&(! is_lazy_tile< T >::value) &&(! is_numeric< T >::value)>::type >

struct	numeric_type< T, typename std::enable_if< is_lazy_tile< T >::value &&! is_numeric< T >::value >::type >

struct	numeric_type< T, typename std::enable_if< is_numeric< T >::value >::type >

struct	numeric_type< Tile< T >, void >

struct	param

struct	param< T, typename std::enable_if< is_numeric< T >::value >::type >

struct	param< T, typename std::enable_if< std::is_pointer< T >::value >::type >

struct	param< T, typename std::enable_if< std::is_reference< T >::value >::type >

class	PermIndex
	A functor that permutes ordinal indices. More...

class	ProcGrid
	A 2D processor grid. More...

class	RangeIterator
	Coordinate index iterate. More...

class	ReducePairOpWrapper
	Wrapper that to convert a pair-wise reduction into a standard reduction. More...

class	ReducePairTask
	Reduce pair task. More...

class	ReduceTask
	Reduce task. More...

struct	remove_cvr
	Remove const, volatile, and reference qualifiers. More...

class	ReplicatedPmap
	A Replicated process map. More...

class	Replicator
	Replicate a `Array` object. More...

class	Scal
	Tile scaling operation. More...

class	ScalAdd
	Tile scale-addition operation. More...

struct	scalar_type
	Type trait for extracting the scalar type of tensors and arrays. More...

struct	scalar_type< std::complex< T >, void >

struct	scalar_type< T, typename std::enable_if< is_scalar< T >::value >::type >

struct	scalar_type< T, typename std::enable_if<!is_numeric< T >::value >::type >

class	ScalMult
	Tile scale-multiplication operation. More...

class	ScalShift
	Tile shift operation. More...

class	ScalSubt
	Tile scale-subtraction operation. More...

class	Shift
	Tile shift operation. More...

class	ShiftWrapper
	Shift wrapper class. More...

class	SizeArray
	Array wrapper. More...

class	Subt
	Tile subtraction operation. More...

class	Summa
	Distributed contraction evaluator implementation. More...

class	TensorConstReference

class	TensorImpl
	Tensor implementation and base for other tensor implementation objects. More...

class	TensorInterface
	Tensor interface for external data. More...

class	TensorReference

class	TileConstReference
	Tensor tile reference. More...

class	TileReference
	Tensor tile reference. More...

struct	transform
	customization point transform functionality to tensor class T, useful for nonintrusive extension of T to be usable as tensor type T in Tensor<T> More...

struct	transform< Tensor< T, A > >

class	UnaryEvalImpl
	Tensor that is composed from an argument tensor. More...

class	UnaryTransformIterator
	Unary transform iterator. More...

class	UnaryWrapper
	Unary tile operation wrapper. More...

class	ValArray
	Value array. More...

Typedefs
template<typename... Ts>
using	void_t = typename make_void< Ts... >::type

template<typename T >
using	numeric_t = typename TiledArray::detail::numeric_type< T >::type

template<typename T >
using	scalar_t = typename TiledArray::detail::scalar_type< T >::type

template<bool B, typename T >
using	const_if_t = typename std::conditional< B, const T, T >::type
	prepends `const` to `T` if `B` is `true` More...

template<typename U >
using	param_type = typename param< U >::type

template<typename Scalar1 , typename Scalar2 >
using	add_t = decltype(std::declval< Scalar1 >()+std::declval< Scalar2 >())

template<typename Scalar1 , typename Scalar2 >
using	subt_t = decltype(std::declval< Scalar1 >() - std::declval< Scalar2 >())

template<typename Scalar1 , typename Scalar2 >
using	mult_t = decltype(std::declval< Scalar1 >() *std::declval< Scalar2 >())

template<typename T >
using	trange_t = typename T::trange_type

template<typename T >
using	shape_t = typename T::shape_type

template<typename T >
using	pmap_t = typename T::pmap_interface

template<typename T >
using	policy_t = typename T::policy_type

Functions
std::string	dummy_annotation (unsigned int DIM)

template<typename Impl >
bool	operator== (const TileReference< Impl > &a, const TileReference< Impl > &b)
	comparison operator for TileReference objects More...

template<typename Impl >
bool	operator!= (const TileReference< Impl > &a, const TileReference< Impl > &b)
	inequality operator for TileReference objects More...

template<typename Impl >
std::ostream &	operator<< (std::ostream &os, const TileReference< Impl > &a)
	redirect operator to std::ostream for TileReference objects More...

template<typename Impl >
bool	operator== (const TileConstReference< Impl > &a, const TileConstReference< Impl > &b)
	comparison operator for TileConstReference objects More...

template<typename Impl >
bool	operator!= (const TileConstReference< Impl > &a, const TileConstReference< Impl > &b)
	inequality operator for TileConstReference objects More...

template<typename Impl >
std::ostream &	operator<< (std::ostream &os, const TileConstReference< Impl > &a)
	redirect operator to std::ostream for TileConstReference objects More...

template<typename B >
void	swap (Bitset< B > &b0, Bitset< B > &b1)

template<typename Block >
Bitset< Block >	operator & (Bitset< Block > left, const Bitset< Block > &right)
	Bitwise and operator of bitset. More...

template<typename Block >
Bitset< Block >	operator\| (Bitset< Block > left, const Bitset< Block > &right)
	Bitwise or operator of bitset. More...

template<typename Block >
Bitset< Block >	operator^ (Bitset< Block > left, const Bitset< Block > &right)
	Bitwise xor operator of bitset. More...

template<typename Block >
std::ostream &	operator<< (std::ostream &os, const Bitset< Block > &bitset)

template<typename DistArray_ , typename BTAS_Tensor_ >
void	counted_btas_subtensor_to_tensor (const BTAS_Tensor_ src, DistArray_ dst, const typename DistArray_::size_type i, madness::AtomicInt *counter)
	Task function for converting btas::Tensor subblock to a TiledArray::DistArray. More...

template<typename TA_Tensor_ , typename BTAS_Tensor_ >
void	counted_tensor_to_btas_subtensor (const TA_Tensor_ &src, BTAS_Tensor_ dst, madness::AtomicInt counter)
	Task function for assigning a tensor to an Eigen submatrix. More...

template<bool sparse>
auto	make_shape (World &world, const TiledArray::TiledRange &trange)

template<>
auto	make_shape< true > (World &world, const TiledArray::TiledRange &trange)

template<>
auto	make_shape< false > (World &, const TiledArray::TiledRange &)

template<typename A , typename Derived >
void	counted_eigen_submatrix_to_tensor (const Eigen::MatrixBase< Derived > matrix, A array, const typename A::size_type i, madness::AtomicInt *counter)
	Task function for converting Eigen submatrix to a tensor. More...

template<typename Derived , typename T >
void	counted_tensor_to_eigen_submatrix (const T &tensor, Eigen::MatrixBase< Derived > matrix, madness::AtomicInt counter)
	Task function for assigning a tensor to an Eigen submatrix. More...

template<bool inplace = false, typename Op , typename ResultTile , typename ArgTile , typename... ArgTiles>
DistArray< ResultTile, DensePolicy >	foreach (Op &&op, const_if_t< not inplace, DistArray< ArgTile, DensePolicy >> &arg, const DistArray< ArgTiles, DensePolicy > &... args)
	base implementation of dense TiledArray::foreach More...

template<bool inplace = false, typename Op , typename ResultTile , typename ArgTile , typename... ArgTiles>
DistArray< ResultTile, SparsePolicy >	foreach (Op &&op, const ShapeReductionMethod shape_reduction, const_if_t< not inplace, DistArray< ArgTile, SparsePolicy >> &arg, const DistArray< ArgTiles, SparsePolicy > &... args)
	base implementation of sparse TiledArray::foreach More...

const TiledArray::Range &	make_ta_range (const TiledArray::Range &range)

template<CBLAS_ORDER Order, typename... Args>
TiledArray::Range	make_ta_range (const btas::RangeNd< Order, Args... > &range)
	makes TiledArray::Range from a btas::RangeNd More...

template<typename Perm , typename Arg , typename Result >
void	permute_array (const Perm &perm, const Arg &arg, Result &result)
	Create a permuted copy of an array. More...

template<typename T , typename Container >
bool	operator== (const RangeIterator< T, Container > &left_it, const RangeIterator< T, Container > &right_it)
	Equality operator. More...

template<typename T , typename Container >
bool	operator!= (const RangeIterator< T, Container > &left_it, const RangeIterator< T, Container > &right_it)
	Inequality operator. More...

template<typename T >
std::vector< T >	operator* (const Permutation &perm, const SizeArray< T > &orig)

template<typename T >
std::ostream &	operator<< (std::ostream &os, const SizeArray< T > &size_array)

Range	diagonal_range (Range const &rng)

template<typename T >
Tensor< float >	diagonal_shape (TiledRange const &trange, T val)

template<typename Array , typename T >
void	write_tiles_to_array (Array &A, T val)

template<typename R , typename std::enable_if<! is_complex< R >::value >::type * = nullptr>
TILEDARRAY_FORCE_INLINE R	conj (const R r)
	Wrapper function for `std::conj` More...

template<typename R >
TILEDARRAY_FORCE_INLINE std::complex< R >	conj (const std::complex< R > z)
	Wrapper function for std::conj. More...

template<typename L , typename R , typename std::enable_if<! is_complex< L >::value >::type * = nullptr>
TILEDARRAY_FORCE_INLINE auto	inner_product (const L l, const R r)
	Inner product of a real value and a numeric value. More...

template<typename R , typename std::enable_if<! is_complex< R >::value >::type * = nullptr>
TILEDARRAY_FORCE_INLINE R	norm (const R r)
	Wrapper function for `std::norm` More...

template<typename R >
TILEDARRAY_FORCE_INLINE R	norm (const std::complex< R > z)
	Compute the norm of a complex number `z` More...

template<typename S >
ComplexConjugate< S >	conj_op (const S factor)
	ComplexConjugate operator factory function. More...

ComplexConjugate< void >	conj_op ()
	ComplexConjugate operator factory function. More...

template<typename L , typename R >
TILEDARRAY_FORCE_INLINE auto	operator* (const L value, const ComplexConjugate< R > op)

template<typename L >
TILEDARRAY_FORCE_INLINE auto	operator* (const L value, const ComplexConjugate< void > &)

template<typename L >
TILEDARRAY_FORCE_INLINE auto	operator* (const L value, const ComplexConjugate< ComplexNegTag > &)

template<typename L , typename R >
TILEDARRAY_FORCE_INLINE auto	operator* (const ComplexConjugate< L > op, const R value)

template<typename R >
TILEDARRAY_FORCE_INLINE auto	operator* (const ComplexConjugate< void >, const R value)

template<typename R >
TILEDARRAY_FORCE_INLINE auto	operator* (const ComplexConjugate< ComplexNegTag >, const R value)

template<typename L , typename R , typename std::enable_if<! std::is_void< R >::value >::type * = nullptr>
TILEDARRAY_FORCE_INLINE L &	operator*= (L &value, const ComplexConjugate< R > op)

template<typename L >
TILEDARRAY_FORCE_INLINE L &	operator*= (L &value, const ComplexConjugate< void > &)

template<typename L >
TILEDARRAY_FORCE_INLINE L &	operator*= (L &value, const ComplexConjugate< ComplexNegTag > &)

template<typename T >
auto	abs (const ComplexConjugate< T > &a)

int	abs (const ComplexConjugate< void > &a)

template<typename TR , typename Op , typename T1 , typename... Ts, typename std::enable_if< is_tensor< TR, T1, Ts... >::value\|\|is_tensor_of_tensor< TR, T1, Ts... >::value >::type * = nullptr>
TR	tensor_op (Op &&op, const T1 &tensor1, const Ts &... tensors)
	Tensor operations with contiguous data. More...

template<typename TR , typename Op , typename T1 , typename... Ts, typename std::enable_if<(is_tensor< T1, Ts... >::value\|\|is_tensor_of_tensor< TR, T1, Ts... >::value) &&is_contiguous_tensor< T1, Ts... >::value >::type * = nullptr>
TR	tensor_op (Op &&op, const Permutation &perm, const T1 &tensor1, const Ts &... tensors)
	Tensor permutation operations with contiguous data. More...

template<typename Op , typename TR , typename... Ts, typename std::enable_if< is_tensor< TR, Ts... >::value &&is_contiguous_tensor< TR, Ts... >::value >::type * = nullptr>
void	inplace_tensor_op (Op &&op, TR &result, const Ts &... tensors)
	In-place tensor operations with contiguous data. More...

template<typename InputOp , typename OutputOp , typename TR , typename T1 , typename... Ts, typename std::enable_if< is_tensor< TR, T1, Ts... >::value &&is_contiguous_tensor< TR, T1, Ts... >::value >::type * = nullptr>
void	inplace_tensor_op (InputOp &&input_op, OutputOp &&output_op, const Permutation &perm, TR &result, const T1 &tensor1, const Ts &... tensors)
	In-place tensor permutation operations with contiguous data. More...

template<typename Op , typename TR , typename... Ts, typename std::enable_if< is_tensor< TR, Ts... >::value &&is_contiguous_tensor< TR, Ts... >::value >::type * = nullptr>
void	tensor_init (Op &&op, TR &result, const Ts &... tensors)
	Initialize tensor with contiguous tensor arguments. More...

template<typename Op , typename TR , typename T1 , typename... Ts, typename std::enable_if< is_tensor< TR, T1, Ts... >::value &&is_contiguous_tensor< TR, T1, Ts... >::value >::type * = nullptr>
void	tensor_init (Op &&op, const Permutation &perm, TR &result, const T1 &tensor1, const Ts &... tensors)
	Initialize tensor with permuted tensor arguments. More...

template<typename Op , typename TR , typename T1 , typename... Ts, typename std::enable_if< is_tensor< TR, T1, Ts... >::value &&is_contiguous_tensor< TR >::value &&! is_contiguous_tensor< T1, Ts... >::value >::type * = nullptr>
void	tensor_init (Op &&op, TR &result, const T1 &tensor1, const Ts &... tensors)
	Initialize tensor with one or more non-contiguous tensor arguments. More...

template<typename ReduceOp , typename JoinOp , typename Scalar , typename T1 , typename... Ts, typename std::enable_if_t< is_tensor< T1, Ts... >::value &&is_contiguous_tensor< T1, Ts... >::value > * = nullptr>
Scalar	tensor_reduce (ReduceOp &&reduce_op, JoinOp &&join_op, Scalar identity, const T1 &tensor1, const Ts &... tensors)
	Reduction operation for contiguous tensors. More...

template<typename SizeType >
void	fuse_dimensions (SizeType MADNESS_RESTRICT const fused_size, SizeType MADNESS_RESTRICT const fused_weight, const SizeType *MADNESS_RESTRICT const size, const Permutation &perm)
	Compute the fused dimensions for permutation. More...

template<typename InputOp , typename OutputOp , typename Result , typename Arg0 , typename... Args>
void	permute (InputOp &&input_op, OutputOp &&output_op, Result &result, const Permutation &perm, const Arg0 &arg0, const Args &... args)
	Construct a permuted tensor copy. More...

template<typename Left , typename Right >
bool	is_range_congruent (const Left &left, const ShiftWrapper< Right > &right)
	Check for congruent range objects with a shifted tensor. More...

template<typename T , typename std::enable_if< is_contiguous_tensor< T >::value >::type * = nullptr>
auto	clone_range (const T &tensor)
	Create a copy of the range of the tensor. More...

template<typename T , typename std::enable_if<! is_contiguous_tensor< T >::value >::type * = nullptr>
Range	clone_range (const T &tensor)
	Create a contiguous copy of the range of the tensor. More...

template<typename Range >
bool	is_congruent (const Range &r1, const Range &r2)
	Test the two ranges are congruent. More...

template<>
bool	is_congruent (const BlockRange &r1, const BlockRange &r2)
	Test that two BlockRange are congruent. More...

template<typename Range >
bool	is_congruent (const BlockRange &r1, const Range &r2)
	Test that BlockRange and Range are congruent. More...

template<typename Range >
bool	is_congruent (const Range &r1, const BlockRange &r2)
	Test that Range and BlockRange are congruent. More...

template<typename T1 , typename T2 , typename std::enable_if<!(is_shifted< T1 >::value\|\|is_shifted< T2 >::value)>::type * = nullptr>
bool	is_range_congruent (const T1 &tensor1, const T2 &tensor2)
	Test that the ranges of a pair of tensors are congruent. More...

template<typename T1 , typename T2 , typename std::enable_if<!(is_shifted< T1 >::value\|\|is_shifted< T2 >::value)>::type * = nullptr>
bool	is_range_congruent (const T1 &tensor1, const T2 &tensor2, const Permutation &perm)
	Test that the ranges of a pair of permuted tensors are congruent. More...

template<typename T >
constexpr bool	is_range_set_congruent (const Permutation &perm, const T &tensor)
	Test that the ranges of a permuted tensor is congruent with itself. More...

template<typename T1 , typename T2 , typename... Ts>
bool	is_range_set_congruent (const Permutation &perm, const T1 &tensor1, const T2 &tensor2, const Ts &... tensors)
	Test that the ranges of a permuted set of tensors are congruent. More...

template<typename T >
constexpr bool	is_range_set_congruent (const T &tensor)
	Test that the ranges of a tensor is congruent with itself. More...

template<typename T1 , typename T2 , typename... Ts>
bool	is_range_set_congruent (const T1 &tensor1, const T2 &tensor2, const Ts &... tensors)
	Test that the ranges of a set of tensors are congruent. More...

template<typename T >
T::size_type	inner_size_helper (const T &tensor)
	Get the inner size. More...

template<typename T1 , typename T2 >
T1::size_type	inner_size_helper (const T1 &tensor1, const T2 &tensor2)
	Get the inner size of two tensors. More...

template<typename T1 , typename T2 , typename std::enable_if<! is_contiguous_tensor< T1 >::value &&is_contiguous_tensor< T2 >::value >::type * = nullptr>
T1::size_type	inner_size (const T1 &tensor1, const T2 &)
	Get the inner size of two tensors. More...

template<typename T , typename std::enable_if<! is_contiguous_tensor< T >::value >::type * = nullptr>
T::size_type	inner_size (const T &tensor)
	Get the inner size. More...

constexpr bool	empty ()
	Test for empty tensors in an empty list. More...

template<typename T1 , typename... Ts>
bool	empty (const T1 &tensor1, const Ts &... tensors)
	Test for empty tensors. More...

template<typename T >
Tile< T >	make_tile (T &&t)
	Factory function for tiles. More...

template<typename Iter1 , typename Iter2 , typename Op >
BinaryTransformIterator< Iter1, Iter2, Op >	make_tran_it (Iter1 it1, Iter2 it2, Op op)
	Binary Transform iterator factory. More...

template<typename Iter , typename Op >
UnaryTransformIterator< Iter, Op >	make_tran_it (Iter it, Op op)
	Unary Transform iterator factory. More...

template<typename T , std::size_t N>
constexpr std::size_t	size (T(&)[N])
	Array size accessor. More...

template<typename T , std::size_t N>
constexpr std::size_t	size (const std::array< T, N > &)
	Array size accessor. More...

template<typename T , typename std::enable_if<! std::is_array< T >::value >::type * = nullptr>
auto	size (const T &a)
	Array size accessor. More...

template<typename T >
auto	size (std::initializer_list< T > a)
	Array size accessor. More...

template<typename ... Ts>
auto	size (const std::tuple< Ts... > &a)
	Tuple size accessor. More...

template<typename T , typename std::enable_if<! std::is_pointer< T >::value >::type * = nullptr>
auto	data (T &t)
	Container data pointer accessor. More...

template<typename T , typename std::enable_if<! std::is_pointer< T >::value >::type * = nullptr>
auto	data (const T &t)
	Container data pointer accessor. More...

template<typename T , typename std::enable_if< std::is_pointer< T >::value >::type * = nullptr>
T	data (T t)
	Pointer data adapter. More...

template<typename T , std::size_t N>
T *	data (T(&a)[N])
	Array data pointer accessor. More...

template<typename T , std::size_t N>
const T *	data (const T(&a)[N])
	Array data pointer accessor. More...

template<typename T >
T *	data (std::initializer_list< T > &l)
	Initializer list data pointer accessor. More...

template<typename T >
const T *	data (const std::initializer_list< T > &l)
	Initializer list const data pointer accessor. More...

template<typename A >
void	print_array (std::ostream &out, const A &a, const std::size_t n)
	Print the content of an array like object. More...

template<typename A >
void	print_array (std::ostream &out, const A &a)
	Print the content of an array like object. More...

template<typename T >
std::ostream &	operator<< (std::ostream &os, const ValArray< T > &val_array)

Typedef Documentation

◆ add_t

template<typename Scalar1 , typename Scalar2 >

using TiledArray::detail::add_t = typedef decltype(std::declval<Scalar1>() + std::declval<Scalar2>())

Definition at line 741 of file type_traits.h.

◆ const_if_t

template<bool B, typename T >

using TiledArray::detail::const_if_t = typedef typename std::conditional<B, const T, T>::type

prepends const to T if B is true

Definition at line 653 of file type_traits.h.

◆ mult_t

template<typename Scalar1 , typename Scalar2 >

using TiledArray::detail::mult_t = typedef decltype(std::declval<Scalar1>() * std::declval<Scalar2>())

Definition at line 748 of file type_traits.h.

◆ numeric_t

template<typename T >

using TiledArray::detail::numeric_t = typedef typename TiledArray::detail::numeric_type<T>::type

Definition at line 525 of file type_traits.h.

◆ param_type

template<typename U >

using TiledArray::detail::param_type = typedef typename param<U>::type

Definition at line 677 of file type_traits.h.

◆ pmap_t

template<typename T >

using TiledArray::detail::pmap_t = typedef typename T::pmap_interface

Definition at line 770 of file type_traits.h.

◆ policy_t

template<typename T >

using TiledArray::detail::policy_t = typedef typename T::policy_type

Definition at line 773 of file type_traits.h.

◆ scalar_t

template<typename T >

using TiledArray::detail::scalar_t = typedef typename TiledArray::detail::scalar_type<T>::type

Definition at line 555 of file type_traits.h.

◆ shape_t

template<typename T >

using TiledArray::detail::shape_t = typedef typename T::shape_type

Definition at line 767 of file type_traits.h.

◆ subt_t

template<typename Scalar1 , typename Scalar2 >

using TiledArray::detail::subt_t = typedef decltype(std::declval<Scalar1>() - std::declval<Scalar2>())

Definition at line 745 of file type_traits.h.

◆ trange_t

template<typename T >

using TiledArray::detail::trange_t = typedef typename T::trange_type

Definition at line 764 of file type_traits.h.

◆ void_t

template<typename... Ts>

using TiledArray::detail::void_t = typedef typename make_void<Ts...>::type

Definition at line 282 of file type_traits.h.

Function Documentation

◆ abs() [1/2]

template<typename T >

auto TiledArray::detail::abs ( const ComplexConjugate< T > & a )

inline

Definition at line 247 of file complex.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ abs() [2/2]

int TiledArray::detail::abs ( const ComplexConjugate< void > & a )

inline

Definition at line 251 of file complex.h.

Here is the caller graph for this function:

◆ clone_range() [1/2]

template<typename T , typename std::enable_if< is_contiguous_tensor< T >::value >::type * = nullptr>

auto TiledArray::detail::clone_range ( const T & tensor )

inline

Create a copy of the range of the tensor.

Template Parameters

T	The tensor type

Parameters

tensor The tensor with the range to be cloned

Returns: A contiguous range with the same lower and upper bounds as the range of tensor.

Definition at line 46 of file utility.h.

◆ clone_range() [2/2]

template<typename T , typename std::enable_if<! is_contiguous_tensor< T >::value >::type * = nullptr>

Range TiledArray::detail::clone_range ( const T & tensor )

inline

Create a contiguous copy of the range of the tensor.

Template Parameters

T	The tensor type

Parameters

tensor The tensor with the range to be cloned

Returns: A contiguous range with the same lower and upper bounds as the range of tensor.

Definition at line 57 of file utility.h.

◆ conj() [1/2]

template<typename R , typename std::enable_if<! is_complex< R >::value >::type * = nullptr>

TILEDARRAY_FORCE_INLINE R TiledArray::detail::conj ( const R r )

Wrapper function for std::conj

This function disables the call to std::conj for real values to prevent the result from being converted into a complex value.

Template Parameters

R	A real scalar type

Parameters

r	The real scalar

Returns: r

Definition at line 44 of file complex.h.

Here is the caller graph for this function:

◆ conj() [2/2]

template<typename R >

TILEDARRAY_FORCE_INLINE std::complex<R> TiledArray::detail::conj ( const std::complex< R > z )

Wrapper function for std::conj.

Template Parameters

R	The scalar type

Parameters

z	The complex scalar

Returns: The complex conjugate of z

Definition at line 54 of file complex.h.

◆ conj_op() [1/2]

template<typename S >

ComplexConjugate<S> TiledArray::detail::conj_op ( const S factor )

inline

ComplexConjugate operator factory function.

Template Parameters

S	The scalar type

Parameters

factor The scaling factor

Returns: A scaling complex conjugate operator

Definition at line 181 of file complex.h.

Here is the caller graph for this function:

◆ conj_op() [2/2]

ComplexConjugate<void> TiledArray::detail::conj_op ( )

inline

ComplexConjugate operator factory function.

Returns: A complex conjugate operator

Definition at line 188 of file complex.h.

◆ counted_btas_subtensor_to_tensor()

template<typename DistArray_ , typename BTAS_Tensor_ >

void TiledArray::detail::counted_btas_subtensor_to_tensor	(	const BTAS_Tensor_ *	src,
		DistArray_ *	dst,
		const typename DistArray_::size_type	i,
		madness::AtomicInt *	counter
	)

Task function for converting btas::Tensor subblock to a TiledArray::DistArray.

Template Parameters

DistArray_	a TiledArray::DistArray type
TArgs	the type pack in btas::Tensor<TArgs...> type

Parameters

src	The btas::Tensor object whose block will be copied
dst	The array that will hold the result
i	The index of the tile to be copied
counter	The task counter

Definition at line 99 of file btas.h.

Here is the call graph for this function:

◆ counted_eigen_submatrix_to_tensor()

template<typename A , typename Derived >

void TiledArray::detail::counted_eigen_submatrix_to_tensor	(	const Eigen::MatrixBase< Derived > *	matrix,
		A *	array,
		const typename A::size_type	i,
		madness::AtomicInt *	counter
	)

Task function for converting Eigen submatrix to a tensor.

Template Parameters

A	Array type
Derived	The matrix type

Parameters

matrix	The matrix that will be copied
array	The array that will hold the result
i	The index of the tile to be copied
counter	The task counter

Definition at line 296 of file eigen.h.

Here is the call graph for this function:

◆ counted_tensor_to_btas_subtensor()

template<typename TA_Tensor_ , typename BTAS_Tensor_ >

void TiledArray::detail::counted_tensor_to_btas_subtensor	(	const TA_Tensor_ &	src,
		BTAS_Tensor_ *	dst,
		madness::AtomicInt *	counter
	)

Task function for assigning a tensor to an Eigen submatrix.

Template Parameters

Tensor_	a TiledArray::Tensor type
TArgs	the type pack in btas::Tensor<TArgs...> type

Parameters

src	The source tensor
dst	The destination tensor
counter	The task counter

Definition at line 116 of file btas.h.

Here is the call graph for this function:

◆ counted_tensor_to_eigen_submatrix()

template<typename Derived , typename T >

void TiledArray::detail::counted_tensor_to_eigen_submatrix	(	const T &	tensor,
		Eigen::MatrixBase< Derived > *	matrix,
		madness::AtomicInt *	counter
	)

Task function for assigning a tensor to an Eigen submatrix.

Template Parameters

Derived	The matrix type
T	Tensor type

Parameters

matrix	The matrix to be assigned
tensor	The tensor to be copied
counter	The task counter

Definition at line 313 of file eigen.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ data() [1/7]

template<typename T , typename std::enable_if<! std::is_pointer< T >::value >::type * = nullptr>

auto TiledArray::detail::data ( T & t )

inline

Container data pointer accessor.

Template Parameters

T	The container type

Parameters

t	A container object

Returns: A pointer to the first element of the container, v

Definition at line 89 of file utility.h.

Here is the caller graph for this function:

◆ data() [2/7]

template<typename T , typename std::enable_if<! std::is_pointer< T >::value >::type * = nullptr>

auto TiledArray::detail::data ( const T & t )

inline

Container data pointer accessor.

Template Parameters

T	The container type

Parameters

t	A container object

Returns: A pointer to the first element of the container, v

Definition at line 101 of file utility.h.

◆ data() [3/7]

template<typename T , typename std::enable_if< std::is_pointer< T >::value >::type * = nullptr>

T TiledArray::detail::data ( T t )

inline

Pointer data adapter.

Template Parameters

T	The container type

Parameters

t A pointer

Returns: t (pass through)

Definition at line 111 of file utility.h.

◆ data() [4/7]

template<typename T , std::size_t N>

T* TiledArray::detail::data ( T(&) a[N] )

inline

Array data pointer accessor.

Template Parameters

T	The array type

Parameters

a	The c-style array object

Returns: A pointer to the first element of the array

Definition at line 119 of file utility.h.

◆ data() [5/7]

template<typename T , std::size_t N>

const T* TiledArray::detail::data ( const T(&) a[N] )

inline

Array data pointer accessor.

Template Parameters

T	The array type

Parameters

a	The c-style array object

Returns: A pointer to the first element of the array

Definition at line 127 of file utility.h.

◆ data() [6/7]

template<typename T >

T* TiledArray::detail::data ( std::initializer_list< T > & l )

inline

Initializer list data pointer accessor.

Template Parameters

T	The initializer list element type

Parameters

l	An initializer list object

Returns: A pointer to the first element of the initializer list, l

Definition at line 136 of file utility.h.

◆ data() [7/7]

template<typename T >

const T* TiledArray::detail::data ( const std::initializer_list< T > & l )

inline

Initializer list const data pointer accessor.

Template Parameters

T	The initializer list element type

Parameters

l	An initializer list object

Returns: A const pointer to the first element of the initializer list, l

Definition at line 144 of file utility.h.

◆ diagonal_range()

Range TiledArray::detail::diagonal_range ( Range const & rng )

inline

Definition at line 40 of file diagonal_array.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ diagonal_shape()

template<typename T >

Tensor<float> TiledArray::detail::diagonal_shape	(	TiledRange const &	trange,
		T	val
	)

Definition at line 58 of file diagonal_array.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dummy_annotation()

std::string TiledArray::detail::dummy_annotation ( unsigned int DIM )

inline

Definition at line 38 of file utils.h.

Here is the caller graph for this function:

◆ empty() [1/2]

constexpr bool TiledArray::detail::empty ( )

inline

Test for empty tensors in an empty list.

This function is used as the termination step for the recursive empty() function. It also handles the case where there are no tensors in the list.

Returns: true

Definition at line 374 of file utility.h.

Here is the caller graph for this function:

◆ empty() [2/2]

template<typename T1 , typename... Ts>

bool TiledArray::detail::empty	(	const T1 &	tensor1,
		const Ts &...	tensors
	)

inline

Test for empty tensors.

Template Parameters

T1	The first tensor type
Ts	The remaining tensor types

Parameters

tensor1	The first tensor to test
tensors	The remaining tensors to test

Returns: true if one or more tensors are empty

Definition at line 384 of file utility.h.

Here is the call graph for this function:

◆ foreach() [1/2]

template<bool inplace = false, typename Op , typename ResultTile , typename ArgTile , typename... ArgTiles>

DistArray<ResultTile, DensePolicy> TiledArray::detail::foreach	(	Op &&	op,
		const_if_t< not inplace, DistArray< ArgTile, DensePolicy >> &	arg,
		const DistArray< ArgTiles, DensePolicy > &...	args
	)

inline

base implementation of dense TiledArray::foreach

Note: can't autodeduce ResultTile from void Op(ResultTile,ArgTile)

Definition at line 135 of file foreach.h.

Here is the call graph for this function:

◆ foreach() [2/2]

template<bool inplace = false, typename Op , typename ResultTile , typename ArgTile , typename... ArgTiles>

DistArray<ResultTile, SparsePolicy> TiledArray::detail::foreach	(	Op &&	op,
		const ShapeReductionMethod	shape_reduction,
		const_if_t< not inplace, DistArray< ArgTile, SparsePolicy >> &	arg,
		const DistArray< ArgTiles, SparsePolicy > &...	args
	)

inline

base implementation of sparse TiledArray::foreach

Note: can't autodeduce ResultTile from void Op(ResultTile,ArgTile)

Definition at line 174 of file foreach.h.

Here is the call graph for this function:

◆ fuse_dimensions()

template<typename SizeType >

void TiledArray::detail::fuse_dimensions	(	SizeType *MADNESS_RESTRICT const	fused_size,
		SizeType *MADNESS_RESTRICT const	fused_weight,
		const SizeType *MADNESS_RESTRICT const	size,
		const Permutation &	perm
	)

inline

Compute the fused dimensions for permutation.

This function will compute the fused dimensions of a tensor for use in permutation algorithms. The idea is to partition the stride 1 dimensions in both the input and output tensor, which yields a forth-order tensor (second- and third-order tensors have size of 1 and stride of 0 in the unused dimensions).

Template Parameters

SizeType An unsigned integral type

Parameters

[out]	fused_size	An array for the fused size output
[out]	fused_weight	An array for the fused weight output
[in]	size	An array that holds the unfused size information of the argument tensor
[in]	perm	The permutation that will be applied to the argument tensor(s).

Definition at line 51 of file permute.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inner_product()

template<typename L , typename R , typename std::enable_if<! is_complex< L >::value >::type * = nullptr>

TILEDARRAY_FORCE_INLINE auto TiledArray::detail::inner_product	(	const L	l,
		const R	r
	)

Inner product of a real value and a numeric value.

Inner product of a complex value and a numeric value.

Template Parameters

L	A real scalar type
R	A numeric type

Returns: r

Template Parameters

L	A complex type
R	A numeric type

Returns: r

Definition at line 65 of file complex.h.

Here is the caller graph for this function:

◆ inner_size() [1/2]

template<typename T1 , typename T2 , typename std::enable_if<! is_contiguous_tensor< T1 >::value &&is_contiguous_tensor< T2 >::value >::type * = nullptr>

T1::size_type TiledArray::detail::inner_size	(	const T1 &	tensor1,
		const T2 &	tensor2
	)

inline

Get the inner size of two tensors.

This function searches of the largest, common contiguous size in the ranges of two non-contiguous tensors. At a minimum, this is equal to the size of the stride-one dimension.

Template Parameters

T1	The first tensor type
T2	The secont tensor type

Parameters

tensor1 The first tensor to be tested

Returns: The largest contiguous, inner-dimension size.

This function searches of the largest, common contiguous size in the ranges of two non-contiguous tensors. At a minimum, this is equal to the size of the stride-one dimension.

Template Parameters

T1	The first tensor type
T2	The secont tensor type

Parameters

tensor2 The second tensor to be tested

Returns: The largest contiguous, inner-dimension size.

This function searches of the largest, common contiguous size in the ranges of two non-contiguous tensors. At a minimum, this is equal to the size of the stride-one dimension.

Template Parameters

T1	The first tensor type
T2	The secont tensor type

Parameters

tensor1	The first tensor to be tested
tensor2	The second tensor to be tested

Returns: The largest common, contiguous inner-dimension size of the two tensors.

Definition at line 313 of file utility.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inner_size() [2/2]

template<typename T , typename std::enable_if<! is_contiguous_tensor< T >::value >::type * = nullptr>

T::size_type TiledArray::detail::inner_size ( const T & tensor )

inline

Get the inner size.

This function searches of the largest contiguous size in the range of a non-contiguous tensor. At a minimum, this is equal to the size of the stride-one dimension.

Template Parameters

T	A tensor type

Parameters

tensor The tensor to be tested

Returns: The largest contiguous, inner-dimension size.

Definition at line 363 of file utility.h.

Here is the call graph for this function:

◆ inner_size_helper() [1/2]

template<typename T >

T::size_type TiledArray::detail::inner_size_helper ( const T & tensor )

inline

Get the inner size.

This function searches of the largest contiguous size in the range of a non-contiguous tensor. At a minimum, this is equal to the size of the stride-one dimension.

Template Parameters

T	A tensor type

Parameters

tensor The tensor to be tested

Returns: The largest contiguous, inner-dimension size.

Definition at line 244 of file utility.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inner_size_helper() [2/2]

template<typename T1 , typename T2 >

T1::size_type TiledArray::detail::inner_size_helper	(	const T1 &	tensor1,
		const T2 &	tensor2
	)

inline

Get the inner size of two tensors.

This function searches of the largest, common contiguous size in the ranges of two non-contiguous tensors. At a minimum, this is equal to the size of the stride-one dimension.

Template Parameters

T1	The first tensor type
T2	The secont tensor type

Parameters

tensor1	The first tensor to be tested
tensor2	The second tensor to be tested

Returns: The largest contiguous, inner-dimension size of the two tensors.

Definition at line 275 of file utility.h.

Here is the call graph for this function:

◆ inplace_tensor_op() [1/2]

template<typename Op , typename TR , typename... Ts, typename std::enable_if< is_tensor< TR, Ts... >::value &&is_contiguous_tensor< TR, Ts... >::value >::type * = nullptr>

void TiledArray::detail::inplace_tensor_op	(	Op &&	op,
		TR &	result,
		const Ts &...	tensors
	)

inline

In-place tensor operations with contiguous data.

In-place tensor of tensors operations with non-contiguous data.

In-place tensor operations with non-contiguous data.

In-place tensor of tensors operations with contiguous data.

This function sets the elements of result with the result of op(tensors[i]...)

Template Parameters

Op	The element initialization operation type
TR	The result tensor type
Ts	The remaining argument tensor types

Parameters

[in]	op	The result tensor element initialization operation
[in,out]	result	The result tensor
[in]	tensors	The argument tensors

This function sets the i -th element of result with the result of op(tensors[i]...)

Template Parameters

Op	The element initialization operation type
TR	The result tensor type
Ts	The remaining argument tensor types

Parameters

[in]	op	The result tensor element initialization operation
[in,out]	result	The result tensor
[in]	tensors	The argument tensors

Definition at line 163 of file kernels.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inplace_tensor_op() [2/2]

template<typename InputOp , typename OutputOp , typename TR , typename T1 , typename... Ts, typename std::enable_if< is_tensor< TR, T1, Ts... >::value &&is_contiguous_tensor< TR, T1, Ts... >::value >::type * = nullptr>

void TiledArray::detail::inplace_tensor_op	(	InputOp &&	input_op,
		OutputOp &&	output_op,
		const Permutation &	perm,
		TR &	result,
		const T1 &	tensor1,
		const Ts &...	tensors
	)

inline

In-place tensor permutation operations with contiguous data.

In-place tensor of tensors permutation operations with contiguous data.

This function sets the i -th element of result with the result of op(tensor1[i],tensors[i]...) The expected signature of the input operations is:

Result::value_type op(const T1::value_type, const Ts::value_type...)

The expected signature of the output operations is:

void op(TR::value_type*, const TR::value_type)

Template Parameters

InputOp	The input operation type
OutputOp	The output operation type
TR	The result tensor type
T1	The first argument tensor type
Ts	The remaining argument tensor types

Parameters

[in]	input_op	The operation that is used to generate the output value from the input arguments
[in]	output_op	The operation that is used to set the value of the result tensor given the element pointer and the result value
[in]	perm	The permutation applied to the argument tensors
[in,out]	result	The result tensor
[in]	tensor1	The first argument tensor
[in]	tensors	The remaining argument tensors

This function sets the i -th element of result with the result of op(tensor1[i], tensors[i]...) The expected signature of the input operations is:

Result::value_type op(const T1::value_type::value_type, const Ts::value_type::value_type...)

The expected signature of the output operations is:

void op(TR::value_type::value_type*, const TR::value_type::value_type)

Template Parameters

InputOp	The input operation type
OutputOp	The output operation type
TR	The result tensor type
T1	The first argument tensor type
Ts	The remaining argument tensor types

Parameters

[in]	input_op	The operation that is used to generate the output value from the input arguments
[in]	output_op	The operation that is used to set the value of the result tensor given the element pointer and the result value
[in]	perm	The permutation applied to the argument tensors
[in,out]	result	The result tensor
[in]	tensor1	The first argument tensor
[in]	tensors	The remaining argument tensors

Definition at line 225 of file kernels.h.

Here is the call graph for this function:

◆ is_congruent() [1/4]

template<typename Range >

bool TiledArray::detail::is_congruent	(	const Range &	r1,
		const Range &	r2
	)

inline

Test the two ranges are congruent.

This function tests that the rank, lower bound, and upper bound of r1 is equal to that of r2.

Template Parameters

Range The range type

Parameters

r1	The first Range to compare
r2	The second Range to compare

Definition at line 69 of file utility.h.

Here is the caller graph for this function:

◆ is_congruent() [2/4]

template<>

bool TiledArray::detail::is_congruent	(	const BlockRange &	r1,
		const BlockRange &	r2
	)

inline

Test that two BlockRange are congruent.

This function tests that the rank, extent of r1 is equal to that of r2.

Parameters

r1	The first BlockRange to compare
r2	The second BlockRange to compare

Definition at line 79 of file utility.h.

Here is the call graph for this function:

◆ is_congruent() [3/4]

template<typename Range >

bool TiledArray::detail::is_congruent	(	const BlockRange &	r1,
		const Range &	r2
	)

inline

Test that BlockRange and Range are congruent.

This function tests that the rank, extent of r1 is equal to that of r2.

Template Parameters

Range The range type

Parameters

r1	The BlockRange to compare
r2	The Range to compare

Definition at line 92 of file utility.h.

Here is the call graph for this function:

◆ is_congruent() [4/4]

template<typename Range >

bool TiledArray::detail::is_congruent	(	const Range &	r1,
		const BlockRange &	r2
	)

inline

Test that Range and BlockRange are congruent.

This function tests that the rank, extent of r1 is equal to that of r2.

Template Parameters

Range The range type

Parameters

r1	The Range to compare
r2	The BlockRange to compare

Definition at line 105 of file utility.h.

Here is the call graph for this function:

◆ is_range_congruent() [1/3]

template<typename T1 , typename T2 , typename std::enable_if<!(is_shifted< T1 >::value||is_shifted< T2 >::value)>::type * = nullptr>

bool TiledArray::detail::is_range_congruent	(	const T1 &	tensor1,
		const T2 &	tensor2
	)

inline

Test that the ranges of a pair of tensors are congruent.

Test that the ranges of a pair of shifted tensors are congruent.

This function tests that the rank, lower bound, and upper bound of tensor1 is equal to that of tensor2.

Template Parameters

T1	The first tensor type
T2	The second tensor type

Parameters

tensor1	The first tensor to be compared
tensor2	The second tensor to be compared

Returns: true if the rank and extents of the two tensors equal, otherwise false.

This function tests that the extents of the two tensors are equal. One or both of the tensors may be shifted.

Template Parameters

T1	The first tensor type
T2	The second tensor type

Parameters

tensor1	The first tensor to be compared
tensor2	The second tensor to be compared

Returns: true if the rank and extents of the two tensors equal, otherwise false.

Definition at line 122 of file utility.h.

Here is the call graph for this function:

◆ is_range_congruent() [2/3]

template<typename Left , typename Right >

bool TiledArray::detail::is_range_congruent	(	const Left &	left,
		const ShiftWrapper< Right > &	right
	)

inline

Check for congruent range objects with a shifted tensor.

Template Parameters

Left	The left-hand tensor type
Right	The right-hand tensor type

Parameters

left	The left-hand tensor
right	The right-hand tensor

Returns: true if the lower and upper bounds of the left- and right-hand tensor ranges are equal, otherwise false

Definition at line 122 of file shift_wrapper.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_range_congruent() [3/3]

template<typename T1 , typename T2 , typename std::enable_if<!(is_shifted< T1 >::value||is_shifted< T2 >::value)>::type * = nullptr>

bool TiledArray::detail::is_range_congruent	(	const T1 &	tensor1,
		const T2 &	tensor2,
		const Permutation &	perm
	)

inline

Test that the ranges of a pair of permuted tensors are congruent.

This function tests that the rank, lower bound, and upper bound of tensor1 is equal to that of the permuted range of tensor2.

Template Parameters

T1	The first tensor type
T2	The second tensor type

Parameters

tensor1	The first tensor to be compared
tensor2	The second tensor to be compared
perm	The permutation to be applied to `tensor2`

Returns: true if the rank and extents of the two tensors equal, otherwise false.

Definition at line 140 of file utility.h.

Here is the call graph for this function:

◆ is_range_set_congruent() [1/4]

template<typename T >

constexpr bool TiledArray::detail::is_range_set_congruent	(	const Permutation &	perm,
		const T &	tensor
	)

inline

Test that the ranges of a permuted tensor is congruent with itself.

This function is used as the termination step for the recursive is_range_set_congruent() function, and to handle the case of a single tensor.

Template Parameters

T	The tensor type

Parameters

perm	The permutation
tensor	The tensor

Returns: true

Definition at line 179 of file utility.h.

Here is the caller graph for this function:

◆ is_range_set_congruent() [2/4]

template<typename T1 , typename T2 , typename... Ts>

bool TiledArray::detail::is_range_set_congruent	(	const Permutation &	perm,
		const T1 &	tensor1,
		const T2 &	tensor2,
		const Ts &...	tensors
	)

inline

Test that the ranges of a permuted set of tensors are congruent.

Template Parameters

T1	The first tensor type
T2	The second tensor type
Ts	The remaining tensor types

Parameters

perm	The permutation to be applied to `tensor2` and `tensors`...
tensor1	The first tensor to be compared
tensor2	The second tensor to be compared
tensors	The remaining tensor to be compared in recursive steps

Returns: true if all permuted tensors in the list are congruent with the first tensor in the set, otherwise false.

Definition at line 195 of file utility.h.

Here is the call graph for this function:

◆ is_range_set_congruent() [3/4]

template<typename T >

constexpr bool TiledArray::detail::is_range_set_congruent ( const T & tensor )

inline

Test that the ranges of a tensor is congruent with itself.

This function is used as the termination step for the recursive is_range_set_congruent() function, and to handle the case of a single tensor.

Template Parameters

T	The tensor type

Parameters

tensor The tensor

Returns: true

Definition at line 212 of file utility.h.

◆ is_range_set_congruent() [4/4]

template<typename T1 , typename T2 , typename... Ts>

bool TiledArray::detail::is_range_set_congruent	(	const T1 &	tensor1,
		const T2 &	tensor2,
		const Ts &...	tensors
	)

inline

Test that the ranges of a set of tensors are congruent.

Template Parameters

T1	The first tensor type
T2	The second tensor type
Ts	The remaining tensor types

Parameters

tensor1	The first tensor to be compared
tensor2	The second tensor to be compared
tensors	The remaining tensor to be compared in recursive steps

Returns: true if all tensors in the list are congruent with the first tensor in the set, otherwise false.

Definition at line 227 of file utility.h.

Here is the call graph for this function:

◆ make_shape()

template<bool sparse>

auto TiledArray::detail::make_shape	(	World &	world,
		const TiledArray::TiledRange &	trange
	)

◆ make_shape< false >()

template<>

auto TiledArray::detail::make_shape< false >	(	World &	,
		const TiledArray::TiledRange &
	)

inline

Definition at line 133 of file btas.h.

◆ make_shape< true >()

template<>

auto TiledArray::detail::make_shape< true >	(	World &	world,
		const TiledArray::TiledRange &	trange
	)

inline

Definition at line 127 of file btas.h.

Here is the call graph for this function:

◆ make_ta_range() [1/2]

const TiledArray::Range& TiledArray::detail::make_ta_range ( const TiledArray::Range & range )

inline

Definition at line 43 of file btas.h.

Here is the caller graph for this function:

◆ make_ta_range() [2/2]

template<CBLAS_ORDER Order, typename... Args>

TiledArray::Range TiledArray::detail::make_ta_range ( const btas::RangeNd< Order, Args... > & range )

inline

makes TiledArray::Range from a btas::RangeNd

Parameters

[in] range a btas::RangeNd object

Exceptions

TiledArray::Exception if range is non-row-major

Definition at line 52 of file btas.h.

◆ make_tile()

template<typename T >

Tile<T> TiledArray::detail::make_tile ( T && t )

Factory function for tiles.

Template Parameters

T	A tensor type

Parameters

t	A tensor object

Returns: A tile that wraps a copy of t.

Definition at line 279 of file tile.h.

Here is the caller graph for this function:

◆ make_tran_it() [1/2]

template<typename Iter1 , typename Iter2 , typename Op >

BinaryTransformIterator<Iter1, Iter2, Op> TiledArray::detail::make_tran_it	(	Iter1	it1,
		Iter2	it2,
		Op	op
	)

Binary Transform iterator factory.

Template Parameters

Iter1	First iterator type
Iter2	Second iterator type
Op	The binary transform type

Parameters

it1	First iterator
it2	Second iterator
op	The binary transform object

Returns: A binary transform iterator

Definition at line 424 of file transform_iterator.h.

◆ make_tran_it() [2/2]

template<typename Iter , typename Op >

UnaryTransformIterator<Iter, Op> TiledArray::detail::make_tran_it	(	Iter	it,
		Op	op
	)

Unary Transform iterator factory.

Template Parameters

Iter	The iterator type
Op	The binary transform type

Parameters

it	The iterator
op	The binary transform object

Returns: A unary transform iterator

Definition at line 436 of file transform_iterator.h.

◆ norm() [1/2]

template<typename R , typename std::enable_if<! is_complex< R >::value >::type * = nullptr>

TILEDARRAY_FORCE_INLINE R TiledArray::detail::norm ( const R r )

Wrapper function for std::norm

This function disables the call to std::conj for real values to prevent the result from being converted into a complex value.

Template Parameters

R	A real scalar type

Parameters

r	The real scalar

Returns: r

Definition at line 89 of file complex.h.

Here is the caller graph for this function:

◆ norm() [2/2]

template<typename R >

TILEDARRAY_FORCE_INLINE R TiledArray::detail::norm ( const std::complex< R > z )

Compute the norm of a complex number z

${\rm norm}(z) = zz^* = {\rm Re}(z)^2 + {\rm Im}(z)^2$

Template Parameters

R	The scalar type

Parameters

z	The complex scalar

Returns: The complex conjugate of z

Definition at line 102 of file complex.h.

◆ operator &()

template<typename Block >

Bitset<Block> TiledArray::detail::operator&	(	Bitset< Block >	left,
		const Bitset< Block > &	right
	)

Bitwise and operator of bitset.

Template Parameters

Block The bitset block type

Parameters

left	The left-hand bitset
right	The right-hand bitset

Returns: The a intersection of the left and right bitsets

Definition at line 615 of file bitset.h.

◆ operator!=() [1/3]

template<typename Impl >

bool TiledArray::detail::operator!=	(	const TileReference< Impl > &	a,
		const TileReference< Impl > &	b
	)

inequality operator for TileReference objects

Definition at line 129 of file array_impl.h.

◆ operator!=() [2/3]

template<typename T , typename Container >

bool TiledArray::detail::operator!=	(	const RangeIterator< T, Container > &	left_it,
		const RangeIterator< T, Container > &	right_it
	)

Inequality operator.

Compares the iterators for inequality.

Template Parameters

T	The value type of the iterator
Container	The container that the iterator references

Parameters

left_it	The left-hand iterator to be compared
right_it	The right-hand iterator to be compared

Returns: true if the value or container are not equal for the left_it and right_it , otherwise false .

Definition at line 173 of file range_iterator.h.

◆ operator!=() [3/3]

template<typename Impl >

bool TiledArray::detail::operator!=	(	const TileConstReference< Impl > &	a,
		const TileConstReference< Impl > &	b
	)

inequality operator for TileConstReference objects

Definition at line 195 of file array_impl.h.

◆ operator*() [1/7]

template<typename L , typename R >

TILEDARRAY_FORCE_INLINE auto TiledArray::detail::operator*	(	const L	value,
		const ComplexConjugate< R >	op
	)

Definition at line 194 of file complex.h.

Here is the call graph for this function:

◆ operator*() [2/7]

template<typename L >

TILEDARRAY_FORCE_INLINE auto TiledArray::detail::operator*	(	const L	value,
		const ComplexConjugate< void > &
	)

Definition at line 199 of file complex.h.

Here is the call graph for this function:

◆ operator*() [3/7]

template<typename L >

TILEDARRAY_FORCE_INLINE auto TiledArray::detail::operator*	(	const L	value,
		const ComplexConjugate< ComplexNegTag > &
	)

Definition at line 204 of file complex.h.

Here is the call graph for this function:

◆ operator*() [4/7]

template<typename L , typename R >

TILEDARRAY_FORCE_INLINE auto TiledArray::detail::operator*	(	const ComplexConjugate< L >	op,
		const R	value
	)

Definition at line 210 of file complex.h.

Here is the call graph for this function:

◆ operator*() [5/7]

template<typename R >

TILEDARRAY_FORCE_INLINE auto TiledArray::detail::operator*	(	const ComplexConjugate< void >	,
		const R	value
	)

Definition at line 215 of file complex.h.

Here is the call graph for this function:

◆ operator*() [6/7]

template<typename R >

TILEDARRAY_FORCE_INLINE auto TiledArray::detail::operator*	(	const ComplexConjugate< ComplexNegTag >	,
		const R	value
	)

Definition at line 220 of file complex.h.

Here is the call graph for this function:

◆ operator*() [7/7]

template<typename T >

std::vector<T> TiledArray::detail::operator*	(	const Permutation &	perm,
		const SizeArray< T > &	orig
	)

inline

Definition at line 437 of file size_array.h.

Here is the call graph for this function:

◆ operator*=() [1/3]

template<typename L , typename R , typename std::enable_if<! std::is_void< R >::value >::type * = nullptr>

TILEDARRAY_FORCE_INLINE L& TiledArray::detail::operator*=	(	L &	value,
		const ComplexConjugate< R >	op
	)

Definition at line 227 of file complex.h.

Here is the call graph for this function:

◆ operator*=() [2/3]

template<typename L >

TILEDARRAY_FORCE_INLINE L& TiledArray::detail::operator*=	(	L &	value,
		const ComplexConjugate< void > &
	)

Definition at line 234 of file complex.h.

Here is the call graph for this function:

◆ operator*=() [3/3]

template<typename L >

TILEDARRAY_FORCE_INLINE L& TiledArray::detail::operator*=	(	L &	value,
		const ComplexConjugate< ComplexNegTag > &
	)

Definition at line 241 of file complex.h.

Here is the call graph for this function:

◆ operator<<() [1/5]

template<typename Impl >

std::ostream& TiledArray::detail::operator<<	(	std::ostream &	os,
		const TileReference< Impl > &	a
	)

redirect operator to std::ostream for TileReference objects

Definition at line 136 of file array_impl.h.

◆ operator<<() [2/5]

template<typename Impl >

std::ostream& TiledArray::detail::operator<<	(	std::ostream &	os,
		const TileConstReference< Impl > &	a
	)

redirect operator to std::ostream for TileConstReference objects

Definition at line 202 of file array_impl.h.

◆ operator<<() [3/5]

template<typename T >

std::ostream& TiledArray::detail::operator<<	(	std::ostream &	os,
		const SizeArray< T > &	size_array
	)

inline

Definition at line 444 of file size_array.h.

Here is the call graph for this function:

◆ operator<<() [4/5]

template<typename T >

std::ostream& TiledArray::detail::operator<<	(	std::ostream &	os,
		const ValArray< T > &	val_array
	)

inline

Definition at line 456 of file val_array.h.

Here is the call graph for this function:

◆ operator<<() [5/5]

template<typename Block >

std::ostream& TiledArray::detail::operator<<	(	std::ostream &	os,
		const Bitset< Block > &	bitset
	)

Definition at line 646 of file bitset.h.

Here is the call graph for this function:

◆ operator==() [1/3]

template<typename Impl >

bool TiledArray::detail::operator==	(	const TileReference< Impl > &	a,
		const TileReference< Impl > &	b
	)

comparison operator for TileReference objects

Definition at line 122 of file array_impl.h.

Here is the call graph for this function:

◆ operator==() [2/3]

template<typename T , typename Container >

bool TiledArray::detail::operator==	(	const RangeIterator< T, Container > &	left_it,
		const RangeIterator< T, Container > &	right_it
	)

Equality operator.

Compares the iterators for equality. They must reference the same range object to be considered equal.

Template Parameters

T	The value type of the iterator
Container	The container that the iterator references

Parameters

left_it	The left-hand iterator to be compared
right_it	The right-hand iterator to be compared

Returns: true if the value and container are equal for the left_it and right_it , otherwise false .

Definition at line 156 of file range_iterator.h.

◆ operator==() [3/3]

template<typename Impl >

bool TiledArray::detail::operator==	(	const TileConstReference< Impl > &	a,
		const TileConstReference< Impl > &	b
	)

comparison operator for TileConstReference objects

Definition at line 188 of file array_impl.h.

Here is the call graph for this function:

◆ operator^()

template<typename Block >

Bitset<Block> TiledArray::detail::operator^	(	Bitset< Block >	left,
		const Bitset< Block > &	right
	)

Bitwise xor operator of bitset.

Template Parameters

Block The bitset block type

Parameters

left	The left-hand bitset
right	The right-hand bitset

Returns: The union of the left and right bitsets

Definition at line 640 of file bitset.h.

◆ operator|()

template<typename Block >

Bitset<Block> TiledArray::detail::operator\|	(	Bitset< Block >	left,
		const Bitset< Block > &	right
	)

Bitwise or operator of bitset.

Template Parameters

Block The bitset block type

Parameters

left	The left-hand bitset
right	The right-hand bitset

Returns: The union of the left and right bitsets

Definition at line 627 of file bitset.h.

◆ permute()

template<typename InputOp , typename OutputOp , typename Result , typename Arg0 , typename... Args>

void TiledArray::detail::permute	(	InputOp &&	input_op,
		OutputOp &&	output_op,
		Result &	result,
		const Permutation &	perm,
		const Arg0 &	arg0,
		const Args &...	args
	)

inline

Construct a permuted tensor copy.

The expected signature of the input operations is:

Result::value_type input_op(const Arg0::value_type, const Args::value_type...)

The expected signature of the output operations is:

void output_op(Result::value_type*, const Result::value_type)

Template Parameters

InputOp	The input operation type
OutputOp	The output operation type
Result	The result tensor type
Arg0	The first tensor argument type
Args	The remaining tensor argument types

Parameters

input_op	The operation that is used to generate the output value from the input arguments
output_op	The operation that is used to set the value of the result tensor given the element pointer and the result value
args	The data pointers of the tensors to be permuted
perm	The permutation that will be applied to the copy

Definition at line 122 of file permute.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ permute_array()

template<typename Perm , typename Arg , typename Result >

void TiledArray::detail::permute_array	(	const Perm &	perm,
		const Arg &	arg,
		Result &	result
	)

inline

Create a permuted copy of an array.

Template Parameters

Perm	The permutation type
Arg	The input array type
Result	The output array type

Parameters

[in]	perm	The permutation
[in]	arg	The input array to be permuted
[out]	result	The output array that will hold the permuted array

Definition at line 57 of file permutation.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_array() [1/2]

template<typename A >

void TiledArray::detail::print_array	(	std::ostream &	out,
		const A &	a,
		const std::size_t	n
	)

inline

Print the content of an array like object.

Template Parameters

A	The array container type

Parameters

out	A standard output stream
a	The array-like container to be printed
n	The number of elements in the array.

Definition at line 153 of file utility.h.

Here is the caller graph for this function:

◆ print_array() [2/2]

template<typename A >

void TiledArray::detail::print_array	(	std::ostream &	out,
		const A &	a
	)

inline

Print the content of an array like object.

Template Parameters

A	The array container type

Parameters

out	A standard output stream
a	The array-like container to be printed

Definition at line 169 of file utility.h.

Here is the call graph for this function:

◆ size() [1/5]

template<typename T , std::size_t N>

constexpr std::size_t TiledArray::detail::size ( T(&) [N] )

inline

Array size accessor.

Template Parameters

T	The array type
N	The size of the array

Returns: The size of c-stype array

Definition at line 47 of file utility.h.

Here is the caller graph for this function:

◆ size() [2/5]

template<typename T , std::size_t N>

constexpr std::size_t TiledArray::detail::size ( const std::array< T, N > & )

inline

Array size accessor.

Template Parameters

T	The array type
N	The size of the array

Returns: The size of c-stype array

Definition at line 55 of file utility.h.

◆ size() [3/5]

template<typename T , typename std::enable_if<! std::is_array< T >::value >::type * = nullptr>

auto TiledArray::detail::size ( const T & a )

inline

Array size accessor.

Template Parameters

T	The array type

Parameters

a	An array object

Returns: The size of array a

Definition at line 64 of file utility.h.

◆ size() [4/5]

template<typename T >

auto TiledArray::detail::size ( std::initializer_list< T > a )

inline

Array size accessor.

Template Parameters

T	The initializer list element type

Parameters

a	An initializer_list object

Returns: The size of initializer_list a

Definition at line 72 of file utility.h.

◆ size() [5/5]

template<typename ... Ts>

auto TiledArray::detail::size ( const std::tuple< Ts... > & a )

inline

Tuple size accessor.

Template Parameters

Ts	The tuple element types

Parameters

a	A tuple object

Returns: The size of tuple a

Definition at line 80 of file utility.h.

◆ swap()

template<typename B >

void TiledArray::detail::swap	(	Bitset< B > &	b0,
		Bitset< B > &	b1
	)

inline

Definition at line 593 of file bitset.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tensor_init() [1/3]

template<typename Op , typename TR , typename... Ts, typename std::enable_if< is_tensor< TR, Ts... >::value &&is_contiguous_tensor< TR, Ts... >::value >::type * = nullptr>

void TiledArray::detail::tensor_init	(	Op &&	op,
		TR &	result,
		const Ts &...	tensors
	)

inline

Initialize tensor with contiguous tensor arguments.

Initialize tensor of tensors with contiguous tensor arguments.

This function initializes the i -th element of result with the result of op(tensors[i]...)

Precondition: The memory of tensor1 has been allocated but not initialized.

Template Parameters

Op	The element initialization operation type
TR	The result tensor type
Ts	The argument tensor types

Parameters

[in]	op	The result tensor element initialization operation
[out]	result	The result tensor
[in]	tensors	The argument tensors

Definition at line 366 of file kernels.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tensor_init() [2/3]

template<typename Op , typename TR , typename T1 , typename... Ts, typename std::enable_if< is_tensor< TR, T1, Ts... >::value &&is_contiguous_tensor< TR, T1, Ts... >::value >::type * = nullptr>

void TiledArray::detail::tensor_init	(	Op &&	op,
		const Permutation &	perm,
		TR &	result,
		const T1 &	tensor1,
		const Ts &...	tensors
	)

inline

Initialize tensor with permuted tensor arguments.

Initialize tensor of tensors with permuted tensor arguments.

This function initializes the i -th element of result with the result of op(tensor1[i], tensors[i]...)

Precondition: The memory of result has been allocated but not initialized.

Template Parameters

Op	The element initialization operation type
TR	The result tensor type
T1	The first argument tensor type
Ts	The argument tensor types

Parameters

[in]	op	The result tensor element initialization operation
[in]	perm	The permutation that will be applied to tensor2
[out]	result	The result tensor
[in]	tensor1	The first argument tensor
[in]	tensors	The argument tensors

Definition at line 423 of file kernels.h.

Here is the call graph for this function:

◆ tensor_init() [3/3]

template<typename Op , typename TR , typename T1 , typename... Ts, typename std::enable_if< is_tensor< TR, T1, Ts... >::value &&is_contiguous_tensor< TR >::value &&! is_contiguous_tensor< T1, Ts... >::value >::type * = nullptr>

void TiledArray::detail::tensor_init	(	Op &&	op,
		TR &	result,
		const T1 &	tensor1,
		const Ts &...	tensors
	)

inline

Initialize tensor with one or more non-contiguous tensor arguments.

This function initializes the i -th element of result with the result of op(tensor1[i], tensors[i]...)

Precondition: The memory of tensor1 has been allocated but not initialized.

Template Parameters

Op	The element initialization operation type
T1	The result tensor type
Ts	The argument tensor types

Parameters

[in]	op	The result tensor element initialization operation
[out]	result	The result tensor
[in]	tensor1	The first argument tensor
[in]	tensors	The argument tensors

This function initializes the i -th element of result with the result of op(tensor1[i],tensors[i]...)

Precondition: The memory of tensor1 has been allocated but not initialized.

Template Parameters

Op	The element initialization operation type
T1	The result tensor type
Ts	The argument tensor types

Parameters

[in]	op	The result tensor element initialization operation
[out]	result	The result tensor
[in]	tensor1	The first argument tensor
[in]	tensors	The argument tensors

Definition at line 492 of file kernels.h.

Here is the call graph for this function:

◆ tensor_op() [1/2]

template<typename TR , typename Op , typename T1 , typename... Ts, typename std::enable_if< is_tensor< TR, T1, Ts... >::value||is_tensor_of_tensor< TR, T1, Ts... >::value >::type * = nullptr>

TR TiledArray::detail::tensor_op	(	Op &&	op,
		const T1 &	tensor1,
		const Ts &...	tensors
	)

inline

Tensor operations with contiguous data.

This function sets the elements of the result tensor with op(tensor1[i], tensors[i]...)

Template Parameters

TR	The tensor result type
Op	The element-wise operation type
T1	The first argument tensor type
Ts	The remaining argument tensor types

Parameters

op	The result tensor element initialization operation
tensor1	The first argument tensor
tensors	The remaining argument tensors

Definition at line 60 of file kernels.h.

◆ tensor_op() [2/2]

template<typename TR , typename Op , typename T1 , typename... Ts, typename std::enable_if<(is_tensor< T1, Ts... >::value||is_tensor_of_tensor< TR, T1, Ts... >::value) &&is_contiguous_tensor< T1, Ts... >::value >::type * = nullptr>

TR TiledArray::detail::tensor_op	(	Op &&	op,
		const Permutation &	perm,
		const T1 &	tensor1,
		const Ts &...	tensors
	)

inline

Tensor permutation operations with contiguous data.

This function sets the elements of the result tensor with op(tensor1[i],tensors[i]...)

Template Parameters

TR	The tensor result type
Op	The element-wise operation type
T1	The result tensor type
Ts	The argument tensor types

Parameters

[in]	op	The operation that is used to compute the result value from the input arguments
[in]	perm	The permutation applied to the argument tensors
[in]	tensor1	The first argument tensor
[in]	tensors	The remaining argument tensors

Definition at line 82 of file kernels.h.

◆ tensor_reduce()

template<typename ReduceOp , typename JoinOp , typename Scalar , typename T1 , typename... Ts, typename std::enable_if_t< is_tensor< T1, Ts... >::value &&is_contiguous_tensor< T1, Ts... >::value > * = nullptr>

Scalar TiledArray::detail::tensor_reduce	(	ReduceOp &&	reduce_op,
		JoinOp &&	join_op,
		Scalar	identity,
		const T1 &	tensor1,
		const Ts &...	tensors
	)

Reduction operation for contiguous tensors.

Reduction operation for non-contiguous tensors of tensors.

Reduction operation for non-contiguous tensors.

Reduction operation for contiguous tensors of tensors.

Perform an element-wise reduction of the tensors by executing join_op(result, reduce_op(result, &tensor1[i], &tensors[i]...)) for each i in the index range of tensor1 . result is initialized to identity . If HAVE_INTEL_TBB is defined, the reduction will be executed in an undefined order, otherwise will execute in the order of increasing i .

Template Parameters

ReduceOp	The element-wise reduction operation type
JoinOp	The result operation type
Scalar	A scalar type
T1	The first argument tensor type
Ts	The argument tensor types

Parameters

reduce_op	The element-wise reduction operation
identity	The initial value for the reduction and the result
tensor1	The first tensor to be reduced
tensors	The other tensors to be reduced

Returns: The reduced value of the tensor(s)

Perform an element-wise reduction of the tensors by executing join_op(result, reduce_op(tensor1[i], tensors[i]...)) for each i in the index range of tensor1 . result is initialized to identity . This will execute serially, in the order of increasing i (each element-wise reduction can however be executed in parallel, depending on the element type).

Template Parameters

ReduceOp	The element-wise reduction operation type
JoinOp	The result operation type
Scalar	A scalar type
T1	The first argument tensor type
Ts	The argument tensor types

Parameters

reduce_op	The element-wise reduction operation
join_op	The result join operation
identity	The initial value for the reduction and the result
tensor1	The first tensor to be reduced
tensors	The other tensors to be reduced

Returns: The reduced value of the tensor(s)

Definition at line 579 of file kernels.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_tiles_to_array()

template<typename Array , typename T >

void TiledArray::detail::write_tiles_to_array	(	Array &	A,
		T	val
	)

Definition at line 90 of file diagonal_array.h.

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Typedefs

Functions

Typedef Documentation

◆ add_t

◆ const_if_t

◆ mult_t

◆ numeric_t

◆ param_type

◆ pmap_t

◆ policy_t

◆ scalar_t

◆ shape_t

◆ subt_t

◆ trange_t

◆ void_t

Function Documentation

◆ abs() [1/2]

◆ abs() [2/2]

◆ clone_range() [1/2]

◆ clone_range() [2/2]

◆ conj() [1/2]

◆ conj() [2/2]

◆ conj_op() [1/2]

◆ conj_op() [2/2]

◆ counted_btas_subtensor_to_tensor()

◆ counted_eigen_submatrix_to_tensor()

◆ counted_tensor_to_btas_subtensor()

◆ counted_tensor_to_eigen_submatrix()

◆ data() [1/7]

◆ data() [2/7]

◆ data() [3/7]

◆ data() [4/7]

◆ data() [5/7]

◆ data() [6/7]

◆ data() [7/7]

◆ diagonal_range()

◆ diagonal_shape()

◆ dummy_annotation()

◆ empty() [1/2]

◆ empty() [2/2]

◆ foreach() [1/2]

◆ foreach() [2/2]

◆ fuse_dimensions()

◆ inner_product()

◆ inner_size() [1/2]

◆ inner_size() [2/2]

◆ inner_size_helper() [1/2]

◆ inner_size_helper() [2/2]

◆ inplace_tensor_op() [1/2]

◆ inplace_tensor_op() [2/2]

◆ is_congruent() [1/4]

◆ is_congruent() [2/4]

◆ is_congruent() [3/4]

◆ is_congruent() [4/4]

◆ is_range_congruent() [1/3]

◆ is_range_congruent() [2/3]

◆ is_range_congruent() [3/3]

◆ is_range_set_congruent() [1/4]

◆ is_range_set_congruent() [2/4]

◆ is_range_set_congruent() [3/4]

◆ is_range_set_congruent() [4/4]

◆ make_shape()

◆ make_shape< false >()

◆ make_shape< true >()

◆ make_ta_range() [1/2]

◆ make_ta_range() [2/2]

◆ make_tile()

◆ make_tran_it() [1/2]

◆ make_tran_it() [2/2]

◆ norm() [1/2]

◆ norm() [2/2]

◆ operator &()

◆ operator!=() [1/3]

◆ operator!=() [2/3]

◆ operator!=() [3/3]

◆ operator*() [1/7]

◆ operator*() [2/7]

◆ operator*() [3/7]

◆ operator*() [4/7]