A | B | C | D | E | F | G | H | I | L | M | N | O | P | Q | R | S | T | U | V | W | X | Z

A: abs_ (quda::colorspinor); abs_ (quda::clover); abs_ (quda::gauge); abs_< Float, int > (quda::gauge); abs_< Float, int8_t > (quda::colorspinor); abs_< Float, int8_t > (quda::gauge); abs_< Float, short > (quda::colorspinor); abs_< Float, short > (quda::gauge); Accessor (quda::clover); Accessor (quda::gauge); Accessor< Float, nColor, nSpin, QUDA_FLOAT2_CLOVER_ORDER > (quda::clover); Accessor< Float, nColor, nSpin, QUDA_FLOAT4_CLOVER_ORDER > (quda::clover); Accessor< Float, nColor, nSpin, QUDA_PACKED_CLOVER_ORDER > (quda::clover); Accessor< Float, nColor, QUDA_FLOAT2_GAUGE_ORDER, storeFloat > (quda::gauge); Accessor< Float, nColor, QUDA_MILC_GAUGE_ORDER, storeFloat > (quda::gauge); Accessor< Float, nColor, QUDA_QDP_GAUGE_ORDER, storeFloat > (quda::gauge); AccessorCB (quda::colorspinor); AccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT2_FIELD_ORDER > (quda::colorspinor); AccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT4_FIELD_ORDER > (quda::colorspinor); AccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT8_FIELD_ORDER > (quda::colorspinor); AccessorCB< Float, nSpin, nColor, nVec, QUDA_SPACE_SPIN_COLOR_FIELD_ORDER > (quda::colorspinor); AddReference (testing::internal); AddReference< T & > (testing::internal); address_constants (trove::detail); affine_modular_fn (trove::detail); aliased_size (detail); aliased_size (trove::detail); AllocType (quda); AllocType< false > (quda); AllocType< true > (quda); array (detail); array (trove); Array (quda); array< T, 0 > (detail); array< T, 0 > (trove); array< T, 1 > (detail); array< T, 1 > (trove); AssertHelper (testing::internal); atomic_type (quda); atomic_type< float > (quda)

B: BiCGstab (quda); BiCGstabL (quda); BiCGstabLUpdate (quda); BlasTest; BLASTest; BLKTRLM (quda); bool_constant (testing::internal); BQCDOrder (quda::clover); BQCDOrder (quda::gauge); bridge_mapper (quda); bridge_mapper< double2, char2 > (quda); bridge_mapper< double2, char4 > (quda); bridge_mapper< double2, char8 > (quda); bridge_mapper< double2, double2 > (quda); bridge_mapper< double2, float2 > (quda); bridge_mapper< double2, float4 > (quda); bridge_mapper< double2, short2 > (quda); bridge_mapper< double2, short4 > (quda); bridge_mapper< double2, short8 > (quda); bridge_mapper< float2, char2 > (quda); bridge_mapper< float2, double2 > (quda); bridge_mapper< float2, float2 > (quda); bridge_mapper< float2, short2 > (quda); bridge_mapper< float4, char4 > (quda); bridge_mapper< float4, char8 > (quda); bridge_mapper< float4, double2 > (quda); bridge_mapper< float4, float4 > (quda); bridge_mapper< float4, short4 > (quda); bridge_mapper< float4, short8 > (quda); bridge_mapper< float8, char8 > (quda); bridge_mapper< float8, short8 > (quda)

C: c2r_compute_composite_offsets (trove::detail); c2r_compute_composite_offsets< array< int, 1 >, m, p > (trove::detail); c2r_compute_composite_offsets< array< int, s >, m, p > (trove::detail); c2r_compute_indices_impl (trove::detail); c2r_compute_indices_impl< Array, composite > (trove::detail); c2r_compute_indices_impl< Array, odd > (trove::detail); c2r_compute_indices_impl< Array, power_of_two > (trove::detail); c2r_compute_initial_offset (trove::detail); c2r_compute_initial_offset< m, odd > (trove::detail); c2r_compute_initial_offset< m, power_of_two > (trove::detail); c2r_compute_offsets_impl (trove::detail); c2r_compute_offsets_impl< array< int, 1 >, b, o > (trove::detail); c2r_compute_offsets_impl< array< int, s >, b, o > (trove::detail); c2r_offset_constants (trove::detail); c2r_offset_constants< m, composite > (trove::detail); c2r_offset_constants< m, odd > (trove::detail); c2r_offset_constants< m, power_of_two > (trove::detail); c2r_warp_transpose_impl (trove::detail); c2r_warp_transpose_impl< Array, Indices, composite > (trove::detail); c2r_warp_transpose_impl< Array, Indices, odd > (trove::detail); c2r_warp_transpose_impl< Array, Indices, power_of_two > (trove::detail); CACG (quda); CACGNE (quda); CACGNR (quda); CAGCR (quda); CartesianProductGenerator (testing::internal); CartesianProductHolder (testing::internal); CG (quda); CG3 (quda); CG3NE (quda); CG3NR (quda); CGNE (quda); CGNR (quda); char8 (quda); clover_mapper (quda); clover_mapper< double, N, add_rho > (quda); clover_mapper< float, N, add_rho > (quda); clover_mapper< int8_t, N, add_rho > (quda); clover_mapper< short, N, add_rho > (quda); clover_wrapper (quda); CloverField (quda); CloverFieldParam (quda); coalesced_ptr (trove); coalesced_ref (trove::detail); CodeLocation (testing::internal); ColorMatrix; ColorSpinor (quda); ColorSpinor< Float, Nc, 2 > (quda); ColorSpinor< Float, Nc, 4 > (quda); colorspinor_ghost_wrapper (quda); colorspinor_mapper (quda); colorspinor_mapper< double, 1, Nc, false, huge_alloc > (quda); colorspinor_mapper< double, 2, Nc, false, huge_alloc > (quda); colorspinor_mapper< double, 4, Nc, false, huge_alloc > (quda); colorspinor_mapper< double, 4, Nc, true, huge_alloc > (quda); colorspinor_mapper< float, 1, Nc, false, huge_alloc > (quda); colorspinor_mapper< float, 2, Nc, false, huge_alloc > (quda); colorspinor_mapper< float, 4, Nc, false, huge_alloc > (quda); colorspinor_mapper< float, 4, Nc, true, huge_alloc > (quda); colorspinor_mapper< int8_t, 1, Nc, false, huge_alloc > (quda); colorspinor_mapper< int8_t, 2, Nc, false, huge_alloc > (quda); colorspinor_mapper< int8_t, 4, Nc, false, huge_alloc > (quda); colorspinor_mapper< int8_t, 4, Nc, true, huge_alloc > (quda); colorspinor_mapper< short, 1, Nc, false, huge_alloc > (quda); colorspinor_mapper< short, 2, Nc, false, huge_alloc > (quda); colorspinor_mapper< short, 4, Nc, false, huge_alloc > (quda); colorspinor_mapper< short, 4, Nc, true, huge_alloc > (quda); colorspinor_order_mapper (quda); colorspinor_order_mapper< T, QUDA_FLOAT2_FIELD_ORDER, Ns, Nc > (quda); colorspinor_order_mapper< T, QUDA_SPACE_COLOR_SPIN_FIELD_ORDER, Ns, Nc > (quda); colorspinor_order_mapper< T, QUDA_SPACE_SPIN_COLOR_FIELD_ORDER, Ns, Nc > (quda); colorspinor_wrapper (quda); ColorSpinorField (quda); ColorSpinorParam (quda); CommKey (quda); Communicator; CompileAssertTypesEqual (testing::internal); CompileAssertTypesEqual< T, T > (testing::internal); complex (quda); complex< double > (quda); complex< float > (quda); complex< int > (quda); complex< int8_t > (quda); complex< short > (quda); composite (trove::detail); composite_c2r_permute_fn (trove::detail); composite_r2c_permute_fn (trove::detail); CompositeColorSpinorFieldDescriptor (quda); cons_c (trove); ConstCharPtr (testing::internal); ConstRef (testing::internal); ConstRef< T & > (testing::internal); ContractionTest; counting_array (trove); counting_array< array< T, 1 > > (trove); counting_array< array< T, s > > (trove); CPSOrder (quda::gauge); cpuCloverField (quda); cpuColorSpinorField (quda); cpuGaugeField (quda); cudaCloverField (quda); cudaColorSpinorField (quda); cudaGaugeField (quda)

D: danti_hermitmat; dcomplex; deflated_solver (quda); Deflation (quda); deflation_space (quda); DeflationParam (quda); dhalf_wilson_vector; Dirac (quda); DiracClover (quda); DiracCloverHasenbuschTwist (quda); DiracCloverHasenbuschTwistPC (quda); DiracCloverPC (quda); DiracCoarse (quda); DiracCoarsePC (quda); DiracDagger (quda); DiracDomainWall (quda); DiracDomainWall4D (quda); DiracDomainWall4DPC (quda); DiracDomainWallPC (quda); DiracG5M (quda); DiracImprovedStaggered (quda); DiracImprovedStaggeredKD (quda); DiracImprovedStaggeredPC (quda); DiracM (quda); DiracMatrix (quda); DiracMdag (quda); DiracMdagM (quda); DiracMdagMLocal (quda); DiracMMdag (quda); DiracMobius (quda); DiracMobiusEofa (quda); DiracMobiusEofaPC (quda); DiracMobiusPC (quda); DiracParam (quda); DiracStaggered (quda); DiracStaggeredKD (quda); DiracStaggeredPC (quda); DiracTwistedClover (quda); DiracTwistedCloverPC (quda); DiracTwistedMass (quda); DiracTwistedMassPC (quda); DiracWilson (quda); DiracWilsonPC (quda); dismember (detail); dismember (trove::detail); dismember< T, U, 1 > (detail); dismember< T, U, 1 > (trove::detail); dismember_type (trove::detail); dismember_type< T, true, false, false > (trove::detail); dismember_type< T, true, true, false > (trove::detail); dismember_type< T, true, true, true > (trove::detail); divergent_loader (trove::detail); divergent_loader< 1, T > (trove::detail); divergent_storer (trove::detail); divergent_storer< 1, T > (trove::detail); double8 (quda); doubledouble; doubledouble2; doubledouble3; DoubleSequence (testing::internal); DoubleSequence< false, IndexSequence< I... >, sizeofT > (testing::internal); DoubleSequence< true, IndexSequence< I... >, sizeofT > (testing::internal); doublesingle; doublesingle2; doublesingle3; Dslash (quda); DslashConstant (quda); DslashTest; DslashTestWrapper; DslashTime; dsu3_matrix; dsu3_vector

F: faketype (testing::internal); fanti_hermitmat; fcomplex; fhalf_wilson_vector; FieldOrder (quda::clover); FieldOrder (quda::gauge); fieldorder_wrapper (quda::colorspinor); fieldorder_wrapper (quda::gauge); FieldOrderCB (quda::colorspinor); fixedInvMaxValue (quda); fixedInvMaxValue< char2 > (quda); fixedInvMaxValue< char4 > (quda); fixedInvMaxValue< char8 > (quda); fixedInvMaxValue< int8_t > (quda); fixedInvMaxValue< short > (quda); fixedInvMaxValue< short2 > (quda); fixedInvMaxValue< short4 > (quda); fixedInvMaxValue< short8 > (quda); fixedMaxValue (quda); fixedMaxValue< char2 > (quda); fixedMaxValue< char4 > (quda); fixedMaxValue< char8 > (quda); fixedMaxValue< int8_t > (quda); fixedMaxValue< short > (quda); fixedMaxValue< short2 > (quda); fixedMaxValue< short4 > (quda); fixedMaxValue< short8 > (quda); FlatTuple (testing::internal); FlatTupleBase (testing::internal); FlatTupleBase< FlatTuple< T... >, IndexSequence< Idx... > > (testing::internal); FlatTupleElemBase (testing::internal); FlatTupleElemBase< FlatTuple< T... >, I > (testing::internal); float8 (quda); FloatingPoint (testing::internal); FloatNOrder (quda::clover); FloatNOrder (quda::colorspinor); FloatNOrder (quda::gauge); FormatForComparison (testing::internal); FormatForComparison< ToPrint[N], OtherOperand > (testing::internal); fsu3_matrix; fsu3_vector; FullClover (quda)

G: gauge_ghost_wrapper (quda); gauge_mapper (quda); gauge_mapper< double, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< double, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< double, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< double, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< double, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< double, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< float, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< float, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< float, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< float, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< float, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< float, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< int8_t, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< int8_t, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< int8_t, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< int8_t, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< int8_t, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< int8_t, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< short, QUDA_RECONSTRUCT_10, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< short, QUDA_RECONSTRUCT_12, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< short, QUDA_RECONSTRUCT_13, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< short, QUDA_RECONSTRUCT_8, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< short, QUDA_RECONSTRUCT_9, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< short, QUDA_RECONSTRUCT_NO, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_NATIVE_GAUGE_ORDER > (quda); gauge_mapper< T, recon, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_MILC_GAUGE_ORDER > (quda); gauge_mapper< T, recon, N, stag, huge_alloc, ghostExchange, use_inphase, QUDA_QDP_GAUGE_ORDER > (quda); gauge_order_mapper (quda); gauge_order_mapper< T, QUDA_BQCD_GAUGE_ORDER, Nc > (quda); gauge_order_mapper< T, QUDA_CPS_WILSON_GAUGE_ORDER, Nc > (quda); gauge_order_mapper< T, QUDA_FLOAT2_GAUGE_ORDER, Nc > (quda); gauge_order_mapper< T, QUDA_MILC_GAUGE_ORDER, Nc > (quda); gauge_order_mapper< T, QUDA_QDP_GAUGE_ORDER, Nc > (quda); gauge_order_mapper< T, QUDA_QDPJIT_GAUGE_ORDER, Nc > (quda); gauge_order_mapper< T, QUDA_TIFR_GAUGE_ORDER, Nc > (quda); gauge_order_mapper< T, QUDA_TIFR_PADDED_GAUGE_ORDER, Nc > (quda); gauge_wrapper (quda); GaugeAlgTest; GaugeCovDev (quda); GaugeField (quda); GaugeFieldParam (quda); GaugeLaplace (quda); GaugeLaplacePC (quda); GCR (quda); get_impl (detail); get_impl (trove::detail); get_impl< T, m, 0 > (detail); get_impl< T, m, 0 > (trove::detail); GhostAccessor (quda::gauge); GhostAccessor< Float, nColor, QUDA_FLOAT2_GAUGE_ORDER, native_ghost, storeFloat > (quda::gauge); GhostAccessor< Float, nColor, QUDA_MILC_GAUGE_ORDER, native_ghost, storeFloat > (quda::gauge); GhostAccessor< Float, nColor, QUDA_QDP_GAUGE_ORDER, native_ghost, storeFloat > (quda::gauge); GhostAccessorCB (quda::colorspinor); GhostAccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT2_FIELD_ORDER > (quda::colorspinor); GhostAccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT4_FIELD_ORDER > (quda::colorspinor); GhostAccessorCB< Float, nSpin, nColor, nVec, QUDA_FLOAT8_FIELD_ORDER > (quda::colorspinor); GhostAccessorCB< Float, nSpin, nColor, nVec, QUDA_SPACE_SPIN_COLOR_FIELD_ORDER > (quda::colorspinor); GMResDR (quda); GMResDRArgs (quda); GTestLog (testing::internal); GTestMutexLock (testing::internal)

H: HMatrix (quda); HMatrix_wrapper (quda)

I: identity (quda); Identity; Identity (quda); IgnoredValue (testing::internal); IncEigCG (quda); indexed_load (trove::detail); indexed_load< 1, T > (trove::detail); indexed_store (trove::detail); indexed_store< 1, T > (trove::detail); IndexSequence (testing::internal); instantiateApply (quda); instantiateApply< false, Apply, Float, nColor, recon, G, Args... > (quda); instantiateReconstruct (quda); instantiateReconstruct< Apply, Float, nColor, Recon, 0, G, Args... > (quda); Int2 (quda); int_fastdiv; inverse (trove); IRAM (quda); is_odd (trove); is_power_of_two (trove); is_same (testing::internal); is_same< T, T > (testing::internal); IsAProtocolMessage (testing::internal); isFixed (quda); isFixed< char2 > (quda); isFixed< char4 > (quda); isFixed< char8 > (quda); isFixed< int8_t > (quda); isFixed< short > (quda); isFixed< short2 > (quda); isFixed< short4 > (quda); isFixed< short8 > (quda); isHalf (quda); isHalf< short > (quda); isHalf< short2 > (quda); isHalf< short4 > (quda); isHalf< short8 > (quda); IsHashTable (testing::internal); isQuarter (quda); isQuarter< char2 > (quda); isQuarter< char4 > (quda); isQuarter< char8 > (quda); isQuarter< int8_t > (quda); IsRecursiveContainer (testing::internal); IsRecursiveContainerImpl (testing::internal); IsRecursiveContainerImpl< C, false > (testing::internal); IsRecursiveContainerImpl< C, true > (testing::internal); IsSame (testing::internal); IsSame< T, T > (testing::internal); IteratorTraits (testing::internal); IteratorTraits< const T * > (testing::internal); IteratorTraits< T * > (testing::internal)

L: LatticeField (quda); LatticeFieldParam (quda); LegacyOrder (quda::gauge); less_significant (quda); LexMapData; load_storage (detail); load_storage< T, U, 1 > (detail); LoadStore; Locator

M: make_array_impl (trove::detail); make_array_impl< T, 1 > (trove::detail); make_carray_impl (trove::detail); make_carray_impl< T, 1 > (trove::detail); MakeIndexSequence (testing::internal); MakeIndexSequence< 0 > (testing::internal); mapper (quda); mapper< char2 > (quda); mapper< char4 > (quda); mapper< char8 > (quda); mapper< double > (quda); mapper< double2 > (quda); mapper< double4 > (quda); mapper< double8 > (quda); mapper< float > (quda); mapper< float2 > (quda); mapper< float4 > (quda); mapper< float8 > (quda); mapper< int8_t > (quda); mapper< short > (quda); mapper< short2 > (quda); mapper< short4 > (quda); mapper< short8 > (quda); Matrix (quda); Matrix; matrix_field (quda); maximum (quda); MemAlloc (quda); Message (testing); MG (quda); mgInputStruct; MGParam (quda); milcMultigridPack; MILCOrder (quda::gauge); MILCSiteOrder (quda::gauge); minimum (quda); MinResExt (quda); MPBiCGstab (quda); MPCG (quda); MR (quda); MsgHandle_s; multigrid_solver (quda); MultiShiftCG (quda); MultiShiftSolver (quda); Mutex (testing::internal)

N: NativeArray (testing::internal); norm_type (quda); norm_type< complex< T > > (quda); normal (quda); normal< double > (quda); normal< float > (quda); null_type (trove)

O: Object (quda); odd (trove::detail)

P: PaddedSpaceSpinorColorOrder (quda::colorspinor); ParameterizedTestFactory (testing::internal); ParameterizedTestSuiteInfo (testing::internal); ParameterizedTestSuiteInfoBase (testing::internal); ParameterizedTestSuiteRegistry (testing::internal); ParamGenerator (testing::internal); ParamGeneratorInterface (testing::internal); ParamIterator (testing::internal); ParamIteratorInterface (testing::internal); PathCoefficients; plus (quda); power_of_two (trove::detail); PreconCG (quda); PreconditionedSolver (quda); PrintToStringParamName (testing); Promote; Promote< double, float >; Promote< double, int >; Promote< double, std::complex< double > >; Promote< float, double >; Promote< float, int >; Promote< float, std::complex< double > >; Promote< float, std::complex< float > >; Promote< int, double >; Promote< int, float >; Promote< int, std::complex< double > >; Promote< int, std::complex< float > >; Promote< std::complex< double >, double >; Promote< std::complex< double >, float >; Promote< std::complex< double >, int >; Promote< std::complex< float >, int >; PromoteTypeId (quda); PromoteTypeId< complex< double >, double > (quda); PromoteTypeId< complex< float >, float > (quda); PromoteTypeId< double, complex< double > > (quda); PromoteTypeId< double, float > (quda); PromoteTypeId< double, int > (quda); PromoteTypeId< double, int8_t > (quda); PromoteTypeId< double, short > (quda); PromoteTypeId< float, complex< float > > (quda); PromoteTypeId< float, double > (quda); PromoteTypeId< float, int > (quda); PromoteTypeId< float, int8_t > (quda); PromoteTypeId< float, short > (quda); PromoteTypeId< int, double > (quda); PromoteTypeId< int, float > (quda); PromoteTypeId< int8_t, double > (quda); PromoteTypeId< int8_t, float > (quda); PromoteTypeId< int8_t, short > (quda); PromoteTypeId< short, double > (quda); PromoteTypeId< short, float > (quda); PromoteTypeId< short, int8_t > (quda)

R: r2c_compute_composite_offsets (trove::detail); r2c_compute_composite_offsets< array< int, 1 >, m > (trove::detail); r2c_compute_composite_offsets< array< int, s >, m > (trove::detail); r2c_compute_indices_impl (trove::detail); r2c_compute_indices_impl< Array, composite > (trove::detail); r2c_compute_indices_impl< Array, odd > (trove::detail); r2c_compute_indices_impl< Array, power_of_two > (trove::detail); r2c_compute_initial_offset (trove::detail); r2c_compute_initial_offset< m, odd > (trove::detail); r2c_compute_offsets_impl (trove::detail); r2c_compute_offsets_impl< array< int, 1 >, index, m, odd > (trove::detail); r2c_compute_offsets_impl< array< int, 1 >, index, m, power_of_two > (trove::detail); r2c_compute_offsets_impl< array< int, s >, index, m, odd > (trove::detail); r2c_compute_offsets_impl< array< int, s >, index, m, power_of_two > (trove::detail); r2c_offset_constants (trove::detail); r2c_offset_constants< m, odd > (trove::detail); r2c_offset_constants< m, power_of_two > (trove::detail); r2c_offsets (trove::detail); r2c_warp_transpose_impl (trove::detail); r2c_warp_transpose_impl< Array, Indices, composite > (trove::detail); r2c_warp_transpose_impl< Array, Indices, odd > (trove::detail); r2c_warp_transpose_impl< Array, Indices, power_of_two > (trove::detail); Random (testing::internal); RangeGenerator (testing::internal); RE (testing::internal); RealType (quda); RealType< char2 > (quda); RealType< char4 > (quda); RealType< complex< double > > (quda); RealType< complex< float > > (quda); RealType< complex< int8_t > > (quda); RealType< complex< short > > (quda); RealType< double > (quda); RealType< double2 > (quda); RealType< float > (quda); RealType< float2 > (quda); RealType< float4 > (quda); RealType< int8_t > (quda); RealType< short > (quda); RealType< short2 > (quda); RealType< short4 > (quda); Reconstruct (quda::gauge); Reconstruct10 (quda); Reconstruct< 11, Float, ghostExchange_ > (quda::gauge); Reconstruct< 12, Float, ghostExchange_ > (quda::gauge); Reconstruct< 13, Float, ghostExchange_, stag_phase > (quda::gauge); Reconstruct< 8, Float, ghostExchange_ > (quda::gauge); Reconstruct< 9, Float, ghostExchange_, stag_phase > (quda::gauge); ReconstructFull (quda); ReconstructMom (quda); ReconstructNo12 (quda); ReconstructNone (quda); ReconstructStaggered (quda); ReconstructWilson (quda); ReduceArg (quda); RelationToSourceCopy (testing::internal); RelationToSourceReference (testing::internal); remember (detail); remember (trove::detail); remember< T, U, 1 > (detail); remember< T, U, 1 > (trove::detail); RemoveConst (testing::internal); RemoveConst< const T > (testing::internal); RemoveConst< const T[N]> (testing::internal); RemoveReference (testing::internal); RemoveReference< T & > (testing::internal); RNG (quda); rotate_elements (trove::detail); rotate_elements_helper (trove::detail); rotate_elements_helper< Array, i, j, false > (trove::detail); rotate_impl (trove::detail); rotate_impl_helper (trove::detail); rotate_impl_helper< Array, i, false > (trove::detail)

S: S (quda::colorspinor); S (quda::clover); S (quda::gauge); scalar (quda); scalar< char2 > (quda); scalar< char3 > (quda); scalar< char4 > (quda); scalar< char8 > (quda); scalar< complex< double > > (quda); scalar< complex< float > > (quda); scalar< double > (quda); scalar< double2 > (quda); scalar< double3 > (quda); scalar< double4 > (quda); scalar< double8 > (quda); scalar< float > (quda); scalar< float2 > (quda); scalar< float3 > (quda); scalar< float4 > (quda); scalar< float8 > (quda); scalar< int8_t > (quda); scalar< short > (quda); scalar< short2 > (quda); scalar< short3 > (quda); scalar< short4 > (quda); scalar< short8 > (quda); ScopedTrace (testing); SD (quda); ShiftUpdate (quda); short8 (quda); shuffle (detail); shuffle< 1 > (detail); shuffle_down (detail); shuffle_down< 1 > (detail); shuffle_up (detail); shuffle_up< 1 > (detail); shuffle_xor (detail); shuffle_xor< 1 > (detail); Sign; Sign< 1 >; SimpleBiCGstab (quda); size_in_range (trove::detail); size_multiple_power_of_two (detail); size_multiple_power_of_two (trove); Solver (quda); SolverParam (quda); SortedEvals (quda); SpaceColorSpinorOrder (quda::colorspinor); SpaceSpinorColorOrder (quda::colorspinor); square_ (quda::clover); square_ (quda::colorspinor); square_ (quda::gauge); square_< ReduceType, int > (quda::gauge); square_< ReduceType, int8_t > (quda::gauge); square_< ReduceType, int8_t > (quda::colorspinor); square_< ReduceType, short > (quda::colorspinor); square_< ReduceType, short > (quda::gauge); StaggeredDslashTest; StaggeredDslashTestWrapper; StaggeredReconstruct (quda); static_gcd (trove); static_gcd< 0, v > (trove); static_gcd< u, 0 > (trove); static_gcd_helper (trove::detail); static_gcd_helper< false, true, u, v > (trove::detail); static_gcd_helper< true, false, u, v > (trove::detail); static_gcd_helper< true, true, u, v > (trove::detail); static_log (trove); static_log< 0 > (trove); static_log< 1 > (trove); static_mod_inverse (trove); static_mod_inverse_helper (trove); static_mod_inverse_helper< false, a, m, r > (trove); static_range (trove); static_range< f, f > (trove); StaticAssertTypeEqHelper (testing::internal); StaticAssertTypeEqHelper< T, T > (testing::internal); String (testing::internal); su3_matrix; su3_vector; SuiteApiResolver (testing::internal); sum_array (trove); sum_array< array< T, 1 > > (trove); sum_array< array< T, s > > (trove)

T: Test (testing); TestEventListener (testing); TestEventListeners (testing); TestFactoryBase (testing::internal); TestFactoryImpl (testing::internal); TestInfo (testing); TestMetaFactory (testing::internal); TestMetaFactoryBase (testing::internal); TestParamInfo (testing); TestProperty (testing); TestResult (testing); TestSuite (testing); TestWithParam (testing); ThreadLocal (testing::internal); TIFROrder (quda::gauge); TIFRPaddedOrder (quda::gauge); TimeProfile (quda); Timer (quda); Topology_s; TraceKey (quda); Transfer (quda); TransformReduce (quda); TransformReduceArg (quda); Trig (quda); Trig< false, float > (quda); Trig< true, float > (quda); TRLM (quda); Tunable (quda); TunableLocalParityReduction (quda); TunableVectorY (quda); TunableVectorYZ (quda); TuneKey (quda); TuneParam (quda); tx_algorithm (trove::detail); tx_algorithm< m, false, true > (trove::detail); tx_algorithm< m, true, false > (trove::detail); tx_permute_impl (trove::detail); tx_permute_impl< array< T, 1 >, Permute, position > (trove::detail); tx_permute_impl< array< T, s >, Permute, position > (trove::detail); TypeIdHelper (testing::internal); TypeWithoutFormatter (testing::internal2); TypeWithoutFormatter< T, kConvertibleToInteger > (testing::internal2); TypeWithoutFormatter< T, kProtobuf > (testing::internal2); TypeWithSize (testing::internal); TypeWithSize< 4 > (testing::internal); TypeWithSize< 8 > (testing::internal)

V: value_identity (trove); value_if (trove); value_if< false, T, Then, Else > (trove); ValueArray (testing::internal); ValuesInIteratorRangeGenerator (testing::internal); vec_length (quda); vec_length< char2 > (quda); vec_length< char3 > (quda); vec_length< char4 > (quda); vec_length< char8 > (quda); vec_length< Complex > (quda); vec_length< complex< double > > (quda); vec_length< complex< float > > (quda); vec_length< complex< int8_t > > (quda); vec_length< complex< short > > (quda); vec_length< double > (quda); vec_length< double2 > (quda); vec_length< double3 > (quda); vec_length< double4 > (quda); vec_length< double8 > (quda); vec_length< float > (quda); vec_length< float2 > (quda); vec_length< float3 > (quda); vec_length< float4 > (quda); vec_length< float8 > (quda); vec_length< int8_t > (quda); vec_length< short > (quda); vec_length< short2 > (quda); vec_length< short3 > (quda); vec_length< short4 > (quda); vec_length< short8 > (quda); vector (quda); vector< double, 2 > (quda); vector< float, 2 > (quda); vector< int, 2 > (quda); vector_type (quda); VectorIO (quda); VectorType (quda); VectorType< double, 1 > (quda); VectorType< double, 2 > (quda); VectorType< double, 3 > (quda); VectorType< double, 4 > (quda); VectorType< double, 8 > (quda); VectorType< float, 1 > (quda); VectorType< float, 2 > (quda); VectorType< float, 3 > (quda); VectorType< float, 4 > (quda); VectorType< float, 8 > (quda); VectorType< int8_t, 1 > (quda); VectorType< int8_t, 2 > (quda); VectorType< int8_t, 3 > (quda); VectorType< int8_t, 4 > (quda); VectorType< int8_t, 8 > (quda); VectorType< short, 1 > (quda); VectorType< short, 2 > (quda); VectorType< short, 3 > (quda); VectorType< short, 4 > (quda); VectorType< short, 8 > (quda)

X: XSD (quda)

Z: Zero (quda); Zero