| ▼Nboost | |
| Crange_const_iterator< Eigen::Matrix< _Scalar, _Rows, 1, _Options, _MaxRows, 1 > > | |
| Crange_mutable_iterator< Eigen::Matrix< _Scalar, _Rows, 1, _Options, _MaxRows, 1 > > | |
| ▼Nbtas | |
| Crange_traits< TiledArray::Range > | |
| ▼NEigen | Forward declarations |
| Caligned_allocator | |
| ▼Nmadness | |
| ►Narchive | |
| Carchive_array | |
| CArchiveLoadImpl | |
| CArchiveLoadImpl< Archive, Eigen::Matrix< Scalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime > > | |
| CArchiveLoadImpl< Archive, TiledArray::cpu_cuda_vector< T > > | |
| CArchiveLoadImpl< ParallelInputArchive, TiledArray::DistArray< Tile, Policy > > | |
| CArchiveStoreImpl | |
| CArchiveStoreImpl< Archive, Eigen::Matrix< Scalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime > > | |
| CArchiveStoreImpl< Archive, TiledArray::cpu_cuda_vector< T > > | |
| CArchiveStoreImpl< ParallelOutputArchive, TiledArray::DistArray< Tile, Policy > > | |
| Cis_input_archive | |
| Cis_output_archive | |
| ►Ndetail | |
| Ctask_arg< TiledArray::detail::TileConstReference< Impl > > | |
| Ctask_arg< TiledArray::detail::TileReference< Impl > > | |
| CFuture | |
| ▼Nstd | STL namespace |
| Cmake_void | |
| ▼NTiledArray | |
| ►Ncontainer | |
| ►Ndetail | |
| Cabsolute_value | |
| CAdd | Tile addition operation |
| CArgumentHelper | |
| CArgumentHelper< Future< T > > | |
| CArgumentHelper< std::pair< Future< T >, Future< U > > > | |
| CArrayEvalImpl | Distributed evaluator for TiledArray::Array objects |
| CArrayImpl | Tensor implementation and base for other tensor implementation objects |
| CArrayIterator | Distributed tensor iterator |
| CBacktrace | |
| CBinaryEvalImpl | Binary, distributed tensor evaluator |
| CBinaryTransformIterator | Binary transform iterator |
| CBinaryWrapper | Binary tile operation wrapper |
| ►CBitset | Fixed size bitset |
| Creference | |
| CBlockedPmap | A blocked process map |
| CCanMakeRandom | |
| CCanMakeRandom< double > | Enables generating random double values |
| CCanMakeRandom< float > | Enables generating random float values |
| CCanMakeRandom< int > | Enables generating random int values |
| CCanMakeRandom< std::complex< double > > | Enables generating random std::complex<double> values |
| CCanMakeRandom< std::complex< float > > | Enables generating random std::complex<float> values |
| Ccast_then_op | |
| Ccast_then_op< DstTile, SrcTile, Op, std::enable_if_t<!std::is_same< DstTile, SrcTile >::value > > | |
| Ccast_then_op< Tile, Tile, Op, void > | |
| CComplexConjugate | |
| CComplexConjugate< ComplexNegTag > | |
| CComplexConjugate< void > | Specialization of ComplexConjugate for the case of a unit/identity factor |
| CComplexNegTag | |
| CContractReduce | Contract and (sum) reduce operation |
| CContractReduce< Result, Left, Right, TiledArray::detail::ComplexConjugate< Scalar > > | Contract and reduce operation |
| CContractReduce< Result, Left, Right, TiledArray::detail::ComplexConjugate< void > > | Contract and (sum) reduce operation |
| CContractReduceBase | Contract and (sum) reduce base |
| CCyclicPmap | Maps cyclically a sequence of indices onto a 2-d matrix of processes |
| Cdefault_permutation | Detect cuda tile |
| Cdefault_permutation< Tensor, std::enable_if_t< is_tensor_of_tensor_v< Tensor > > > | |
| Cdefault_permutation< Tensor, std::enable_if_t<!is_tensor_of_tensor_v< Tensor > > > | |
| Cdefault_world | |
| Cdist_subarray_vec | Global view of a tilewise-round-robin distributed std::vector of Arrays |
| CDistEval | Tensor expression object |
| CDistEvalImpl | Distributed evaluator implementation object |
| CDistributedStorage | Distributed storage container |
| Ceval_trait_base | |
| Ceval_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 > | |
| Chas_conversion_operator | |
| Chas_conversion_operator< From, To, typename std::enable_if< is_type< decltype(std::declval< From >().operator To &())>::value >::type > | |
| Chas_conversion_operator< From, To, typename std::enable_if< is_type< decltype(std::declval< From >().operator To())>::value >::type > | |
| CHashPmap | Hashed process map |
| Cis_array | |
| Cis_array< DistArray< T, P > > | |
| Cis_array_tile | Detect tiles used by ArrayEvalImpl |
| Cis_array_tile< TiledArray::detail::LazyArrayTile< T, Op > > | |
| Cis_bidirectional_iterator | |
| Cis_boost_gettable | |
| Cis_boost_gettable< I, T, std::void_t< decltype(::boost::get< I >(std::declval< const T & >()))> > | |
| Cis_btas_tensor | |
| Cis_btas_tensor< btas::Tensor< T, Args... > > | |
| Cis_complete_type | Helper to implement other metafunctions is_complete_type<T>::value is true if T is a complete type |
| Cis_complete_type< T, decltype(void(sizeof(T)))> | |
| Cis_complete_type< void > | |
| Cis_complex | |
| Cis_complex< std::complex< T > > | |
| Cis_contiguous_range | |
| Cis_contiguous_range< T, std::void_t< decltype(std::data(std::declval< T & >()))> > | |
| Cis_contiguous_range_helper | |
| Cis_contiguous_range_helper< Range > | |
| Cis_contiguous_tensor | |
| Cis_contiguous_tensor< T > | |
| Cis_contiguous_tensor< T1, T2, Ts... > | |
| Cis_contiguous_tensor<> | |
| Cis_contiguous_tensor_helper | |
| Cis_contiguous_tensor_helper< btas::Tensor< T, Args... > > | |
| Cis_contiguous_tensor_helper< ShiftWrapper< T > > | |
| Cis_contiguous_tensor_helper< Tensor< T, A > > | |
| Cis_contiguous_tensor_helper< TensorInterface< T, R, OpResult > > | |
| Cis_contiguous_tensor_helper< Tile< T > > | |
| Cis_convertible | |
| Cis_explicitly_convertible | |
| Cis_forward_iterator | |
| Cis_gettable_pair | |
| Cis_gettable_pair< T, std::enable_if_t< is_gettable_v< 0, T > &&is_gettable_v< 1, T > > > | |
| Cis_gpair_range | |
| Cis_gpair_range< T, std::enable_if_t< is_gpair_v< value_t< T > > &&is_range_v< T > > > | |
| Cis_implicitly_convertible | |
| Cis_initializer_list | Primary template for detecting if T is an std::initializer_list |
| Cis_initializer_list< std::initializer_list< T > > | Specialization of is_initializer_list for an std::initializer_list |
| Cis_input_iterator | |
| Cis_integral_list | |
| Cis_integral_list_helper | |
| Cis_integral_list_helper< T, Ts... > | |
| Cis_integral_list_helper<> | |
| Cis_integral_pair | |
| Cis_integral_pair_ | |
| Cis_integral_pair_< std::pair< T1, T2 >, typename std::enable_if< std::is_integral< T1 >::value &&std::is_integral< T2 >::value >::type > | |
| Cis_integral_pair_list | |
| Cis_integral_pair_list_helper | |
| Cis_integral_pair_list_helper< T, Ts... > | |
| Cis_integral_pair_list_helper<> | |
| Cis_integral_range | |
| Cis_integral_range< T, std::enable_if_t< std::is_integral_v< value_t< T > > &&is_range_v< T > > > | |
| Cis_integral_sized_range | |
| Cis_integral_sized_range< T, std::enable_if_t< std::is_integral_v< value_t< T > > &&is_sized_range_v< T > > > | |
| Cis_integral_tuple | |
| Cis_integral_tuple< std::tuple< Ts... > > | |
| Cis_invocable | |
| Cis_invocable_r | |
| Cis_invocable_void | |
| Cis_invocable_void_helper | |
| Cis_invocable_void_helper< std::enable_if_t< std::is_void< std::result_of_t< F(Args...)> >::value, void >, F, Args... > | |
| Cis_iterator | |
| Cis_iterator< const T *, void > | |
| Cis_iterator< const T *const, void > | |
| Cis_iterator< T *, void > | |
| Cis_iterator< T *const, void > | |
| Cis_iterator< T, typename std::enable_if< has_member_type_iterator_category< T >::value >::type > | |
| Cis_non_array_lazy_tile | Detect a lazy evaluation tile that are not a LazyArrayTile |
| Cis_numeric | |
| Cis_numeric< bool > | |
| Cis_numeric< ComplexConjugate< S > > | |
| Cis_numeric< std::complex< T > > | |
| Cis_output_iterator | |
| Cis_pair | |
| Cis_pair< std::pair< T1, T2 > > | |
| Cis_permutation | |
| Cis_permutation< TiledArray::BipartitePermutation > | |
| Cis_permutation< TiledArray::Permutation > | |
| Cis_permutation< TiledArray::symmetry::Permutation > | |
| Cis_random_iterator | |
| Cis_range | |
| Cis_range< T, std::void_t< decltype(std::begin(std::declval< T & >()), std::end(std::declval< T & >()))> > | |
| Cis_reduce_op_ | |
| Cis_reduce_op_< std::void_t< decltype(std::declval< ReduceOp & >()(std::declval< Result & >(), std::declval< const Args * >()...))>, ReduceOp, Result, Args... > | |
| Cis_same_or_derived | |
| Cis_scalar | |
| Cis_scalar< std::complex< T > > | |
| Cis_shifted | |
| Cis_shifted< T > | |
| Cis_shifted< T1, T2, Ts... > | |
| Cis_shifted<> | |
| Cis_shifted_helper | |
| Cis_shifted_helper< ShiftWrapper< T > > | |
| Cis_sized_range | |
| Cis_sized_range< T, std::void_t< decltype(std::size(std::declval< T & >()))> > | |
| Cis_std_gettable | |
| Cis_std_gettable< I, T, std::void_t< decltype(::std::get< I >(std::declval< const T & >()))> > | |
| Cis_strictly_ordered | |
| Cis_strictly_ordered_helper | |
| Cis_ta_tensor | |
| Cis_ta_tensor< Tensor< T, A > > | |
| Cis_tensor | |
| Cis_tensor< T > | |
| Cis_tensor< T1, T2, Ts... > | |
| Cis_tensor<> | |
| Cis_tensor_helper | |
| Cis_tensor_helper< btas::Tensor< T, Args... > > | |
| Cis_tensor_helper< ShiftWrapper< const T > > | |
| Cis_tensor_helper< ShiftWrapper< T > > | |
| Cis_tensor_helper< Tensor< T, A > > | |
| Cis_tensor_helper< TensorInterface< Args... > > | |
| Cis_tensor_helper< Tile< T > > | |
| Cis_tensor_of_tensor | |
| Cis_tensor_of_tensor< T > | |
| Cis_tensor_of_tensor< T1, T2, Ts... > | |
| Cis_tensor_of_tensor<> | |
| Cis_tensor_of_tensor_helper | |
| Cis_tensor_of_tensor_helper< ShiftWrapper< T > > | |
| Cis_tensor_of_tensor_helper< Tensor< T, A > > | |
| Cis_tensor_of_tensor_helper< TensorInterface< T, Args... > > | |
| Cis_tensor_of_tensor_helper< Tile< T > > | |
| Cis_tuple | |
| Cis_tuple< std::tuple< Ts... > > | |
| Cis_type | Helper to implement other metafunctions is_type<T>::value is true if T is a valid type |
| CLazyArrayTile | Lazy tile for on-the-fly evaluation of array tiles |
| CMakeRandom | |
| CMakeRandom< std::complex< ScalarType > > | |
| ►CMemoryWatchpoint_x86_64 | MemoryWatchpoint represents a hardware watchpoint for a memory location Implements a memory watchpoint on x86 ... only implemented for macOS so far this is a slightly tweaked version of https://m.habrahabr.ru/post/103073/ see also http://www.sandpile.org/x86/drx.htm for the x86 debugging register map |
| CPool | Singleton pool of MemoryWatchpoint objects |
| CMult | Tile multiplication operation |
| Cnon_iterator_tag | |
| CNoop | Tile no operation (noop) |
| Cnumeric_type | Type trait for extracting the numeric type of tensors and arrays |
| Cnumeric_type< T, typename std::enable_if< has_member_type_value_type< T >::value &&(!is_lazy_tile< T >::value) &&(!is_numeric_v< T >)>::type > | |
| Cnumeric_type< T, typename std::enable_if< is_lazy_tile< T >::value &&!is_numeric_v< T > >::type > | |
| Cnumeric_type< T, typename std::enable_if< is_numeric_v< T > >::type > | |
| Cordinal_traits | Ordinal trait specifies properties of the ordinal |
| Cordinal_traits< btas::RangeNd< _Order, _Index, _Ordinal > > | Btas::RangeNd can be col or row-major |
| Cordinal_traits< Range > | TA::Range is hardwired to row-major |
| Cordinal_traits< T, std::enable_if_t< is_contiguous_tensor_v< T > > > | Ordinal traits of contiguous tensors are defined by their range type |
| Cparam | |
| Cparam< T, typename std::enable_if< is_numeric_v< T > >::type > | |
| Cparam< T, typename std::enable_if< std::is_pointer< T >::value >::type > | |
| Cparam< T, typename std::enable_if< std::is_reference< T >::value >::type > | |
| CPermIndex | A functor that permutes ordinal indices |
| CProcGrid | A 2D processor grid |
| CRangeIterator | Coordinate index iterate |
| CReducePairOpWrapper | Wrapper that to convert a pair-wise reduction into a standard reduction |
| CReducePairTask | Reduce pair task |
| CReduceTask | Reduce task |
| Cremove_cvr | Remove const, volatile, and reference qualifiers |
| CReplicatedPmap | A Replicated process map |
| CReplicator | Replicate a Array object |
| CRoundRobinPmap | A blocked process map |
| CScal | Tile scaling operation |
| CScalAdd | Tile scale-addition operation |
| Cscalar_type | Type trait for extracting the scalar type of tensors and arrays |
| Cscalar_type< std::complex< T >, void > | |
| Cscalar_type< T, typename std::enable_if< is_scalar_v< T > >::type > | |
| Cscalar_type< T, typename std::enable_if<!is_numeric_v< T > >::type > | |
| CScalMult | Tile scale-multiplication operation |
| CScalShift | Tile shift operation |
| CScalSubt | Tile scale-subtraction operation |
| CShift | Tile shift operation |
| CShiftWrapper | Shift wrapper class |
| CSizeArray | Array wrapper |
| CSubt | Tile subtraction operation |
| CSumma | Distributed contraction evaluator implementation |
| CTensorConstReference | |
| CTensorImpl | Tensor implementation and base for other tensor implementation objects |
| CTensorInterface | Tensor interface for external data |
| CTensorReference | |
| CTileConstReference | Tensor tile reference |
| CTileReference | Tensor tile reference |
| CTrace | |
| CTrace< Tensor< T, A >, detail::enable_if_numeric_t< T > > | |
| CTraceIsDefined | |
| CTraceIsDefined< btas::Tensor< T, Range, Storage >, enable_if_numeric_t< T > > | |
| CTraceIsDefined< Tensor< T, A >, enable_if_numeric_t< T > > | Signals that we can take the trace of a Tensor<T, A> (for numeric T) |
| CTraceIsDefined< Tile< Arg >, enable_if_trace_is_defined_t< Arg > > | Signals that we can take the trace of a Tile<Arg> if can trace Arg |
| Ctransform | |
| Ctransform< Tensor< T, A > > | Specialization of TiledArray::detail::transform for Tensor |
| Ctype_printer | |
| CUnaryEvalImpl | Tensor that is composed from an argument tensor |
| CUnaryTransformIterator | Unary transform iterator |
| CUnaryWrapper | Unary tile operation wrapper |
| CValArray | Value array |
| ►Neigen | |
| ►Nexpressions | |
| ►Nkernels | |
| CKernelSelector | |
| CKernelSelector< false, true, true > | |
| CKernelSelector< true, false, true > | |
| CKernelSelector< true, true, true > | |
| CAddEngine | Addition expression engine |
| CAddExpr | Addition expression |
| CBinaryEngine | |
| CBinaryExpr | Binary expression object |
| CBinaryOpPermutationOptimizer | Abstract optimizer of permutations for a binary operation |
| CBipartiteIndexList | |
| CBlkTsrEngine | Tensor expression engine |
| CBlkTsrEngineBase | Tensor expression engine |
| CBlkTsrExpr | Block expression |
| CBlkTsrExpr< const Array, true > | Block expression |
| CBlkTsrExprBase | Block expression |
| CContEngine | Multiplication expression engine |
| CEngineParamOverride | |
| CEngineTrait | |
| CEngineTrait< AddEngine< Left, Right, Result > > | |
| CEngineTrait< BlkTsrEngine< DistArray< Tile, Policy >, Result, Alias > > | |
| CEngineTrait< MultEngine< Left, Right, Result > > | |
| CEngineTrait< ScalAddEngine< Left, Right, Scalar, Result > > | |
| CEngineTrait< ScalBlkTsrEngine< DistArray< Tile, Policy >, Scalar, Result > > | |
| CEngineTrait< ScalEngine< Arg, Scalar, Result > > | |
| CEngineTrait< ScalMultEngine< Left, Right, Scalar, Result > > | |
| CEngineTrait< ScalSubtEngine< Left, Right, Scalar, Result > > | |
| CEngineTrait< ScalTsrEngine< DistArray< Tile, Policy >, Scalar, Result > > | |
| CEngineTrait< SubtEngine< Left, Right, Result > > | |
| CEngineTrait< TsrEngine< DistArray< Tile, Policy >, Result, Alias > > | |
| CExpr | Base class for expression evaluation |
| CExprEngine | Expression engine |
| CExprOStream | Expression output stream |
| CExprTraceTarget | Expression trace target |
| CExprTrait | |
| CExprTrait< AddExpr< Left, Right > > | |
| CExprTrait< BlkTsrExpr< Array, Alias > > | |
| CExprTrait< BlkTsrExpr< const Array, Alias > > | |
| CExprTrait< MultExpr< Left, Right > > | |
| CExprTrait< ScalAddExpr< Left, Right, Scalar > > | |
| CExprTrait< ScalBlkTsrExpr< Array, Scalar > > | |
| CExprTrait< ScalBlkTsrExpr< const Array, Scalar > > | |
| CExprTrait< ScalExpr< Arg, Scalar > > | |
| CExprTrait< ScalMultExpr< Left, Right, Scalar > > | |
| CExprTrait< ScalSubtExpr< Left, Right, Scalar > > | |
| CExprTrait< ScalTsrExpr< Array, Scalar > > | |
| CExprTrait< SubtExpr< Left, Right > > | |
| CExprTrait< TsrExpr< Array, Alias > > | |
| CExprTrait< TsrExpr< const Array, true > > | |
| CGEMMPermutationOptimizer | |
| CHadamardPermutationOptimizer | |
| Chas_array | Type trait checks if T has array() member Useful to determine if an Expr is a TsrExpr or a related type |
| CIndexList | |
| Cis_aliased | |
| Cis_aliased< BlkTsrExpr< Array, Alias > > | |
| Cis_aliased< TsrExpr< Array, Alias > > | |
| CLeafEngine | Leaf expression engine |
| CMultEngine | Multiplication expression engine |
| CMultExpr | Multiplication expression |
| CNullBinaryOpPermutationOptimizer | |
| CScalAddEngine | Addition expression engine |
| CScalAddExpr | Add-then-scale expression |
| CScalBlkTsrEngine | Scaled tensor block expression engine |
| CScalBlkTsrExpr | Block expression |
| CScalEngine | Scaling expression engine |
| CScalExpr | Scaling expression |
| CScalMultEngine | Scaled multiplication expression engine |
| CScalMultExpr | Multiplication expression |
| CScalSubtEngine | Subtraction expression engine |
| CScalSubtExpr | Subtraction expression |
| CScalTsrEngine | Scaled tensor expression engine |
| CScalTsrExpr | Expression wrapper for scaled array objects |
| CSubtEngine | Subtraction expression engine |
| CSubtExpr | Subtraction expression |
| CTsrEngine | Tensor expression engine |
| CTsrExpr | Expression wrapper for array objects |
| CTsrExpr< const Array, true > | Expression wrapper for const array objects |
| CUnaryEngine | |
| CUnaryExpr | |
| ►Nmath | |
| ►Nlinalg | |
| ►Ndetail | |
| Carray_traits | |
| ►Nscalapack | |
| CBlockCyclicMatrix | |
| CConjugateGradientSolver | |
| CDIIS | DIIS (`‘direct inversion of iterative subspace’') extrapolation |
| CSVD | |
| CBinaryReduceWrapper | Binary reduction wrapper class that handles lazy tile evaluation |
| CBinaryReduceWrapper< typename Op::first_argument_type, typename Op::second_argument_type, Op > | Binary reduction operation wrapper |
| CBlock | |
| CGemmHelper | Contraction to *GEMM helper |
| CGemmTask | |
| CMatrixBlockTask | |
| COuterVectorOpUnwind | Outer algorithm automatic loop unwinding |
| COuterVectorOpUnwind< 0 > | |
| CPartialReduceUnwind | Partial reduce algorithm automatic loop unwinding |
| CPartialReduceUnwind< 0 > | |
| CTransposeUnwind | Partial transpose algorithm automatic loop unwinding |
| CTransposeUnwind< 0 > | |
| CUnaryReduceWrapper | Unary reduction wrapper class that handles lazy tile evaluation |
| CUnaryReduceWrapper< typename Op::argument_type, Op > | Unary reduction wrapper class that handles lazy tile evaluation |
| CVectorOpUnwind | Vector loop unwind helper class |
| CVectorOpUnwind< 0ul > | Vector loop unwind helper class |
| ►Nmeta | |
| Cor_reduce | ||'s bools |
| Cor_reduce< b > | |
| ►Nsymmetry | |
| CPermutation | Permutation of a sequence of objects indexed by base-0 indices |
| CPermutationGroup | Permutation group |
| CRepresentation | |
| CSymmetricGroup | Symmetric group |
| ►Ntile_interface | |
| CAdd | |
| CAdd< Result, Left, Right, typename std::enable_if<!(std::is_same< Result, result_of_add_t< Left, Right >>::value &&std::is_same< Result, result_of_add_t< Left, Right, BipartitePermutation >>::value)>::type > | |
| CAddTo | |
| CAddTo< Result, Left, Right, typename std::enable_if<!std::is_same< Result, result_of_add_to_t< Left, Right > >::value >::type > | |
| CCast | |
| CCast< Result, Arg, std::enable_if_t< detail::has_conversion_operator_v< Arg, madness::Future< Result > >||detail::is_convertible_v< Arg, Result > > > | Internal cast (aka conversion) implementation |
| CCast< Result, Arg, typename std::enable_if< is_lazy_tile< Arg >::value &&!std::is_same< Result, typename TiledArray::eval_trait< Arg >::type >::value >::type > | Internal cast implementation |
| CClone | |
| CClone< Result, Arg, typename std::enable_if<!std::is_same< Result, typename clone_trait< Arg >::type >::value >::type > | |
| Cclone_trait | Internal clone trait |
| Cclone_trait< Arg, typename std::enable_if< TiledArray::detail::is_type< result_of_clone_t< Arg > >::value >::type > | Internal clone trait |
| CPermute | |
| CPermute< Result, Arg, typename std::enable_if< !std::is_same< Result, result_of_permute_t< Arg > >::value >::type > | |
| Cpermute_trait | |
| Cpermute_trait< Arg, typename std::enable_if< TiledArray::detail::is_type< result_of_permute_t< Arg > >::value >::type > | |
| CScalAdd | |
| CScalAdd< Result, Left, Right, Scalar, typename std::enable_if<!(std::is_same< Result, result_of_add_t< Left, Right, Scalar >>::value &&std::is_same< Result, result_of_add_t< Left, Right, Scalar, BipartitePermutation >>::value)>::type > | |
| CScalAddTo | |
| CScalAddTo< Result, Left, Right, Scalar, typename std::enable_if<!std::is_same< Result, result_of_add_to_t< Left, Right, Scalar > >::value >::type > | |
| CScale | |
| CScale< Result, Arg, Scalar, typename std::enable_if<!std::is_same< Result, result_of_scale_t< Arg, Scalar > >::value >::type > | |
| Cscale_trait | |
| Cscale_trait< Arg, Scalar, typename std::enable_if< TiledArray::detail::is_type< result_of_scale_t< Arg, Scalar > >::value >::type > | |
| CScaleTo | |
| CScaleTo< Result, Arg, Scalar, typename std::enable_if<!std::is_same< Result, result_of_scale_t< Arg, Scalar > >::value >::type > | |
| CShift | |
| CShift< Result, Arg, typename std::enable_if< !std::is_same< Result, result_of_shift_t< Arg > >::value >::type > | |
| Cshift_trait | |
| Cshift_trait< Arg, typename std::enable_if< TiledArray::detail::is_type< result_of_shift_t< Arg > >::value >::type > | |
| CShiftTo | |
| CShiftTo< Result, Arg, typename std::enable_if<!std::is_same< Result, result_of_shift_to_t< Arg > >::value >::type > | |
| CAbsMaxReduction | Maxabs tile reduction |
| CAbsMinReduction | Minabs tile reduction |
| CAdd | Add tile operation |
| CAddTo | Add-to tile operation |
| CBipartitePermutation | Permutation of a bipartite set |
| CBlockRange | Range that references a subblock of another range |
| CCast | Tile cast operation |
| CCast< TiledArray::Tensor< T, Allocator >, btas::Tensor< T, Range_, Storage > > | Converts a btas::Tensor to a TiledArray::Tensor |
| CCast< TiledArray::Tensor< typename T::value_type, Allocator >, Tile< T >, std::void_t< decltype(std::declval< TiledArray::Cast< TiledArray::Tensor< typename T::value_type, Allocator >, T >>()(std::declval< const T & >()))> > | |
| CClone | Create a deep copy of a tile |
| Cclone_trait | Clone trait |
| Ccpu_cuda_vector | Vector that lives on either host or device side, or both |
| CDebugger | |
| CDensePolicy | |
| CDenseShape | Dense shape of an array |
| CDistArray | Forward declarations |
| CDotReduction | Vector dot product tile reduction |
| Ceval_trait | Determine the object type used in the evaluation of tensor expressions |
| CException | |
| Cfunction_ref | |
| Cfunction_ref< R(Args...)> | Specialization for function types |
| CInitializerListRank | Primary template for determining how many nested std::initializer_list's are in a type |
| CInitializerListRank< std::initializer_list< T >, SizeType > | Specialization of InitializerListRank used when the template type parameter is a std::initializer_list type |
| CInnerProductReduction | Vector inner product tile reduction |
| CIrrep | Irrep of an  symmetric group |
| Cis_consumable_tile | Consumable tile type trait |
| Cis_consumable_tile< ZeroTensor > | |
| Cis_dense | Type trait to detect dense shape types |
| Cis_dense< DensePolicy > | |
| Cis_dense< DenseShape > | |
| Cis_dense< DistArray< Tile, Policy > > | |
| Cis_lazy_tile | Detect lazy evaluation tiles |
| Cis_lazy_tile< DistArray< Tile, Policy > > | |
| CMaxReduction | Maximum tile reduction |
| CMaxReduction< Tile, typename std::enable_if< detail::is_strictly_ordered< detail::numeric_t< Tile > >::value >::type > | |
| CMinReduction | Minimum tile reduction |
| CMinReduction< Tile, typename std::enable_if< detail::is_strictly_ordered< detail::numeric_t< Tile > >::value >::type > | |
| CPermutation | Permutation of a sequence of objects indexed by base-0 indices |
| CPermute | Permute a tile |
| Cpermute_trait | Permute trait |
| ►CPmap | Process map |
| CIterator | Pmap iterator type |
| CProductReduction | Tile product reduction |
| CRange | A (hyperrectangular) interval on  , space of integer  -indices |
| CScalAdd | Add tile operation |
| CScalAddTo | Add-to and scale tile operation |
| CScale | Scale tile |
| Cscale_trait | Scale trait |
| Cshared_function | Analogous to std::function, but has shallow-copy semantics |
| CShift | Shift the range of tile |
| CShiftTo | Shift the range of tile in place |
| CSingleton | Singleton base class To create a singleton class A do: |
| CSparsePolicy | |
| CSparseShape | Frobenius-norm-based sparse shape |
| CSquaredNormReduction | Squared norm tile reduction |
| CSumReduction | Tile sum reduction |
| CTensor | An N-dimensional tensor object |
| CTile | An N-dimensional shallow copy wrapper for tile objects |
| CTiledRange | Range data of a tiled array |
| CTiledRange1 | |
| CTileOpsLogger | |
| CTraceReduction | Tile trace reduction |
| CZeroTensor | Place-holder object for a zero tensor |
| CKroneckerDeltaTile | generalized (asymmetric) Kronecker delta |
