| Cquda::clover::abs_< ReduceType, Float > | |
| Cquda::colorspinor::abs_< Float, storeFloat > | |
| Cquda::gauge::abs_< Float, storeFloat > | |
| Cquda::gauge::abs_< Float, int > | |
| Cquda::colorspinor::abs_< Float, int8_t > | |
| Cquda::gauge::abs_< Float, int8_t > | |
| Cquda::colorspinor::abs_< Float, short > | |
| Cquda::gauge::abs_< Float, short > | |
| Cquda::clover::Accessor< Float, nColor, nSpin, order > | |
| Cquda::gauge::Accessor< Float, nColor, order, storeFloat > | |
| Cquda::clover::Accessor< Float, nColor, nSpin, QUDA_FLOAT2_CLOVER_ORDER > | |
| Cquda::clover::Accessor< Float, nColor, nSpin, QUDA_FLOAT4_CLOVER_ORDER > | |
| Cquda::clover::Accessor< Float, nColor, nSpin, QUDA_PACKED_CLOVER_ORDER > | |
| Cquda::gauge::Accessor< Float, nColor, QUDA_FLOAT2_GAUGE_ORDER, storeFloat > | |
| Cquda::gauge::Accessor< Float, nColor, QUDA_MILC_GAUGE_ORDER, storeFloat > | |
| Cquda::gauge::Accessor< Float, nColor, QUDA_QDP_GAUGE_ORDER, storeFloat > | |
| Cquda::colorspinor::AccessorCB< Float, nSpin, nColor, nVec, order > | |
| Cquda::colorspinor::AccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT2_FIELD_ORDER > | |
| Cquda::colorspinor::AccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT4_FIELD_ORDER > | |
| Cquda::colorspinor::AccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT8_FIELD_ORDER > | |
| Cquda::colorspinor::AccessorCB< Float, nSpin, nColor, nVec, QUDA_SPACE_SPIN_COLOR_FIELD_ORDER > | |
| Ctesting::internal::AddReference< T > | |
| Ctesting::internal::AddReference< T & > | |
| Ctrove::detail::address_constants< T > | |
| Ctrove::detail::affine_modular_fn< m, a, b > | |
| Cdetail::aliased_size< T, U > | |
| Ctrove::detail::aliased_size< T, U > | |
| Cquda::AllocType< large_alloc > | |
| Cquda::AllocType< false > | |
| Cquda::AllocType< true > | |
| ►CCLI::App | |
| CQUDAApp | |
| Cdetail::array< T, m > | |
| Cquda::Array< T, N > | |
| Ctrove::array< T, m > | |
| Cdetail::array< T, 0 > | |
| Ctrove::array< T, 0 > | |
| Cdetail::array< T, 1 > | |
| Ctrove::array< T, 1 > | |
| Ctesting::internal::AssertHelper | |
| Cquda::atomic_type< T > | The atomic word size we use for a given reduction type. This type should be lock-free to guarantee correct behaviour on platforms that are not coherent with respect to the host |
| Cquda::atomic_type< float > | |
| ►Cstd::binary_function | |
| Cquda::less_significant< T > | |
| ►Ctesting::internal::bool_constant< bool_value > | |
| Ctesting::internal::IsRecursiveContainerImpl< C, false > | |
| Ctesting::internal::is_same< T, U > | |
| Ctesting::internal::is_same< T, T > | |
| ►Ctesting::internal::bool_constant< std::is_convertible< const T *, const ::proto2::Message * >::value > | |
| Ctesting::internal::IsAProtocolMessage< T > | |
| Cquda::clover::BQCDOrder< Float, length > | |
| Cquda::bridge_mapper< typename, typename > | |
| Cquda::bridge_mapper< double2, char2 > | |
| Cquda::bridge_mapper< double2, char4 > | |
| Cquda::bridge_mapper< double2, char8 > | |
| Cquda::bridge_mapper< double2, double2 > | |
| Cquda::bridge_mapper< double2, float2 > | |
| Cquda::bridge_mapper< double2, float4 > | |
| Cquda::bridge_mapper< double2, short2 > | |
| Cquda::bridge_mapper< double2, short4 > | |
| Cquda::bridge_mapper< double2, short8 > | |
| Cquda::bridge_mapper< float2, char2 > | |
| Cquda::bridge_mapper< float2, double2 > | |
| Cquda::bridge_mapper< float2, float2 > | |
| Cquda::bridge_mapper< float2, short2 > | |
| Cquda::bridge_mapper< float4, char4 > | |
| Cquda::bridge_mapper< float4, char8 > | |
| Cquda::bridge_mapper< float4, double2 > | |
| Cquda::bridge_mapper< float4, float4 > | |
| Cquda::bridge_mapper< float4, short4 > | |
| Cquda::bridge_mapper< float4, short8 > | |
| Cquda::bridge_mapper< float8, char8 > | |
| Cquda::bridge_mapper< float8, short8 > | |
| Ctrove::detail::c2r_compute_composite_offsets< T, m, p > | |
| Ctrove::detail::c2r_compute_composite_offsets< array< int, 1 >, m, p > | |
| Ctrove::detail::c2r_compute_composite_offsets< array< int, s >, m, p > | |
| Ctrove::detail::c2r_compute_indices_impl< Array, Schema > | |
| Ctrove::detail::c2r_compute_indices_impl< Array, composite > | |
| Ctrove::detail::c2r_compute_indices_impl< Array, odd > | |
| Ctrove::detail::c2r_compute_indices_impl< Array, power_of_two > | |
| Ctrove::detail::c2r_compute_initial_offset< m, Schema > | |
| Ctrove::detail::c2r_compute_initial_offset< m, odd > | |
| Ctrove::detail::c2r_compute_initial_offset< m, power_of_two > | |
| Ctrove::detail::c2r_compute_offsets_impl< Array, b, o > | |
| Ctrove::detail::c2r_compute_offsets_impl< array< int, 1 >, b, o > | |
| Ctrove::detail::c2r_compute_offsets_impl< array< int, s >, b, o > | |
| Ctrove::detail::c2r_offset_constants< m, Schema > | |
| Ctrove::detail::c2r_offset_constants< m, composite > | |
| Ctrove::detail::c2r_offset_constants< m, odd > | |
| ►Ctrove::detail::c2r_offset_constants< m, power_of_two > | |
| Ctrove::detail::r2c_offset_constants< m, power_of_two > | |
| Ctrove::detail::c2r_warp_transpose_impl< Array, Indices, Schema > | |
| Ctrove::detail::c2r_warp_transpose_impl< Array, Indices, composite > | |
| Ctrove::detail::c2r_warp_transpose_impl< Array, Indices, odd > | |
| Ctrove::detail::c2r_warp_transpose_impl< Array, Indices, power_of_two > | |
| Ctesting::internal::CartesianProductHolder< Gen > | |
| ►Cchar2 | |
| Cquda::complex< int8_t > | |
| Cquda::char8 | |
| Cquda::clover_mapper< Float, N, add_rho > | |
| Cquda::clover_mapper< double, N, add_rho > | |
| Cquda::clover_mapper< float, N, add_rho > | |
| Cquda::clover_mapper< int8_t, N, add_rho > | |
| Cquda::clover_mapper< short, N, add_rho > | |
| Cquda::clover_wrapper< Float, T > | Clover_wrapper is an internal class that is used to wrap instances of colorspinor accessors, currying in a specifc location and chirality on the field. The operator() accessors in clover-field accessors return instances to this class, allowing us to then use operator overloading upon this class to interact with the HMatrix class. As a result we can include clover-field accessors directly in HMatrix expressions in kernels without having to declare temporaries with explicit calls to the load/save methods in the clover-field accessors |
| Ctrove::coalesced_ptr< T > | |
| Ctrove::detail::coalesced_ref< T > | |
| Ctesting::internal::CodeLocation | |
| CColorMatrix< Real > | |
| Cquda::ColorSpinor< Float, Nc, Ns > | |
| Cquda::ColorSpinor< Float, Nc, 2 > | |
| Cquda::ColorSpinor< Float, Nc, 4 > | |
| Cquda::colorspinor_ghost_wrapper< Float, T > | Colorspinor_ghost_wrapper is an internal class that is used to wrap instances of colorspinor accessors, currying in a specifc location on the field. The Ghost() accessors in colorspinor-field accessors return instances to this class, allowing us to then use operator overloading upon this class to interact with the ColorSpinor class. As a result we can include colorspinor-field accessors directly in ColorSpinor expressions in kernels without having to declare temporaries with explicit calls to the loadGhost/saveGhost methods in the colorspinor-field accessors |
| Cquda::colorspinor_mapper< T, Ns, Nc, project, huge_alloc > | |
| Cquda::colorspinor_mapper< double, 1, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< double, 2, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< double, 4, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< double, 4, Nc, true, huge_alloc > | |
| Cquda::colorspinor_mapper< float, 1, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< float, 2, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< float, 4, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< float, 4, Nc, true, huge_alloc > | |
| Cquda::colorspinor_mapper< int8_t, 1, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< int8_t, 2, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< int8_t, 4, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< int8_t, 4, Nc, true, huge_alloc > | |
| Cquda::colorspinor_mapper< short, 1, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< short, 2, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< short, 4, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< short, 4, Nc, true, huge_alloc > | |
| Cquda::colorspinor_order_mapper< T, order, Ns, Nc > | |
| Cquda::colorspinor_order_mapper< T, QUDA_FLOAT2_FIELD_ORDER, Ns, Nc > | |
| Cquda::colorspinor_order_mapper< T, QUDA_SPACE_COLOR_SPIN_FIELD_ORDER, Ns, Nc > | |
| Cquda::colorspinor_order_mapper< T, QUDA_SPACE_SPIN_COLOR_FIELD_ORDER, Ns, Nc > | |
| Cquda::colorspinor_wrapper< Float, T > | Colorspinor_wrapper is an internal class that is used to wrap instances of colorspinor accessors, currying in a specifc location on the field. The operator() accessors in colorspinor-field accessors return instances to this class, allowing us to then use operator overloading upon this class to interact with the ColorSpinor class. As a result we can include colorspinor-field accessors directly in ColorSpinor expressions in kernels without having to declare temporaries with explicit calls to the load/save methods in the colorspinor-field accessors |
| Cquda::CommKey | |
| CCommunicator | |
| Ctesting::internal::CompileAssertTypesEqual< T1, T2 > | |
| Ctesting::internal::CompileAssertTypesEqual< T, T > | |
| Cquda::complex< ValueType > | |
| Cquda::complex< Float > | |
| Cquda::complex< storeFloat > | |
| Ctrove::detail::composite | |
| Ctrove::detail::composite_c2r_permute_fn< m > | |
| Ctrove::detail::composite_r2c_permute_fn< m > | |
| Cquda::CompositeColorSpinorFieldDescriptor | |
| Ctrove::cons_c< T, i, Tail > | |
| Ctesting::internal::ConstCharPtr | |
| Ctesting::internal::ConstRef< T > | |
| Ctesting::internal::ConstRef< T & > | |
| Ctrove::counting_array< T > | |
| Ctrove::counting_array< array< T, 1 > > | |
| Ctrove::counting_array< array< T, s > > | |
| Cdanti_hermitmat | |
| Cdcomplex | |
| Cquda::deflated_solver | |
| Cquda::Deflation | |
| Cquda::DeflationParam | |
| Cdhalf_wilson_vector | |
| ►Cquda::DiracMatrix | |
| Cquda::DiracDagger | |
| Cquda::DiracG5M | |
| Cquda::DiracM | |
| Cquda::DiracMMdag | |
| Cquda::DiracMdag | |
| Cquda::DiracMdagM | |
| Cquda::DiracMdagMLocal | |
| Cquda::DiracParam | |
| Cdetail::dismember< T, U, r > | |
| Ctrove::detail::dismember< T, U, r > | |
| Cdetail::dismember< T, U, 1 > | |
| Ctrove::detail::dismember< T, U, 1 > | |
| Ctrove::detail::dismember_type< T, use_int, use_int2, use_int4 > | |
| Ctrove::detail::dismember_type< T, true, false, false > | |
| Ctrove::detail::dismember_type< T, true, true, false > | |
| Ctrove::detail::dismember_type< T, true, true, true > | |
| Ctrove::detail::divergent_loader< s, T > | |
| Ctrove::detail::divergent_loader< 1, T > | |
| Ctrove::detail::divergent_storer< s, T > | |
| Ctrove::detail::divergent_storer< 1, T > | |
| ►Cdouble2 | |
| Cquda::complex< double > | |
| Cquda::double8 | |
| Cdoubledouble | |
| Cdoubledouble2 | |
| Cdoubledouble3 | |
| Ctesting::internal::DoubleSequence< plus_one, T, sizeofT > | |
| Ctesting::internal::DoubleSequence< false, IndexSequence< I... >, sizeofT > | |
| Ctesting::internal::DoubleSequence< true, IndexSequence< I... >, sizeofT > | |
| Cdoublesingle | |
| Cdoublesingle2 | |
| Cdoublesingle3 | |
| Cquda::DslashConstant | Constants used by dslash and packing kernels |
| CDslashTestWrapper | |
| CDslashTime | |
| Cdsu3_matrix | |
| Cdsu3_vector | |
| Cquda::EigCGArgs | |
| ►Cquda::EigenSolver | |
| Cquda::IRAM | Implicitly Restarted Arnoldi Method |
| ►Cquda::TRLM | Thick Restarted Lanczos Method |
| Cquda::BLKTRLM | Block Thick Restarted Lanczos Method |
| Ctesting::internal::ElemFromList< N, I, T > | |
| Ctesting::internal::ElemFromList< I, typename MakeIndexSequence< sizeof...(T)>::type, T... > | |
| Ctesting::internal::ElemFromListImpl< T, size_t, size_t > | |
| Ctesting::internal::ElemFromListImpl< T, I, I > | |
| ►Ctesting::internal::ElemFromListImpl< T, N, I > | |
| Ctesting::internal::ElemFromList< N, IndexSequence< I... >, T... > | |
| Ctrove::enable_if< b, T > | |
| Ctrove::enable_if< false, T > | |
| Ctesting::internal::EnableIf< bool > | |
| Ctesting::internal::EnableIf< true > | |
| Ctesting::Environment | |
| Ctesting::internal::EqHelper | |
| Ctrove::detail::affine_modular_fn< m, a, b >::eval< x > | |
| Ctrove::detail::composite_c2r_permute_fn< m >::eval< x > | |
| Ctrove::detail::composite_r2c_permute_fn< m >::eval< x > | |
| Ctesting::internal::faketype | |
| Cfanti_hermitmat | |
| Cfcomplex | |
| Cfhalf_wilson_vector | |
| Cquda::clover::FieldOrder< Float, nColor, nSpin, order > | |
| Cquda::gauge::FieldOrder< Float_, nColor, nSpinCoarse, order, native_ghost, storeFloat_ > | |
| Cquda::colorspinor::fieldorder_wrapper< Float, storeFloat > | Fieldorder_wrapper is an internal class that is used to wrap instances of FieldOrder accessors, currying in the specific location on the field. This is used as a helper class for fixed-point accessors providing the necessary conversion and scaling when writing to a fixed-point field |
| Cquda::gauge::fieldorder_wrapper< Float, storeFloat > | Fieldorder_wrapper is an internal class that is used to wrap instances of FieldOrder accessors, currying in the specific location on the field. This is used as a helper class for fixed-point accessors providing the necessary conversion and scaling when writing to a fixed-point field |
| Cquda::colorspinor::FieldOrderCB< Float, nSpin, nColor, nVec, order, storeFloat, ghostFloat, disable_ghost, block_float > | |
| Cquda::fixedInvMaxValue< T > | |
| Cquda::fixedInvMaxValue< char2 > | |
| Cquda::fixedInvMaxValue< char4 > | |
| Cquda::fixedInvMaxValue< char8 > | |
| Cquda::fixedInvMaxValue< int8_t > | |
| Cquda::fixedInvMaxValue< short > | |
| Cquda::fixedInvMaxValue< short2 > | |
| Cquda::fixedInvMaxValue< short4 > | |
| Cquda::fixedInvMaxValue< short8 > | |
| Cquda::fixedMaxValue< T > | |
| Cquda::fixedMaxValue< char2 > | |
| Cquda::fixedMaxValue< char4 > | |
| Cquda::fixedMaxValue< char8 > | |
| Cquda::fixedMaxValue< int8_t > | |
| Cquda::fixedMaxValue< short > | |
| Cquda::fixedMaxValue< short2 > | |
| Cquda::fixedMaxValue< short4 > | |
| Cquda::fixedMaxValue< short8 > | |
| Ctesting::internal::FlatTupleBase< Derived, Idx > | |
| ►Ctesting::internal::FlatTupleBase< FlatTuple< T... >, MakeIndexSequence< sizeof...(T)>::type > | |
| Ctesting::internal::FlatTuple< Ts... > | |
| Ctesting::internal::FlatTuple< T > | |
| Ctesting::internal::FlatTupleElemBase< Derived, I > | |
| Ctesting::internal::FlatTupleElemBase< FlatTuple< T... >, I > | |
| ►Ctesting::internal::FlatTupleElemBase< FlatTuple< T... >, Idx > | |
| Ctesting::internal::FlatTupleBase< FlatTuple< T... >, IndexSequence< Idx... > > | |
| ►Cfloat2 | |
| Cquda::complex< float > | |
| Cquda::float8 | |
| Ctesting::internal::FloatingPoint< RawType > | |
| Cquda::clover::FloatNOrder< Float, length, N, add_rho, huge_alloc > | Accessor routine for CloverFields in native field order |
| Cquda::colorspinor::FloatNOrder< Float, Ns, Nc, N_, spin_project, huge_alloc > | Accessor routine for ColorSpinorFields in native field order |
| Cquda::gauge::FloatNOrder< Float, length, N, reconLenParam, stag_phase, huge_alloc, ghostExchange_, use_inphase > | |
| Ctesting::internal::FormatForComparison< ToPrint, OtherOperand > | |
| Ctesting::internal::FormatForComparison< ToPrint[N], OtherOperand > | |
| Cfsu3_matrix | |
| Cfsu3_vector | |
| Cquda::FullClover | |
| Cquda::gauge_ghost_wrapper< Float, T > | Gauge_ghost_wrapper is an internal class that is used to wrap instances of gauge ghost accessors, currying in a specific location and dimension on the field. The Ghost() accessors in gauge-field accessors return instances to this class, allowing us to then use operator overloading upon this class to interact with the Matrix class. As a result we can include gauge-field ghost accessors directly in Matrix expressions in kernels without having to declare temporaries with explicit calls to the load/save methods in the gauge-field accessors |
| Cquda::gauge_mapper< T, QudaReconstructType, N, stag, huge_alloc, ghostExchange, use_inphase, order > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< int8_t, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< int8_t, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< int8_t, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< int8_t, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< int8_t, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< int8_t, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > | |
| Cquda::gauge_mapper< T, recon, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_MILC_GAUGE_ORDER > | |
| Cquda::gauge_mapper< T, recon, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_QDP_GAUGE_ORDER > | |
| Cquda::gauge_order_mapper< T, order, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_BQCD_GAUGE_ORDER, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_CPS_WILSON_GAUGE_ORDER, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_FLOAT2_GAUGE_ORDER, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_MILC_GAUGE_ORDER, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_QDP_GAUGE_ORDER, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_QDPJIT_GAUGE_ORDER, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_TIFR_GAUGE_ORDER, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_TIFR_PADDED_GAUGE_ORDER, Nc > | |
| Cquda::gauge_wrapper< Float, T > | Gauge_wrapper is an internal class that is used to wrap instances of gauge accessors, currying in a specific location on the field. The operator() accessors in gauge-field accessors return instances to this class, allowing us to then use operator overloading upon this class to interact with the Matrix class. As a result we can include gauge-field accessors directly in Matrix expressions in kernels without having to declare temporaries with explicit calls to the load/save methods in the gauge-field accessors |
| Cdetail::get_impl< T, m, i > | |
| Ctrove::detail::get_impl< T, m, i > | |
| Cdetail::get_impl< T, m, 0 > | |
| Ctrove::detail::get_impl< T, m, 0 > | |
| Cquda::gauge::GhostAccessor< Float, nColor, order, native_ghost, storeFloat > | |
| Cquda::gauge::GhostAccessor< Float, nColor, order, true, storeFloat > | |
| Cquda::gauge::GhostAccessor< Float, nColor, QUDA_FLOAT2_GAUGE_ORDER, native_ghost, storeFloat > | |
| Cquda::gauge::GhostAccessor< Float, nColor, QUDA_MILC_GAUGE_ORDER, native_ghost, storeFloat > | |
| Cquda::gauge::GhostAccessor< Float, nColor, QUDA_QDP_GAUGE_ORDER, native_ghost, storeFloat > | |
| Cquda::colorspinor::GhostAccessorCB< Float, nSpin, nColor, nVec, order > | |
| Cquda::colorspinor::GhostAccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT2_FIELD_ORDER > | |
| Cquda::colorspinor::GhostAccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT4_FIELD_ORDER > | |
| Cquda::colorspinor::GhostAccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT8_FIELD_ORDER > | |
| Cquda::colorspinor::GhostAccessorCB< Float, nSpin, nColor, nVec, QUDA_SPACE_SPIN_COLOR_FIELD_ORDER > | |
| Cquda::GMResDRArgs | |
| Ctesting::internal::GTestLog | |
| Ctesting::internal::GTestMutexLock | |
| Cquda::HMatrix< T, N > | Specialized container for Hermitian matrices (e.g., used for wrapping clover matrices) |
| Cquda::HMatrix_wrapper< T, Hmat > | Wrapper class that enables us to write to Hmatrices in packed format |
| CIdentity< N, T > | |
| Cquda::identity< T > | |
| Cquda::Identity< T > | |
| Ctesting::internal::IgnoredValue | |
| Ctrove::detail::indexed_load< s, T > | |
| Ctrove::detail::indexed_load< 1, T > | |
| Ctrove::detail::indexed_store< s, T > | |
| Ctrove::detail::indexed_store< 1, T > | |
| Ctesting::internal::IndexSequence< Is > | |
| ►Ctesting::internal::IndexSequence<> | |
| Ctesting::internal::MakeIndexSequence< 0 > | |
| Cquda::instantiateApply< enabled, Apply, Float, nColor, recon, G, Args > | This class instantiates the Apply class based on the instantiated templates below |
| Cquda::instantiateApply< false, Apply, Float, nColor, recon, G, Args... > | This class is a specialization which does not instantiate the Apply class if the is_enabled has evaluated to false |
| Cquda::instantiateReconstruct< Apply, Float, nColor, Recon, i, G, Args > | Instantiate the reconstruction template at index i and recurse to prior element |
| Cquda::instantiateReconstruct< Apply, Float, nColor, Recon, 0, G, Args... > | Termination specialization of instantiateReconstruct |
| ►Cint2 | |
| Cquda::complex< int > | |
| Cquda::Int2 | |
| Cint_fastdiv | |
| Ctrove::inverse< T, Fn, x, p > | |
| Ctrove::is_odd< m > | |
| Ctrove::is_power_of_two< m > | |
| Cquda::isFixed< T > | |
| Cquda::isFixed< char2 > | |
| Cquda::isFixed< char4 > | |
| Cquda::isFixed< char8 > | |
| Cquda::isFixed< int8_t > | |
| Cquda::isFixed< short > | |
| Cquda::isFixed< short2 > | |
| Cquda::isFixed< short4 > | |
| Cquda::isFixed< short8 > | |
| Cquda::isHalf< T > | |
| Cquda::isHalf< short > | |
| Cquda::isHalf< short2 > | |
| Cquda::isHalf< short4 > | |
| Cquda::isHalf< short8 > | |
| Ctesting::internal::IsHashTable< T > | |
| Cquda::isQuarter< T > | |
| Cquda::isQuarter< char2 > | |
| Cquda::isQuarter< char4 > | |
| Cquda::isQuarter< char8 > | |
| Cquda::isQuarter< int8_t > | |
| Ctesting::internal::IsRecursiveContainerImpl< C, bool > | |
| Ctesting::internal::IsRecursiveContainerImpl< C, true > | |
| Ctesting::internal::IsSame< T, U > | |
| Ctesting::internal::IsSame< T, T > | |
| Ctesting::internal::IteratorTraits< Iterator > | |
| Ctesting::internal::IteratorTraits< const T * > | |
| Ctesting::internal::IteratorTraits< T * > | |
| ►Cquda::LatticeFieldParam | |
| Cquda::CloverFieldParam | |
| Cquda::ColorSpinorParam | |
| Cquda::GaugeFieldParam | |
| ►Cquda::gauge::LegacyOrder< Float, length > | The LegacyOrder defines the ghost zone storage and ordering for all cpuGaugeFields, which use the same ghost zone storage |
| Cquda::gauge::BQCDOrder< Float, length > | Struct to define BQCD ordered gauge fields: |
| Cquda::gauge::CPSOrder< Float, length > | |
| Cquda::gauge::MILCOrder< Float, length > | |
| Cquda::gauge::MILCSiteOrder< Float, length > | Struct to define gauge fields packed into an opaque MILC site struct: |
| Cquda::gauge::QDPJITOrder< Float, length > | |
| Cquda::gauge::QDPOrder< Float, length > | |
| Cquda::gauge::TIFROrder< Float, length > | Struct to define TIFR ordered gauge fields: [mu][parity][volumecb][col][row] |
| Cquda::gauge::TIFRPaddedOrder< Float, length > | |
| CLexMapData | |
| Cdetail::load_storage< T, U, r > | |
| Cdetail::load_storage< T, U, 1 > | |
| CLoadStore< Real > | |
| CLocator< oddBit > | |
| Ctrove::detail::make_array_impl< T, s > | |
| Ctrove::detail::make_array_impl< T, 1 > | |
| Ctrove::detail::make_carray_impl< T, s > | |
| Ctrove::detail::make_carray_impl< T, 1 > | |
| Cquda::mapper< typename > | |
| Cquda::mapper< char2 > | |
| Cquda::mapper< char4 > | |
| Cquda::mapper< char8 > | |
| Cquda::mapper< double > | |
| Cquda::mapper< double2 > | |
| Cquda::mapper< double4 > | |
| Cquda::mapper< double8 > | |
| Cquda::mapper< Float > | |
| Cquda::mapper< float > | |
| Cquda::mapper< float2 > | |
| Cquda::mapper< float4 > | |
| Cquda::mapper< float8 > | |
| Cquda::mapper< int8_t > | |
| Cquda::mapper< short > | |
| Cquda::mapper< short2 > | |
| Cquda::mapper< short4 > | |
| Cquda::mapper< short8 > | |
| CMatrix< N, T > | |
| Cquda::Matrix< T, N > | |
| Cquda::matrix_field< T, n > | |
| Cquda::maximum< T > | |
| Cquda::MemAlloc | |
| Ctesting::Message | |
| CmgInputStruct | |
| CmilcMultigridPack | |
| Cquda::minimum< T > | |
| Cquda::MinResExt | This computes the optimum guess for the system Ax=b in the L2 residual norm. For use in the HMD force calculations using a minimal residual chronological method. This computes the guess solution as a linear combination of a given number of previous solutions. Following Brower et al, only the orthogonalised vector basis is stored to conserve memory |
| CMsgHandle_s | |
| Cquda::multigrid_solver | |
| ►Cquda::MultiShiftSolver | |
| Cquda::MultiShiftCG | Multi-Shift Conjugate Gradient Solver |
| Ctesting::internal::Mutex | |
| Ctesting::internal::NativeArray< Element > | |
| Cquda::norm_type< T > | |
| Cquda::norm_type< complex< T > > | |
| Cquda::normal< Real > | |
| Cquda::normal< double > | |
| Cquda::normal< float > | |
| Ctrove::null_type | |
| ►Cquda::Object | |
| ►Cquda::Dirac | |
| ►Cquda::DiracCoarse | |
| Cquda::DiracCoarsePC | |
| ►Cquda::DiracImprovedStaggered | |
| Cquda::DiracImprovedStaggeredKD | |
| Cquda::DiracImprovedStaggeredPC | |
| ►Cquda::DiracStaggered | |
| Cquda::DiracStaggeredKD | |
| Cquda::DiracStaggeredPC | |
| ►Cquda::DiracWilson | |
| ►Cquda::DiracClover | |
| Cquda::DiracCloverHasenbuschTwist | |
| ►Cquda::DiracCloverPC | |
| Cquda::DiracCloverHasenbuschTwistPC | |
| ►Cquda::DiracDomainWall | |
| ►Cquda::DiracDomainWall4D | |
| Cquda::DiracDomainWall4DPC | |
| Cquda::DiracDomainWallPC | |
| ►Cquda::DiracMobius | |
| ►Cquda::DiracMobiusEofa | |
| Cquda::DiracMobiusEofaPC | |
| Cquda::DiracMobiusPC | |
| ►Cquda::DiracTwistedClover | |
| Cquda::DiracTwistedCloverPC | |
| ►Cquda::DiracTwistedMass | |
| Cquda::DiracTwistedMassPC | |
| Cquda::DiracWilsonPC | |
| Cquda::GaugeCovDev | Full Covariant Derivative operator. Although not a Dirac operator per se, it's a linear operator so it's conventient to put in the Dirac operator abstraction |
| ►Cquda::GaugeLaplace | Full Gauge Laplace operator. Although not a Dirac operator per se, it's a linear operator so it's conventient to put in the Dirac operator abstraction |
| Cquda::GaugeLaplacePC | Even-odd preconditioned Gauge Laplace operator |
| ►Cquda::LatticeField | |
| ►Cquda::CloverField | |
| Cquda::cpuCloverField | |
| Cquda::cudaCloverField | |
| ►Cquda::ColorSpinorField | |
| Cquda::cpuColorSpinorField | |
| Cquda::cudaColorSpinorField | |
| ►Cquda::GaugeField | |
| Cquda::cpuGaugeField | |
| Cquda::cudaGaugeField | |
| Cquda::deflation_space | This is an object that captures the state required for a deflated solver |
| Ctrove::detail::odd | |
| Cquda::colorspinor::PaddedSpaceSpinorColorOrder< Float, Ns, Nc > | |
| ►Ctesting::internal::ParameterizedTestSuiteInfoBase | |
| Ctesting::internal::ParameterizedTestSuiteInfo< TestSuite > | |
| Ctesting::internal::ParameterizedTestSuiteRegistry | |
| Ctesting::internal::ParamGenerator< T > | |
| ►Ctesting::internal::ParamGeneratorInterface< T > | |
| Ctesting::internal::RangeGenerator< T, IncrementT > | |
| Ctesting::internal::ValuesInIteratorRangeGenerator< T > | |
| Ctesting::internal::ParamGeneratorInterface< ParamType > | |
| ►Ctesting::internal::ParamGeneratorInterface<::std::tuple< T... > > | |
| Ctesting::internal::CartesianProductGenerator< T > | |
| Ctesting::internal::ParamIterator< T > | |
| Ctesting::internal::ParamIteratorInterface< T > | |
| Ctesting::internal::ParamIteratorInterface< ParamType > | |
| CPathCoefficients< Real > | |
| Cquda::plus< T > | |
| Ctrove::detail::power_of_two | |
| Ctesting::PrintToStringParamName | |
| CPromote< T, U > | |
| CPromote< double, float > | |
| CPromote< double, int > | |
| CPromote< double, std::complex< double > > | |
| CPromote< float, double > | |
| CPromote< float, int > | |
| CPromote< float, std::complex< double > > | |
| CPromote< float, std::complex< float > > | |
| CPromote< int, double > | |
| CPromote< int, float > | |
| CPromote< int, std::complex< double > > | |
| CPromote< int, std::complex< float > > | |
| CPromote< std::complex< double >, double > | |
| CPromote< std::complex< double >, float > | |
| CPromote< std::complex< double >, int > | |
| CPromote< std::complex< float >, int > | |
| Cquda::PromoteTypeId< T, U > | |
| Cquda::PromoteTypeId< complex< double >, double > | |
| Cquda::PromoteTypeId< complex< float >, float > | |
| Cquda::PromoteTypeId< double, complex< double > > | |
| Cquda::PromoteTypeId< double, float > | |
| Cquda::PromoteTypeId< double, int > | |
| Cquda::PromoteTypeId< double, int8_t > | |
| Cquda::PromoteTypeId< double, short > | |
| Cquda::PromoteTypeId< float, complex< float > > | |
| Cquda::PromoteTypeId< float, double > | |
| Cquda::PromoteTypeId< float, int > | |
| Cquda::PromoteTypeId< float, int8_t > | |
| Cquda::PromoteTypeId< float, short > | |
| Cquda::PromoteTypeId< int, double > | |
| Cquda::PromoteTypeId< int, float > | |
| Cquda::PromoteTypeId< int8_t, double > | |
| Cquda::PromoteTypeId< int8_t, float > | |
| Cquda::PromoteTypeId< int8_t, short > | |
| Cquda::PromoteTypeId< short, double > | |
| Cquda::PromoteTypeId< short, float > | |
| Cquda::PromoteTypeId< short, int8_t > | |
| Cquda::colorspinor::QDPJITDiracOrder< Float, Ns, Nc > | |
| Cquda::clover::QDPJITOrder< Float, length > | |
| Cquda::clover::QDPOrder< Float, length > | |
| CQUDA_DiracField | |
| CQUDA_DiracFieldParam_s | |
| CQudaBLASParam_s | |
| CQudaEigArgs_t | |
| CQudaEigParam_s | |
| CQudaFatLinkArgs_t | |
| CQudaGaugeObservableParam_s | |
| CQudaGaugeParam_s | |
| CQudaHisqParams_t | |
| CQudaInitArgs_t | |
| CQudaInvertArgs_t | |
| CQudaInvertParam_s | |
| CQudaLayout_t | |
| CQudaMILCSiteArg_t | |
| CQudaMultigridParam_s | |
| Ctrove::detail::r2c_compute_composite_offsets< T, m > | |
| Ctrove::detail::r2c_compute_composite_offsets< array< int, 1 >, m > | |
| Ctrove::detail::r2c_compute_composite_offsets< array< int, s >, m > | |
| Ctrove::detail::r2c_compute_indices_impl< Array, Schema > | |
| Ctrove::detail::r2c_compute_indices_impl< Array, composite > | |
| Ctrove::detail::r2c_compute_indices_impl< Array, odd > | |
| Ctrove::detail::r2c_compute_indices_impl< Array, power_of_two > | |
| Ctrove::detail::r2c_compute_initial_offset< m, Schema > | |
| Ctrove::detail::r2c_compute_initial_offset< m, odd > | |
| Ctrove::detail::r2c_compute_offsets_impl< Array, index, m, Schema > | |
| Ctrove::detail::r2c_compute_offsets_impl< array< int, 1 >, index, m, odd > | |
| Ctrove::detail::r2c_compute_offsets_impl< array< int, 1 >, index, m, power_of_two > | |
| Ctrove::detail::r2c_compute_offsets_impl< array< int, s >, index, m, odd > | |
| Ctrove::detail::r2c_compute_offsets_impl< array< int, s >, index, m, power_of_two > | |
| Ctrove::detail::r2c_offset_constants< m, Schema > | |
| Ctrove::detail::r2c_offset_constants< m, odd > | |
| Ctrove::detail::r2c_offsets< index, offset, bound > | |
| Ctrove::detail::r2c_warp_transpose_impl< Array, Indices, Schema > | |
| Ctrove::detail::r2c_warp_transpose_impl< Array, Indices, composite > | |
| Ctrove::detail::r2c_warp_transpose_impl< Array, Indices, odd > | |
| Ctrove::detail::r2c_warp_transpose_impl< Array, Indices, power_of_two > | |
| Ctesting::internal::Random | |
| Ctesting::internal::RE | |
| Cquda::RealType< T > | |
| Cquda::RealType< char2 > | |
| Cquda::RealType< char4 > | |
| Cquda::RealType< complex< double > > | |
| Cquda::RealType< complex< float > > | |
| Cquda::RealType< complex< int8_t > > | |
| Cquda::RealType< complex< short > > | |
| Cquda::RealType< double > | |
| Cquda::RealType< double2 > | |
| Cquda::RealType< float > | |
| Cquda::RealType< float2 > | |
| Cquda::RealType< float4 > | |
| Cquda::RealType< int8_t > | |
| Cquda::RealType< short > | |
| Cquda::RealType< short2 > | |
| Cquda::RealType< short4 > | |
| Cquda::gauge::Reconstruct< N, Float, ghostExchange_, QudaStaggeredPhase > | Generic reconstruction helper with no reconstruction |
| Cquda::Reconstruct10 | |
| Cquda::gauge::Reconstruct< 11, Float, ghostExchange_ > | Gauge reconstruct helper for Momentum field with 10 packed elements (really 9 from the Lie algebra, with zero for last element). We label this as 11 to avoid collisions with simple load/store of momentum field where we do not seek to unpack/pack |
| Cquda::gauge::Reconstruct< 12, Float, ghostExchange_ > | Gauge reconstruct 12 helper where we reconstruct the third row from the cross product of the first two rows |
| Cquda::gauge::Reconstruct< 13, Float, ghostExchange_, stag_phase > | Gauge reconstruct 13 helper where we reconstruct the third row from the cross product of the first two rows, and include a non-trivial phase factor |
| Cquda::gauge::Reconstruct< 8, Float, ghostExchange_ > | Gauge reconstruct 8 helper where we reconstruct the gauge matrix from 8 packed elements (maximal compression) |
| Cquda::gauge::Reconstruct< 9, Float, ghostExchange_, stag_phase > | Gauge reconstruct 9 helper where we reconstruct the gauge matrix from 8 packed elements (maximal compression) and include a non-trivial phase factor |
| Cquda::gauge::Reconstruct< reconLenParam, Float, QUDA_GHOST_EXCHANGE_INVALID, QUDA_STAGGERED_PHASE_NO > | |
| Cquda::ReconstructFull | |
| Cquda::ReconstructMom | |
| Cquda::ReconstructNo12 | |
| Cquda::ReconstructNone | |
| Cquda::ReconstructStaggered | |
| Cquda::ReconstructWilson | |
| Cquda::ReduceArg< T > | |
| ►Cquda::ReduceArg< reduce_t > | |
| Cquda::TransformReduceArg< reduce_t, T, count_t, transformer, reducer > | |
| Ctesting::internal::RelationToSourceCopy | |
| Ctesting::internal::RelationToSourceReference | |
| Cdetail::remember< T, U, r > | |
| Ctrove::detail::remember< T, U, r > | |
| Cdetail::remember< T, U, 1 > | |
| Ctrove::detail::remember< T, U, 1 > | |
| Ctesting::internal::RemoveConst< T > | |
| Ctesting::internal::RemoveConst< const T > | |
| Ctesting::internal::RemoveConst< const T[N]> | |
| Ctesting::internal::RemoveReference< T > | |
| Ctesting::internal::RemoveReference< T & > | |
| Cquda::RNG | Class declaration to initialize and hold CURAND RNG states |
| Ctrove::detail::rotate_elements< Array, i, j > | |
| Ctrove::detail::rotate_elements_helper< Array, i, j, non_terminal > | |
| Ctrove::detail::rotate_elements_helper< Array, i, j, false > | |
| Ctrove::detail::rotate_impl< Array, i > | |
| Ctrove::detail::rotate_impl_helper< Array, i, non_terminal > | |
| Ctrove::detail::rotate_impl_helper< Array, i, false > | |
| Cquda::clover::S< real, length > | This is just a dummy structure we use for trove to define the required structure size |
| Cquda::colorspinor::S< real, length > | This is just a dummy structure we use for trove to define the required structure size |
| Cquda::gauge::S< real, length > | This is just a dummy structure we use for trove to define the required structure size |
| Cquda::scalar< typename > | |
| Cquda::scalar< char2 > | |
| Cquda::scalar< char3 > | |
| Cquda::scalar< char4 > | |
| Cquda::scalar< char8 > | |
| Cquda::scalar< complex< double > > | |
| Cquda::scalar< complex< float > > | |
| Cquda::scalar< double > | |
| Cquda::scalar< double2 > | |
| Cquda::scalar< double3 > | |
| Cquda::scalar< double4 > | |
| Cquda::scalar< double8 > | |
| Cquda::scalar< float > | |
| Cquda::scalar< float2 > | |
| Cquda::scalar< float3 > | |
| Cquda::scalar< float4 > | |
| Cquda::scalar< float8 > | |
| Cquda::scalar< int8_t > | |
| Cquda::scalar< short > | |
| Cquda::scalar< short2 > | |
| Cquda::scalar< short3 > | |
| Cquda::scalar< short4 > | |
| Cquda::scalar< short8 > | |
| Ctesting::ScopedTrace | |
| ►Cshort2 | |
| Cquda::complex< short > | |
| Cquda::short8 | |
| Cdetail::shuffle< s > | |
| Cdetail::shuffle< 1 > | |
| Cdetail::shuffle_down< s > | |
| Cdetail::shuffle_down< 1 > | |
| Cdetail::shuffle_up< s > | |
| Cdetail::shuffle_up< 1 > | |
| Cdetail::shuffle_xor< s > | |
| Cdetail::shuffle_xor< 1 > | |
| CSign< N > | |
| CSign< 1 > | |
| Ctrove::detail::size_in_range< T > | |
| Cdetail::size_multiple_power_of_two< T, p > | |
| Ctrove::size_multiple_power_of_two< T, p > | |
| ►Cquda::Solver | |
| Cquda::BiCGstab | |
| Cquda::BiCGstabL | |
| ►Cquda::CACG | Communication-avoiding CG solver. This solver does un-preconditioned CG, running in steps of n_krylov, build up a polynomial in the linear operator of length n_krylov, and then performs a steepest descent minimization on the resulting basis vectors. For now only implemented using the power basis so is only useful as a preconditioner |
| Cquda::CACGNE | |
| Cquda::CACGNR | |
| Cquda::CAGCR | Communication-avoiding GCR solver. This solver does un-preconditioned GCR, first building up a polynomial in the linear operator of length n_krylov, and then performs a minimum residual extrapolation on the resulting basis vectors. For use as a multigrid smoother with minimum global synchronization |
| ►Cquda::CG | Conjugate-Gradient Solver |
| Cquda::CGNE | |
| Cquda::CGNR | |
| ►Cquda::CG3 | |
| Cquda::CG3NE | |
| Cquda::CG3NR | |
| Cquda::GCR | |
| Cquda::GMResDR | |
| Cquda::IncEigCG | |
| Cquda::MG | |
| Cquda::MPBiCGstab | |
| Cquda::MPCG | |
| Cquda::MR | |
| Cquda::PreconCG | |
| Cquda::PreconditionedSolver | |
| Cquda::SD | |
| Cquda::SimpleBiCGstab | |
| Cquda::XSD | |
| ►Cquda::SolverParam | |
| Cquda::MGParam | |
| Cquda::SortedEvals | |
| Cquda::colorspinor::SpaceColorSpinorOrder< Float, Ns, Nc > | |
| Cquda::colorspinor::SpaceSpinorColorOrder< Float, Ns, Nc > | |
| Cquda::clover::square_< ReduceType, Float > | |
| Cquda::colorspinor::square_< ReduceType, Float > | |
| Cquda::gauge::square_< ReduceType, Float > | |
| Cquda::gauge::square_< ReduceType, int > | |
| Cquda::colorspinor::square_< ReduceType, int8_t > | |
| Cquda::gauge::square_< ReduceType, int8_t > | |
| Cquda::colorspinor::square_< ReduceType, short > | |
| Cquda::gauge::square_< ReduceType, short > | |
| CStaggeredDslashTestWrapper | |
| Cquda::StaggeredReconstruct | |
| Ctrove::static_gcd< u, v > | |
| Ctrove::static_gcd< 0, v > | |
| Ctrove::static_gcd< u, 0 > | |
| Ctrove::detail::static_gcd_helper< u_odd, v_odd, u, v > | |
| Ctrove::detail::static_gcd_helper< false, true, u, v > | |
| Ctrove::detail::static_gcd_helper< true, false, u, v > | |
| Ctrove::detail::static_gcd_helper< true, true, u, v > | |
| Ctrove::static_log< m > | |
| Ctrove::static_log< 0 > | |
| Ctrove::static_log< 1 > | |
| Ctrove::static_mod_inverse< a, m, r > | |
| Ctrove::static_mod_inverse_helper< done, a, m, r > | |
| Ctrove::static_mod_inverse_helper< false, a, m, r > | |
| Ctrove::static_range< k, l > | |
| Ctrove::static_range< f, f > | |
| Ctesting::internal::StaticAssertTypeEqHelper< T1, T2 > | |
| Ctesting::internal::StaticAssertTypeEqHelper< T, T > | |
| Ctesting::internal::String | |
| Csu3_matrix< real > | |
| Csu3_vector< real > | |
| Ctrove::sum_array< T > | |
| Ctrove::sum_array< array< T, 1 > > | |
| Ctrove::sum_array< array< T, s > > | |
| ►CT | |
| Ctesting::internal::SuiteApiResolver< T > | |
| ►Ctesting::Test | |
| ►Ctesting::TestWithParam< int > | |
| CBLASTest | |
| ►Ctesting::TestWithParam<::testing::tuple< int, int, int > > | |
| CDslashTest | |
| CStaggeredDslashTest | |
| ►Ctesting::TestWithParam<::testing::tuple< int, int > > | |
| CBlasTest | |
| CContractionTest | |
| CGaugeAlgTest | |
| Ctesting::TestWithParam< T > | |
| ►Ctesting::TestEventListener | |
| Ctesting::EmptyTestEventListener | |
| Ctesting::TestEventListeners | |
| ►Ctesting::internal::TestFactoryBase | |
| Ctesting::internal::ParameterizedTestFactory< TestClass > | |
| Ctesting::internal::TestFactoryImpl< TestClass > | |
| Ctesting::TestInfo | |
| Ctesting::internal::TestMetaFactoryBase< ParamType > | |
| ►Ctesting::internal::TestMetaFactoryBase< TestSuite::ParamType > | |
| Ctesting::internal::TestMetaFactory< TestSuite > | |
| Ctesting::TestParamInfo< ParamType > | |
| Ctesting::TestProperty | |
| Ctesting::TestResult | |
| Ctesting::TestSuite | |
| Ctesting::internal::ThreadLocal< T > | |
| Cquda::TimeProfile | |
| Cquda::Timer | |
| CTopology_s | |
| Cquda::TraceKey | |
| Cquda::Transfer | |
| Cquda::Trig< isFixed, T > | |
| Cquda::Trig< false, float > | |
| Cquda::Trig< true, float > | |
| ►Cquda::Tunable | |
| Cquda::QudaMem | |
| Cquda::TransformReduce< reduce_t, T, I, transformer, reducer > | |
| Cquda::TunableLocalParityReduction | |
| ►Cquda::TunableVectorY | |
| ►Cquda::TunableVectorYZ | |
| Cquda::Dslash< D, Arg > | This is the generic driver for launching Dslash kernels (the base kernel of which is defined in dslash_helper.cuh). This is templated on the a template template parameter which is the underlying operator wrapped in a class, |
| Cquda::TuneKey | |
| Cquda::TuneParam | |
| Ctrove::detail::tx_algorithm< m, ispo2, isodd > | |
| Ctrove::detail::tx_algorithm< m, false, true > | |
| Ctrove::detail::tx_algorithm< m, true, false > | |
| Ctrove::detail::tx_permute_impl< T, Permute, position > | |
| Ctrove::detail::tx_permute_impl< array< T, 1 >, Permute, position > | |
| Ctrove::detail::tx_permute_impl< array< T, s >, Permute, position > | |
| ►CDoubleSequence::type | |
| Ctesting::internal::MakeIndexSequence< N > | |
| ►CIsRecursiveContainerImpl::type | |
| Ctesting::internal::IsRecursiveContainer< C > | |
| Ctesting::internal::TypeIdHelper< T > | |
| Ctesting::internal2::TypeWithoutFormatter< T, kTypeKind > | |
| Ctesting::internal2::TypeWithoutFormatter< T, kConvertibleToInteger > | |
| Ctesting::internal2::TypeWithoutFormatter< T, kProtobuf > | |
| Ctesting::internal::TypeWithSize< size > | |
| Ctesting::internal::TypeWithSize< 4 > | |
| Ctesting::internal::TypeWithSize< 8 > | |
| Ctesting::internal::TypeWithSize< sizeof(RawType)> | |
| Ctrove::detail::uncoalesced_store_array< Array > | |
| Ctrove::detail::uncoalesced_store_array< array< T, 1 > > | |
| Ctrove::detail::uncoalesced_store_array< array< T, s > > | |
| Cquda::uniform< Real > | |
| Cquda::uniform< double > | |
| Cquda::uniform< float > | |
| Ctesting::UnitTest | |
| Ctesting::internal::UniversalPrinter< T > | |
| Ctesting::internal::UniversalPrinter< T & > | |
| Ctesting::internal::UniversalPrinter< T[N]> | |
| Ctesting::internal::UniversalTersePrinter< T > | |
| Ctesting::internal::UniversalTersePrinter< char * > | |
| Ctesting::internal::UniversalTersePrinter< const char * > | |
| Ctesting::internal::UniversalTersePrinter< T & > | |
| Ctesting::internal::UniversalTersePrinter< T[N]> | |
| Ctesting::internal::UniversalTersePrinter< wchar_t * > | |
| Ctrove::detail::use_direct< T > | |
| Ctrove::detail::use_divergent< T > | |
| Ctrove::detail::use_shfl< T, s, r > | |
| Ctrove::detail::use_shfl< T, true, true > | |
| Ctrove::value_identity< T, x > | |
| Ctrove::value_if< cond, T, Then, Else > | |
| Ctrove::value_if< false, T, Then, Else > | |
| Ctesting::internal::ValueArray< Ts > | |
| Cquda::vec_length< typename > | |
| Cquda::vec_length< char2 > | |
| Cquda::vec_length< char3 > | |
| Cquda::vec_length< char4 > | |
| Cquda::vec_length< char8 > | |
| Cquda::vec_length< Complex > | |
| Cquda::vec_length< complex< double > > | |
| Cquda::vec_length< complex< float > > | |
| Cquda::vec_length< complex< int8_t > > | |
| Cquda::vec_length< complex< short > > | |
| Cquda::vec_length< double > | |
| Cquda::vec_length< double2 > | |
| Cquda::vec_length< double3 > | |
| Cquda::vec_length< double4 > | |
| Cquda::vec_length< double8 > | |
| Cquda::vec_length< float > | |
| Cquda::vec_length< float2 > | |
| Cquda::vec_length< float3 > | |
| Cquda::vec_length< float4 > | |
| Cquda::vec_length< float8 > | |
| Cquda::vec_length< int8_t > | |
| Cquda::vec_length< short > | |
| Cquda::vec_length< short2 > | |
| Cquda::vec_length< short3 > | |
| Cquda::vec_length< short4 > | |
| Cquda::vec_length< short8 > | |
| Cquda::vector< typename, N > | |
| Cquda::vector< double, 2 > | |
| Cquda::vector< float, 2 > | |
| Cquda::vector< int, 2 > | |
| Cquda::vector_type< scalar, n > | |
| Cquda::VectorIO | VectorIO is a simple wrapper class for loading and saving sets of vector fields using QIO |
| Cquda::VectorType< Float, number > | |
| Cquda::VectorType< double, 1 > | |
| Cquda::VectorType< double, 2 > | |
| Cquda::VectorType< double, 3 > | |
| Cquda::VectorType< double, 4 > | |
| Cquda::VectorType< double, 8 > | |
| Cquda::VectorType< float, 1 > | |
| Cquda::VectorType< float, 2 > | |
| Cquda::VectorType< float, 3 > | |
| Cquda::VectorType< float, 4 > | |
| Cquda::VectorType< float, 8 > | |
| Cquda::VectorType< int8_t, 1 > | |
| Cquda::VectorType< int8_t, 2 > | |
| Cquda::VectorType< int8_t, 3 > | |
| Cquda::VectorType< int8_t, 4 > | |
| Cquda::VectorType< int8_t, 8 > | |
| Cquda::VectorType< short, 1 > | |
| Cquda::VectorType< short, 2 > | |
| Cquda::VectorType< short, 3 > | |
| Cquda::VectorType< short, 4 > | |
| Cquda::VectorType< short, 8 > | |
| Ctrove::detail::warp_load_array< Array > | |
| Ctrove::detail::warp_load_array< array< T, 1 > > | |
| Ctrove::detail::warp_load_array< array< T, s > > | |
| Ctrove::detail::warp_shuffle< Data, Indices > | |
| Ctrove::detail::warp_shuffle< array< T, 1 >, array< int, 1 > > | |
| Ctrove::detail::warp_shuffle< array< T, m >, array< int, m > > | |
| Ctrove::detail::warp_store_array< Array > | |
| Ctrove::detail::warp_store_array< array< T, 1 > > | |
| Ctrove::detail::warp_store_array< array< T, s > > | |
| Cquda::WilsonReconstruct | |
| ►Ctesting::WithParamInterface< T > | |
| Ctesting::TestWithParam< int > | |
| Ctesting::TestWithParam<::testing::tuple< int, int, int > > | |
| Ctesting::TestWithParam<::testing::tuple< int, int > > | |
| Ctesting::TestWithParam< T > | |
| ►Cquda::Worker | |
| Cquda::BiCGstabLUpdate | |
| Cquda::ShiftUpdate | |
| Cdetail::working_array< T > | |
| Cdetail::working_type< T, use_int > | |
| Cdetail::working_type< T, true > | |
| Ctesting::internal::WrapPrinterType< type > | |
| Cquda::Zero< T > | |
| CZero< N, T > | |
