| Cquda::gauge::abs_< Float, storeFloat > | |
| Cquda::clover::abs_< ReduceType, Float > | |
| Cquda::colorspinor::abs_< Float, storeFloat > | |
| Cquda::gauge::abs_< Float, char > | |
| Cquda::colorspinor::abs_< Float, char > | |
| Cquda::gauge::abs_< Float, int > | |
| Cquda::gauge::abs_< Float, short > | |
| Cquda::colorspinor::abs_< Float, short > | |
| Cquda::gauge::Accessor< Float, nColor, order, storeFloat, use_tex > | |
| Cquda::clover::Accessor< Float, nColor, nSpin, order > | |
| 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, use_tex > | |
| Cquda::gauge::Accessor< Float, nColor, QUDA_MILC_GAUGE_ORDER, storeFloat, use_tex > | |
| Cquda::gauge::Accessor< Float, nColor, QUDA_QDP_GAUGE_ORDER, storeFloat, use_tex > | |
| 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_SPACE_SPIN_COLOR_FIELD_ORDER > | |
| Cquda::colorspinor::AccessorCB< real, nSpin, nColor, nVec, order > | |
| Cquda::colorspinor::AccessorCB< storeFloat, nSpin, nColor, nVec, order > | |
| Cquda::colorspinor::AccessorCB< vFloat, nSpin, nColor, nVec, order > | |
| Cquda::AllocType< large_alloc > | |
| Cquda::AllocType< false > | |
| Cquda::AllocType< true > | |
| Cquda::Arg< real, Ns, Nc, order > | |
| Cquda::Array< T, N > | |
| ►Cbinary_function | |
| Cquda::less_significant< T > | |
| Cquda::blas::BlasArg< SpinorX, SpinorY, SpinorZ, SpinorW, SpinorV, Functor > | |
| ►Cquda::blas::BlasFunctor< Float2, FloatN > | |
| Cquda::blas::ax_< Float2, FloatN > | |
| Cquda::blas::axpbyz_< Float2, FloatN > | |
| Cquda::blas::axpyBzpcx_< Float2, FloatN > | |
| Cquda::blas::axpyZpbx_< Float2, FloatN > | |
| Cquda::blas::cabxpyAx_< Float2, FloatN > | |
| Cquda::blas::caxpby_< Float2, FloatN > | |
| Cquda::blas::caxpbypczw_< Float2, FloatN > | |
| Cquda::blas::caxpbypzYmbw_< Float2, FloatN > | |
| Cquda::blas::caxpy_< Float2, FloatN > | |
| Cquda::blas::caxpyBxpz_< Float2, FloatN > | |
| Cquda::blas::caxpyBzpx_< Float2, FloatN > | |
| Cquda::blas::caxpyxmaz_< Float2, FloatN > | |
| Cquda::blas::caxpyxmazMR_< Float2, FloatN > | |
| Cquda::blas::doubleCG3Init_< Float2, FloatN > | |
| Cquda::blas::doubleCG3Update_< Float2, FloatN > | |
| Cquda::blas::tripleCGUpdate_< Float2, FloatN > | |
| Cquda::BlockOrthoArg< Rotator, Vector, fineSpin, spinBlockSize, coarseSpin, nVec > | |
| Cquda::clover::BQCDOrder< Float, length > | |
| Cquda::bridge_mapper< typename, typename > | |
| Cquda::bridge_mapper< double2, char2 > | |
| Cquda::bridge_mapper< double2, char4 > | |
| 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< 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, double2 > | |
| Cquda::bridge_mapper< float4, float4 > | |
| Cquda::bridge_mapper< float4, short4 > | |
| Cquda::CalculateYArg< Float, fineSpin, coarseSpin, fineColor, coarseColor, coarseGauge, coarseGaugeAtomic, fineGauge, fineSpinor, fineSpinorTmp, fineSpinorV, fineClover > | |
| Cquda::CalculateYhatArg< Float, PreconditionedGauge, Gauge, n > | |
| ►Cchar2 | |
| Cquda::complex< char > | |
| Cquda::ChecksumArg< T, order, Nc > | |
| Cquda::ChiralToNonRelBasis< Arg > | |
| Cquda::linalg::Cholesky< Mat, T, N, fast > | Compute Cholesky decomposition of A. By default, we use a modified Cholesky which avoids the division and sqrt, and instead only needs rsqrt. In which case we must use a modified forward and backward difference substitution |
| Cquda::clover_mapper< Float, N, add_rho > | |
| Cquda::clover_mapper< char, N, add_rho > | |
| Cquda::clover_mapper< double, N, add_rho > | |
| Cquda::clover_mapper< Float > | |
| Cquda::clover_mapper< float, 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 |
| Cquda::CloverArg< Float, nSpin, nColor, dynamic_clover_ > | Parameteter structure for driving the clover and twist-clover application kernels |
| Cquda::CloverDerivArg< Float, Force, Gauge, Oprod > | |
| Cquda::CloverSigmaOprodArg< Float, Output, InputA, InputB > | |
| Cquda::coeff_5< real > | Structure containing zMobius / Zolotarev coefficients |
| Cquda::blas::coeff_array< T > | |
| Cquda::coeff_type< real, is_variable, Arg > | Helper class for grabbing the constant struct, whether we are on the GPU or CPU |
| Cquda::coeff_type< real, true, Arg > | Specialization for variable complex coefficients |
| 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< char, 1, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< char, 2, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< char, 4, Nc, false, huge_alloc > | |
| Cquda::colorspinor_mapper< char, 4, Nc, true, 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< Float, 4, nColor > | |
| Cquda::colorspinor_mapper< Float, Ns, Nc > | |
| Cquda::colorspinor_mapper< Float, nSpin, nColor > | |
| Cquda::colorspinor_mapper< Float, nSpin, nColor, spin_project, spinor_direct_load > | |
| Cquda::colorspinor_mapper< real, nSpin, nColor, spin_project, spinor_direct_load > | |
| 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::complex< ValueType > | |
| Cquda::CompositeColorSpinorFieldDescriptor | |
| Cquda::ContractionArg< real > | |
| Cquda::CopyColorSpinorArg< FloatOut, FloatIn, nSpin_, nColor_, Out, In > | |
| Cquda::CopyGaugeArg< OutOrder, InOrder > | |
| Cquda::CopyGaugeExArg< OutOrder, InOrder > | |
| Cquda::CopySpinorExArg< OutOrder, InOrder, Basis > | |
| Cdanti_hermitmat | |
| Cdcomplex | |
| Cquda::deflated_solver | |
| Cquda::Deflation | |
| Cquda::DeflationParam | |
| Cdhalf_wilson_vector | |
| ►Cquda::DiracMatrix | |
| Cquda::DiracDagger | |
| Cquda::DiracM | |
| Cquda::DiracMdag | |
| Cquda::DiracMdagM | |
| Cquda::DiracMMdag | |
| Cquda::DiracParam | |
| Cquda::DomainWall4DApply< Float, nColor, recon > | |
| Cquda::DomainWall4DLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::DomainWall5DApply< Float, nColor, recon > | |
| Cquda::DomainWall5DLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| ►Cdouble2 | |
| Cquda::complex< double > | |
| Cdoubledouble | |
| Cdoubledouble2 | |
| Cdoubledouble3 | |
| Cdoublesingle | |
| Cdoublesingle2 | |
| Cdoublesingle3 | |
| Cquda::Dslash5Arg< Float, nColor > | Parameter structure for applying the Dslash |
| ►Cquda::DslashArg< Float > | |
| Cquda::CovDevArg< Float, nColor, reconstruct_ > | Parameter structure for driving the covariatnt derivative operator |
| Cquda::LaplaceArg< Float, nColor, reconstruct_ > | Parameter structure for driving the covariatnt derivative operator |
| Cquda::StaggeredArg< Float, nColor, reconstruct_u_, reconstruct_l_, improved_, phase_ > | Parameter structure for driving the Staggered Dslash operator |
| ►Cquda::WilsonArg< Float, nColor, reconstruct_ > | Parameter structure for driving the Wilson operator |
| Cquda::DomainWall4DArg< Float, nColor, reconstruct_ > | |
| Cquda::DomainWall5DArg< Float, nColor, reconstruct_ > | |
| Cquda::NdegTwistedMassArg< Float, nColor, reconstruct_ > | |
| Cquda::NdegTwistedMassArg< Float, nColor, reconstruct_ > | |
| Cquda::TwistedCloverArg< Float, nColor, reconstruct_, dynamic_clover_ > | |
| Cquda::TwistedMassArg< Float, nColor, reconstruct_ > | |
| Cquda::TwistedMassArg< Float, nColor, reconstruct_ > | |
| Cquda::WilsonCloverArg< Float, nColor, reconstruct_, twist_ > | |
| Cquda::WilsonCloverArg< Float, nColor, reconstruct_, twist_ > | |
| Cquda::DslashCoarseArg< Float, yFloat, ghostFloat, coarseSpin, coarseColor, csOrder, gOrder > | |
| Cquda::DslashCoarseLaunch | |
| Cquda::dslash::DslashCommsPattern | |
| Cquda::DslashConstant | Constants used by dslash and packing kernels |
| Cquda::dslash::DslashFactory< Dslash > | |
| CDslashParam | |
| ►Cquda::dslash::DslashPolicyImp< Dslash > | |
| Cquda::dslash::DslashAsync< Dslash > | |
| Cquda::dslash::DslashBasic< Dslash > | |
| Cquda::dslash::DslashFusedExterior< Dslash > | |
| Cquda::dslash::DslashFusedExteriorAsync< Dslash > | |
| Cquda::dslash::DslashFusedGDR< Dslash > | |
| Cquda::dslash::DslashFusedGDRRecv< Dslash > | |
| Cquda::dslash::DslashFusedZeroCopy< Dslash > | |
| Cquda::dslash::DslashFusedZeroCopyPack< Dslash > | |
| Cquda::dslash::DslashFusedZeroCopyPackGDRRecv< Dslash > | |
| Cquda::dslash::DslashGDR< Dslash > | |
| Cquda::dslash::DslashGDRRecv< Dslash > | |
| Cquda::dslash::DslashNC< Dslash > | |
| Cquda::dslash::DslashZeroCopy< Dslash > | |
| Cquda::dslash::DslashZeroCopyPack< Dslash > | |
| Cquda::dslash::DslashZeroCopyPackGDRRecv< Dslash > | |
| CDslashTime | |
| Cdsu3_matrix | |
| Cdsu3_vector | |
| Cquda::EigCGArgs | |
| ►Cquda::EigenSolver | |
| Cquda::TRLM | Thick Restarted Lanczos Method |
| Cquda::blas::detail::explode< rem, digits > | |
| ►Cquda::blas::detail::explode< num/10, num % 10 > | |
| Cquda::blas::num_to_string< num > | |
| Cquda::blas::num_to_string< num > | |
| Cquda::ExtractGhostArg< Float, nColor_, Order, nDim > | |
| Cquda::ExtractGhostExArg< Order, nDim, dim > | |
| Cfanti_hermitmat | |
| Cfcomplex | |
| Cfhalf_wilson_vector | |
| Cquda::clover::FieldOrder< Float, nColor, nSpin, order > | |
| Cquda::gauge::FieldOrder< Float, nColor, nSpinCoarse, order, native_ghost, storeFloat, use_tex > | |
| 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, use_tex > | |
| Cquda::colorspinor::FieldOrderCB< Float, coarseSpin, coarseColor, 1, csOrder, Float, ghostFloat > | |
| Cquda::colorspinor::FieldOrderCB< Float, coarseSpin, coarseColor, 1, order > | |
| Cquda::colorspinor::FieldOrderCB< Float, fineSpin, fineColor, 1, order > | |
| Cquda::colorspinor::FieldOrderCB< Float, fineSpin, fineColor, coarseColor, order, vFloat > | |
| Cquda::colorspinor::FieldOrderCB< real, Ns, Nc, 1, order > | |
| Cquda::fixedInvMaxValue< T > | |
| Cquda::fixedInvMaxValue< char > | |
| Cquda::fixedInvMaxValue< char2 > | |
| Cquda::fixedInvMaxValue< char4 > | |
| Cquda::fixedInvMaxValue< short > | |
| Cquda::fixedInvMaxValue< short2 > | |
| Cquda::fixedInvMaxValue< short4 > | |
| Cquda::fixedMaxValue< T > | |
| Cquda::fixedMaxValue< char > | |
| Cquda::fixedMaxValue< char2 > | |
| Cquda::fixedMaxValue< char4 > | |
| Cquda::fixedMaxValue< short > | |
| Cquda::fixedMaxValue< short2 > | |
| Cquda::fixedMaxValue< short4 > | |
| ►Cfloat2 | |
| Cquda::complex< float > | |
| Cquda::float4_precision_mapper< T > | |
| Cquda::float4_precision_mapper< char > | |
| Cquda::float4_precision_mapper< double > | |
| Cquda::float4_precision_mapper< short > | |
| Cquda::clover::FloatNOrder< Float, length, N, add_rho, huge_alloc > | Accessor routine for CloverFields in native field order |
| Cquda::gauge::FloatNOrder< Float, length, N, reconLenParam, stag_phase, huge_alloc, ghostExchange_, use_inphase > | |
| Cquda::colorspinor::FloatNOrder< Float, Ns, Nc, N, spin_project, huge_alloc > | Accessor routine for ColorSpinorFields in native field order |
| Cquda::FmunuArg< Float, Fmunu, Gauge > | |
| Cfsu3_matrix | |
| Cfsu3_vector | |
| Cquda::FullClover | |
| Cquda::GammaArg< Float, nColor > | Parameter structure for driving the Gamma operator |
| 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 > | |
| Cquda::gauge_mapper< char, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< char, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< char, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< char, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< char, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< char, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< double, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< float, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< Float, recon > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_mapper< short, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase > | |
| Cquda::gauge_order_mapper< T, order, Nc > | |
| Cquda::gauge_order_mapper< T, QUDA_BQCD_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 |
| Cquda::GaugeAPEArg< Float, GaugeOr, GaugeDs > | |
| Cquda::GaugeGaussArg< Float, recon, group_ > | |
| Cquda::GaugeOvrImpSTOUTArg< Float, GaugeOr, GaugeDs > | |
| Cquda::GaugeSTOUTArg< Float, GaugeOr, GaugeDs > | |
| Cquda::gauge::GhostAccessor< Float, nColor, order, native_ghost, storeFloat, use_tex > | |
| Cquda::gauge::GhostAccessor< Float, nColor, QUDA_FLOAT2_GAUGE_ORDER, native_ghost, storeFloat, use_tex > | |
| Cquda::gauge::GhostAccessor< Float, nColor, QUDA_MILC_GAUGE_ORDER, native_ghost, storeFloat, use_tex > | |
| Cquda::gauge::GhostAccessor< Float, nColor, QUDA_QDP_GAUGE_ORDER, native_ghost, storeFloat, use_tex > | |
| 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_SPACE_SPIN_COLOR_FIELD_ORDER > | |
| Cquda::colorspinor::GhostAccessorCB< ghostFloat, nSpin, nColor, nVec, order > | |
| Cquda::colorspinor::GhostAccessorCB< real, nSpin, nColor, nVec, order > | |
| Cquda::colorspinor::GhostAccessorCB< vFloat, nSpin, nColor, nVec, order > | |
| Cquda::GMResDRArgs | |
| 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::ImprovedStaggeredApply< Float, nColor, recon_l > | |
| ►Cint2 | |
| Cquda::complex< int > | |
| Cquda::Int2 | |
| Cint_fastdiv | |
| Cquda::is_variable< type > | |
| Cquda::is_variable< DSLASH5_MOBIUS > | |
| Cquda::is_variable< DSLASH5_MOBIUS_PRE > | |
| Cquda::is_variable< M5_INV_ZMOBIUS > | |
| Cquda::isFixed< T > | |
| Cquda::isFixed< char > | |
| Cquda::isFixed< char2 > | |
| Cquda::isFixed< char4 > | |
| Cquda::isFixed< short > | |
| Cquda::isFixed< short2 > | |
| Cquda::isFixed< short4 > | |
| Cquda::isHalf< T > | |
| Cquda::isHalf< short > | |
| Cquda::isHalf< short2 > | |
| Cquda::isHalf< short4 > | |
| Cquda::isQuarter< T > | |
| Cquda::isQuarter< char > | |
| Cquda::isQuarter< char2 > | |
| Cquda::isQuarter< char4 > | |
| Cquda::KSForceArg< Oprod, Gauge, Mom > | |
| Cquda::KSLongLinkArg< Result, Oprod, Gauge > | |
| Cquda::LaplaceApply< Float, nColor, recon > | |
| Cquda::LaplaceLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| ►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 | |
| CLoadStore< Real > | |
| CLocator< oddBit > | |
| Cquda::mapper< typename > | |
| Cquda::mapper< char > | |
| Cquda::mapper< char2 > | |
| Cquda::mapper< char4 > | |
| Cquda::mapper< double > | |
| Cquda::mapper< double2 > | |
| Cquda::mapper< double4 > | |
| Cquda::mapper< float > | |
| Cquda::mapper< Float > | |
| Cquda::mapper< float2 > | |
| Cquda::mapper< float4 > | |
| Cquda::mapper< short > | |
| Cquda::mapper< short2 > | |
| Cquda::mapper< short4 > | |
| Cquda::Matrix< T, N > | |
| CMatrix< N, T > | |
| Cquda::matrix_field< T, n > | |
| Cquda::matrix_field< complex< real >, nSpin > | |
| Cquda::MemAlloc | |
| 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::blas::MultiBlasArg< NXZ, SpinorX, SpinorY, SpinorZ, SpinorW, Functor > | Parameter struct for generic multi-blas kernel |
| ►Cquda::blas::MultiBlasFunctor< NXZ, Float2, FloatN > | |
| Cquda::blas::multi_axpyBzpcx_< NXZ, Float2, FloatN > | |
| Cquda::blas::multi_caxpyBxpz_< NXZ, Float2, FloatN > | |
| Cquda::blas::multicaxpy_< NXZ, Float2, FloatN > | |
| Cquda::blas::multicaxpyz_< NXZ, Float2, FloatN > | |
| Cquda::multigrid_solver | |
| ►Cquda::blas::MultiReduceFunctor< NXZ, ReduceType, Float2, FloatN > | |
| Cquda::blas::Cdot< NXZ, ReduceType, Float2, FloatN > | |
| Cquda::blas::CdotCopy< NXZ, ReduceType, Float2, FloatN > | |
| Cquda::blas::Dot< NXZ, ReduceType, Float2, FloatN > | |
| ►Cquda::MultiShiftSolver | |
| Cquda::MultiShiftCG | Multi-Shift Conjugate Gradient Solver |
| Cquda::NdegTwistedMassApply< Float, nColor, recon > | |
| Cquda::NdegTwistedMassLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::NdegTwistedMassPreconditionedApply< Float, nColor, recon > | |
| Cquda::NdegTwistedMassPreconditionedLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::non_native_precision_mapper< typename > | |
| Cquda::non_native_precision_mapper< char > | |
| Cquda::non_native_precision_mapper< double > | |
| Cquda::non_native_precision_mapper< float > | |
| Cquda::non_native_precision_mapper< short > | |
| Cquda::NonRelBasis< Arg > | |
| Cquda::NonRelToChiralBasis< Arg > | |
| Cquda::norm_type< T > | |
| Cquda::norm_type< complex< T > > | |
| Cquda::normal< Real > | |
| Cquda::normal< double > | |
| Cquda::normal< float > | |
| ►Cquda::Object | |
| ►Cquda::Dirac | |
| ►Cquda::DiracCoarse | |
| Cquda::DiracCoarsePC | |
| ►Cquda::DiracImprovedStaggered | |
| Cquda::DiracImprovedStaggeredPC | |
| ►Cquda::DiracStaggered | |
| Cquda::DiracStaggeredPC | |
| ►Cquda::DiracWilson | |
| ►Cquda::DiracClover | |
| Cquda::DiracCloverPC | |
| ►Cquda::DiracDomainWall | |
| ►Cquda::DiracDomainWall4D | |
| Cquda::DiracDomainWall4DPC | |
| Cquda::DiracDomainWallPC | |
| ►Cquda::DiracMobius | |
| 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::PackArg< Float_, nColor_, nSpin_, spin_project_ > | |
| Cquda::PackGhostArg< Field > | |
| Cquda::colorspinor::PaddedSpaceSpinorColorOrder< Float, Ns, Nc > | |
| CPathCoefficients< Real > | |
| Cquda::precision_spin_color_mapper< T, G, nSpin, nColor_ > | |
| Cquda::precision_spin_color_mapper< double, double, 1, nColor_ > | |
| Cquda::precision_spin_color_mapper< double, double, 2, nColor_ > | |
| Cquda::precision_spin_color_mapper< double, double, 4, nColor_ > | |
| Cquda::precision_spin_color_mapper< float, char, 4, nColor_ > | |
| Cquda::precision_spin_color_mapper< float, short, 4, nColor_ > | |
| Cquda::precision_spin_color_mapper< T, G, 1, nColor_ > | |
| Cquda::PreserveBasis< Arg > | |
| Cquda::ProjectSU3Arg< Float, G > | |
| 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< float, complex< float > > | |
| Cquda::PromoteTypeId< float, double > | |
| Cquda::PromoteTypeId< float, int > | |
| Cquda::PromoteTypeId< int, double > | |
| Cquda::PromoteTypeId< int, float > | |
| Cquda::colorspinor::QDPJITDiracOrder< Float, Ns, Nc > | |
| Cquda::clover::QDPJITOrder< Float, length > | |
| Cquda::clover::QDPOrder< Float, length > | |
| CQUDA_DiracField | |
| CQUDA_DiracFieldParam_s | |
| CQudaEigArgs_t | |
| CQudaEigParam_s | |
| CQudaFatLinkArgs_t | |
| CQudaGaugeParam_s | |
| CQudaHisqParams_t | |
| CQudaInitArgs_t | |
| CQudaInvertArgs_t | |
| CQudaInvertParam_s | |
| CQudaLayout_t | |
| CQudaMILCSiteArg_t | |
| CQudaMultigridParam_s | |
| Cquda::RealType< T > | |
| Cquda::RealType< char > | |
| Cquda::RealType< char2 > | |
| Cquda::RealType< char4 > | |
| Cquda::RealType< complex< char > > | |
| Cquda::RealType< complex< double > > | |
| Cquda::RealType< complex< float > > | |
| Cquda::RealType< complex< short > > | |
| Cquda::RealType< double > | |
| Cquda::RealType< double2 > | |
| Cquda::RealType< float > | |
| Cquda::RealType< float2 > | |
| Cquda::RealType< float4 > | |
| Cquda::RealType< short > | |
| Cquda::RealType< short2 > | |
| Cquda::RealType< short4 > | |
| Cquda::gauge::Reconstruct< N, Float, ghostExchange_, QudaStaggeredPhase > | Generic reconstruction helper with no reconstruction |
| 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, ghostExchange_, stag_phase > | |
| Cquda::reduce_vector< T > | |
| Cquda::ReduceArg< T > | |
| ►Cquda::ReduceArg< double > | |
| Cquda::QChargeArg< Float, Gauge, density_ > | |
| ►Cquda::ReduceArg< double2 > | |
| Cquda::CloverInvertArg< Float > | |
| Cquda::GaugePlaqArg< Gauge > | |
| ►Cquda::ReduceArg< ReduceType > | |
| Cquda::blas::ReductionArg< ReduceType, SpinorX, SpinorY, SpinorZ, SpinorW, SpinorV, Reducer > | |
| ►Cquda::ReduceArg< vector_type< ReduceType, NXZ > > | |
| Cquda::blas::MultiReduceArg< NXZ, ReduceType, SpinorX, SpinorY, SpinorZ, SpinorW, Reducer > | Parameter struct for generic multi-blas kernel |
| ►Cquda::blas::ReduceFunctor< ReduceType, Float2, FloatN > | |
| Cquda::blas::axpbyzNorm2< ReduceType, Float2, FloatN > | |
| Cquda::blas::axpyCGNorm2< ReduceType, Float2, FloatN > | |
| Cquda::blas::AxpyReDot< ReduceType, Float2, FloatN > | |
| Cquda::blas::cabxpyzaxnorm< ReduceType, Float2, FloatN > | |
| Cquda::blas::caxpbypzYmbwcDotProductUYNormY_< ReduceType, Float2, FloatN > | |
| Cquda::blas::caxpydotzy< ReduceType, Float2, FloatN > | |
| Cquda::blas::caxpyNorm2< ReduceType, Float2, FloatN > | |
| Cquda::blas::caxpyxmaznormx< ReduceType, Float2, FloatN > | |
| Cquda::blas::Cdot< NXZ, ReduceType, Float2, FloatN > | |
| Cquda::blas::CdotNormA< ReduceType, Float2, FloatN > | |
| Cquda::blas::Dot< NXZ, ReduceType, Float2, FloatN > | |
| Cquda::blas::doubleCG3InitNorm_< ReduceType, Float2, FloatN > | |
| Cquda::blas::doubleCG3UpdateNorm_< ReduceType, Float2, FloatN > | |
| Cquda::blas::HeavyQuarkResidualNorm_< ReduceType, Float2, FloatN > | |
| Cquda::blas::Norm1< ReduceType, Float2, FloatN > | |
| Cquda::blas::Norm2< ReduceType, Float2, FloatN > | |
| Cquda::blas::quadrupleCG3InitNorm_< ReduceType, Float2, FloatN > | |
| Cquda::blas::quadrupleCG3UpdateNorm_< ReduceType, Float2, FloatN > | |
| Cquda::blas::quadrupleCGReduction_< ReduceType, Float2, FloatN > | |
| Cquda::blas::tripleCGReduction_< ReduceType, Float2, FloatN > | |
| Cquda::blas::xpyHeavyQuarkResidualNorm_< ReduceType, Float2, FloatN > | |
| Cquda::RelBasis< Arg > | |
| Cquda::RestrictArg< Float, vFloat, fineSpin, fineColor, coarseSpin, coarseColor, order > | |
| Cquda::RNG | Class declaration to initialize and hold CURAND RNG states |
| Cquda::rngArg | |
| 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< char > | |
| Cquda::scalar< char2 > | |
| Cquda::scalar< char3 > | |
| Cquda::scalar< char4 > | |
| Cquda::scalar< double > | |
| Cquda::scalar< double2 > | |
| Cquda::scalar< double3 > | |
| Cquda::scalar< double4 > | |
| Cquda::scalar< float > | |
| Cquda::scalar< float2 > | |
| Cquda::scalar< Float2 > | |
| Cquda::scalar< float3 > | |
| Cquda::scalar< float4 > | |
| Cquda::scalar< short > | |
| Cquda::scalar< short2 > | |
| Cquda::scalar< short3 > | |
| Cquda::scalar< short4 > | |
| Cquda::SharedMemory< T > | |
| Cquda::ShiftColorSpinorFieldArg< Output, Input > | |
| ►Cshort2 | |
| Cquda::complex< short > | |
| CSign< N > | |
| CSign< 1 > | |
| ►Cquda::Solver | |
| Cquda::BiCGstab | |
| Cquda::BiCGstabL | |
| ►Cquda::CACG | Communication-avoiding CG solver. This solver does un-preconditioned CG, running in steps of nKrylov, build up a polynomial in the linear operator of length nKrylov, 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 nKrylov, 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::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::spin_mapper< fineSpin, coarseSpin > | |
| Cquda::spin_order_mapper< nSpin, order_ > | |
| Cquda::spin_order_mapper< 1, QUDA_FLOAT4_FIELD_ORDER > | |
| Cquda::spin_order_mapper< 2, QUDA_FLOAT4_FIELD_ORDER > | |
| ►CSpinorTexture< RegType, StoreType, N > | |
| CSpinor< RegType, StoreType, N, write > | |
| Cquda::clover::square_< ReduceType, Float > | |
| Cquda::colorspinor::square_< ReduceType, Float > | |
| Cquda::gauge::square_< ReduceType, Float > | |
| Cquda::colorspinor::square_< ReduceType, char > | |
| Cquda::gauge::square_< ReduceType, char > | |
| Cquda::gauge::square_< ReduceType, int > | |
| Cquda::colorspinor::square_< ReduceType, short > | |
| Cquda::gauge::square_< ReduceType, short > | |
| Cquda::StaggeredApply< Float, nColor, recon_u > | |
| Cquda::StaggeredLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | |
| Cquda::StaggeredReconstruct | |
| Csu3_matrix< real > | |
| Csu3_vector< real > | |
| ►CTest | |
| CGaugeAlgTest | |
| ►CTestWithParam | |
| CBlasTest | |
| CContractionTest | |
| CDslashTest | |
| CStaggeredDslashTest | |
| CTexture< OutputType, InputType > | |
| CTexture< InterType, StoreType > | |
| Cquda::TexVectorType< Float, number > | |
| Cquda::TexVectorType< char, 1 > | |
| Cquda::TexVectorType< char, 2 > | |
| Cquda::TexVectorType< char, 4 > | |
| Cquda::TexVectorType< double, 1 > | |
| Cquda::TexVectorType< double, 2 > | |
| Cquda::TexVectorType< float, 1 > | |
| Cquda::TexVectorType< float, 2 > | |
| Cquda::TexVectorType< float, 4 > | |
| Cquda::TexVectorType< short, 1 > | |
| Cquda::TexVectorType< short, 2 > | |
| Cquda::TexVectorType< short, 4 > | |
| Cthrust_allocator | |
| Cquda::TimeProfile | |
| Cquda::Timer | |
| Cquda::blas::detail::to_chars< digits > | |
| ►Cquda::blas::detail::to_chars< digits... > | |
| Cquda::blas::detail::explode< 0, digits... > | |
| Cquda::blas::detail::explode< 0, digits... > | |
| CTopology_s | |
| Cquda::TraceKey | |
| Cquda::Transfer | |
| Cquda::Trig< isFixed, T > | |
| Cquda::Trig< false, float > | |
| Cquda::Trig< true, float > | |
| ►Cquda::Tunable | |
| Cquda::blas::BlasCuda< FloatN, M, SpinorX, SpinorY, SpinorZ, SpinorW, SpinorV, Functor > | |
| Cquda::blas::copy_ns::CopyCuda< FloatN, N, Output, Input > | |
| Cquda::blas::MultiReduceCuda< NXZ, doubleN, ReduceType, FloatN, M, SpinorX, SpinorY, SpinorZ, SpinorW, Reducer > | |
| Cquda::blas::ReduceCuda< doubleN, ReduceType, FloatN, M, SpinorX, SpinorY, SpinorZ, SpinorW, SpinorV, Reducer > | |
| Cquda::blas::TileSizeTune< ReducerDiagonal, writeDiagonal, ReducerOffDiagonal, writeOffDiagonal > | |
| Cquda::CopyGaugeEx< FloatOut, FloatIn, length, OutOrder, InOrder > | |
| Cquda::CopySpinor< FloatOut, FloatIn, Ns, Nc, OutOrder, InOrder > | |
| Cquda::CopySpinorEx< FloatOut, FloatIn, Ns, Nc, OutOrder, InOrder, Basis, extend > | |
| Cquda::dslash::DslashPolicyTune< Dslash > | |
| Cquda::DslashCoarsePolicyTune | |
| Cquda::ExtractGhostEx< Float, length, nDim, dim, Order > | |
| Cquda::KSForceComplete< Float, Oprod, Gauge, Mom > | |
| Cquda::KSLongLinkForce< Float, Result, Oprod, Gauge > | |
| Cquda::QudaMemCopy | |
| Cquda::ShiftColorSpinorField< Output, Input > | |
| ►Cquda::TunableLocalParity | |
| Cquda::GaugePlaq< Float, Gauge > | |
| ►Cquda::TunableVectorY | |
| Cquda::blas::MultiBlas< NXZ, FloatN, M, SpinorX, SpinorY, SpinorZ, SpinorW, Functor, T > | |
| Cquda::Clover< Float, nSpin, nColor, Arg > | |
| Cquda::CopyColorSpinor< Ns, Arg > | |
| Cquda::CopyColorSpinor< 4, Arg > | |
| Cquda::Gamma< ValueType, basis, dir > | |
| Cquda::GaugeGauss< Float, Arg > | |
| Cquda::SpinorNoise< real, Ns, Nc, type, Arg > | |
| ►Cquda::TunableVectorYZ | |
| Cquda::CalculateY< from_coarse, Float, fineSpin, fineColor, coarseSpin, coarseColor, Arg > | |
| Cquda::CopyGauge< FloatOut, FloatIn, length, Arg > | |
| ►Cquda::Dslash< Float > | |
| Cquda::DomainWall4D< Float, nDim, nColor, Arg > | |
| Cquda::DomainWall5D< Float, nDim, nColor, Arg > | |
| Cquda::Laplace< Float, nDim, nColor, Arg > | |
| Cquda::NdegTwistedMass< Float, nDim, nColor, Arg > | |
| Cquda::NdegTwistedMassPreconditioned< Float, nDim, nColor, Arg > | |
| Cquda::Staggered< Float, nDim, nColor, Arg > | |
| Cquda::Staggered< Float, nDim, nColor, Arg > | |
| Cquda::TwistedClover< Float, nDim, nColor, Arg > | |
| Cquda::TwistedCloverPreconditioned< Float, nDim, nColor, Arg > | |
| Cquda::TwistedMass< Float, nDim, nColor, Arg > | |
| Cquda::TwistedMassPreconditioned< Float, nDim, nColor, Arg > | |
| Cquda::Wilson< Float, nDim, nColor, Arg > | |
| Cquda::WilsonClover< Float, nDim, nColor, Arg > | |
| Cquda::WilsonCloverPreconditioned< Float, nDim, nColor, Arg > | |
| Cquda::Dslash5< Float, nColor, Arg > | |
| Cquda::ExtractGhost< nDim, Arg > | |
| Cquda::GaugeOvrImpSTOUT< Float, Arg > | |
| Cquda::GenericPackGhostLauncher< Float, block_float, Ns, Ms, Nc, Mc, Arg > | |
| Cquda::Pack< Float, nColor, spin_project > | |
| Cquda::ProjectSU3< Float, G > | |
| Cquda::TwistClover< Float, nSpin, nColor, Arg > | |
| Cquda::TwistGamma< Float, nColor, Arg > | |
| Cquda::WuppertalSmearing< Float, Ns, Nc, Arg > | |
| ►CTunable | |
| ►CDslashCuda | |
| CSharedDslashCuda | |
| Cquda::TuneKey | |
| Cquda::TuneParam | |
| Cquda::TwistedCloverApply< Float, nColor, recon > | |
| Cquda::TwistedCloverLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::TwistedCloverPreconditionedApply< Float, nColor, recon > | |
| Cquda::TwistedCloverPreconditionedLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::TwistedMassApply< Float, nColor, recon > | |
| Cquda::TwistedMassLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::TwistedMassPreconditionedApply< Float, nColor, recon > | |
| Cquda::TwistedMassPreconditionedLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cuint32_char2 | |
| Cuint32_short2 | |
| Cquda::uniform< Real > | |
| Cquda::uniform< double > | |
| Cquda::uniform< float > | |
| Cquda::vec_length< typename > | |
| Cquda::vec_length< char > | |
| Cquda::vec_length< char2 > | |
| Cquda::vec_length< char4 > | |
| Cquda::vec_length< double > | |
| Cquda::vec_length< double2 > | |
| Cquda::vec_length< double4 > | |
| Cquda::vec_length< float > | |
| Cquda::vec_length< float2 > | |
| Cquda::vec_length< float4 > | |
| Cquda::vec_length< short > | |
| Cquda::vec_length< short2 > | |
| Cquda::vec_length< short4 > | |
| Cquda::vector< typename, N > | |
| Cquda::vector< double, 2 > | |
| Cquda::vector< float, 2 > | |
| Cquda::vector< int, 2 > | |
| Cquda::vector_type< scalar, n > | |
| Cquda::vector_type< ReduceType, NXZ > | |
| Cquda::VectorCache< real, Vector > | Class which wraps around a shared memory cache for a Vector type, where each thread in the thread block stores a unique Vector in the cache which any other thread can access. Presently, the expectation is that Vector is synonymous with the ColorSpinor class, but we could extend this to apply to the Matrix class as well |
| Cquda::VectorType< Float, number > | |
| Cquda::VectorType< char, 1 > | |
| Cquda::VectorType< char, 2 > | |
| Cquda::VectorType< char, 4 > | |
| Cquda::VectorType< double, 1 > | |
| Cquda::VectorType< double, 2 > | |
| Cquda::VectorType< double, 4 > | |
| Cquda::VectorType< float, 1 > | |
| Cquda::VectorType< float, 2 > | |
| Cquda::VectorType< float, 4 > | |
| Cquda::VectorType< short, 1 > | |
| Cquda::VectorType< short, 2 > | |
| Cquda::VectorType< short, 4 > | |
| Cquda::WilsonApply< Float, nColor, recon > | |
| Cquda::WilsonCloverApply< Float, nColor, recon > | |
| Cquda::WilsonCloverLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::WilsonCloverPreconditionedApply< Float, nColor, recon > | |
| Cquda::WilsonCloverPreconditionedLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::WilsonLaunch< Float, nDim, nColor, nParity, dagger, xpay, kernel_type, Arg > | This is a helper class that is used to instantiate the correct templated kernel for the dslash |
| Cquda::WilsonReconstruct | |
| ►Cquda::Worker | |
| Cquda::BiCGstabLUpdate | |
| Cquda::ShiftUpdate | |
| Cquda::blas::write< writeX, writeY, writeZ, writeW > | |
| Cquda::WuppertalSmearingArg< Float, Ns, Nc, gRecon > | |
| Cquda::Zero< T > | |
| CZero< N, T > | |
1.8.13
