Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 CStokhos::AbstractPreconditionerFactoryAn abstract class to represent a generic preconditioner factory
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::acos_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::acos_quad_func
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::acos_quad_func
 CDerivExpansionUnitTest::ACosFunc
 CForUQTKExpansionUnitTest::ACosFunc
 CPseudoSpectralExpansionUnitTest::ACosFunc
 CQuadExpansionUnitTest::ACosFunc
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::acosh_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::acosh_quad_func
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::acosh_quad_func
 CAlgebraicExpansionUnitTest::ACoshFunc
 CConstantExpansionUnitTest::ACoshFunc
 CDerivExpansionUnitTest::ACoshFunc
 CForUQTKExpansionUnitTest::ACoshFunc
 CPseudoSpectralExpansionUnitTest::ACoshFunc
 CQuadExpansionUnitTest::ACoshFunc
 CStokhos::AdaptivityManager
 CAddDiagonalValuesAtomicKernel< MatrixType >
 CAddDiagonalValuesKernel< MatrixType >
 CStokhos::aligned_allocator< T >An aligned STL allocator
 CStokhos::aligned_allocator< const T >An aligned STL allocator
 Ccusp::precond::aggregation::amg_container< IndexType, ValueType, MemorySpace >
 Ccusp::precond::aggregation::amg_container< IndexType, ValueType, cusp::device_memory >
 Ccusp::precond::aggregation::amg_container< IndexType, ValueType, cusp::host_memory >
 CStokhos::AnisotropicTotalOrderIndexSet< ordinal_t >An anisotropic total order index set
 CStokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t >::apply< ord_t, val_t, dev_t >Turn StaticFixedStorage into a meta-function class usable with mpl::apply
 CStokhos::StaticStorage< ordinal_t, value_t, Num, device_t >::apply< ord_t, val_t, dev_t >Turn StaticStorage into a meta-function class usable with mpl::apply
 CStokhos::ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t >::apply< ord_t, val_t, dev_t >Turn ViewStorage into a meta-function class usable with mpl::apply
 CStokhos::StandardStorage< ordinal_type, value_type >::apply< ord_t, val_t >Turn StandardStorage into a meta-function class usable with mpl::apply
 CStokhos::StaticFixedStandardStorage< ordinal_type, value_type, Num >::apply< ord_t, val_t >Turn StaticFixedStandardStorage into a meta-function class usable with mpl::apply
 CStokhos::StaticStandardStorage< ordinal_type, value_type, Num >::apply< ord_t, val_t >Turn StaticStandardStorage into a meta-function class usable with mpl::apply
 CKokkos::Example::FENL::ExponentialKLCoefficient< Scalar, MeshScalar, Device >::apply< T1, T2, T3 >
 CStokhos::DynamicStorage< ordinal_t, value_t, device_t >::apply< ord_t, val_t, dev_t >Turn DynamicStorage into a meta-function class usable with mpl::apply
 CStokhos::DynamicStridedStorage< ordinal_t, value_t, device_t >::apply< ord_t, val_t, dev_t >Turn DynamicStridedStorage into a meta-function class usable with mpl::apply
 CStokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t >::apply_N< N >
 CStokhos::DynamicStorage< ordinal_t, value_t, device_t >::apply_N< N >
 CStokhos::Multiply< BlockCrsMatrix< LinearSparse3Tensor< TensorScalar, Kokkos::Cuda, BlockSize >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::ApplyKernelAsymmetric< MAX_COL >
 CStokhos::Multiply< BlockCrsMatrix< LinearSparse3Tensor< TensorScalar, Kokkos::Cuda, BlockSize >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::ApplyKernelSymmetric< MAX_COL >
 CApplyView< DataType, LayoutType, ExecutionSpace >
 CApplyView< DataType, NoLayout, ExecutionSpace >
 CKokkos::Details::ArithTraits< Sacado::MP::Vector< S > >
 CKokkos::Details::ArithTraits< Sacado::UQ::PCE< S > >
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::asin_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::asin_quad_func
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::asin_quad_func
 CDerivExpansionUnitTest::ASinFunc
 CForUQTKExpansionUnitTest::ASinFunc
 CPseudoSpectralExpansionUnitTest::ASinFunc
 CQuadExpansionUnitTest::ASinFunc
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::asinh_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::asinh_quad_func
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::asinh_quad_func
 CAlgebraicExpansionUnitTest::ASinhFunc
 CConstantExpansionUnitTest::ASinhFunc
 CDerivExpansionUnitTest::ASinhFunc
 CForUQTKExpansionUnitTest::ASinhFunc
 CPseudoSpectralExpansionUnitTest::ASinhFunc
 CQuadExpansionUnitTest::ASinhFunc
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::atan2_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::atan2_quad_func
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::atan_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::atan_quad_func
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::atan_quad_func
 CDerivExpansionUnitTest::ATanFunc
 CForUQTKExpansionUnitTest::ATanFunc
 CPseudoSpectralExpansionUnitTest::ATanFunc
 CQuadExpansionUnitTest::ATanFunc
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::atanh_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::atanh_quad_func
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::atanh_quad_func
 CAlgebraicExpansionUnitTest::ATanhFunc
 CConstantExpansionUnitTest::ATanhFunc
 CDerivExpansionUnitTest::ATanhFunc
 CForUQTKExpansionUnitTest::ATanhFunc
 CPseudoSpectralExpansionUnitTest::ATanhFunc
 CQuadExpansionUnitTest::ATanhFunc
 CStokhos::BasisFactory< ordinal_type, value_type >Factory for building multivariate orthogonal polynomial bases
 CStokhos::BasisInteractionGraph
 CIfpack2::BelosScalarType< Sacado::PCE::OrthogPoly< T, S > >Specialization of BelosScalarType to PCE types
 Cbinary_function
 CStokhos::BlockCrsMatrix< BlockSpec, ValueType, Device >CRS matrix of dense blocks
 CBlockCrsMatrix
 CStokhos::MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > >::BlockKernel< BlockSize >
 CStokhos::BlockMultiply< BlockSpec >
 CStokhos::BlockMultiply< CooProductTensor< ValueType, Device, Pack > >
 CStokhos::BlockMultiply< CrsProductTensor< ValueType, Device > >
 CStokhos::BlockMultiply< FlatSparse3Tensor< ValueType, Device > >
 CStokhos::BlockMultiply< FlatSparse3Tensor_kji< ValueType, Device > >
 CStokhos::BlockMultiply< LexicographicBlockSparse3Tensor< ValueType, Device > >
 CStokhos::BlockMultiply< LinearSparse3Tensor< ValueType, Device, BlockSize > >
 CStokhos::BlockMultiply< SimpleTiledCrsProductTensor< ValueType, Device > >
 CStokhos::BlockMultiply< StochasticProductTensor< ValueType, TensorType, Device > >
 CStokhos::BlockMultiply< SymmetricDiagonalSpec< Device > >
 CStokhos::BlockMultiply< SymmetricDiagonalSpec< Kokkos::Cuda > >
 CStokhos::BlockMultiply< TiledCrsProductTensor< ValueType, Device > >
 CStokhos::RCB< TupleType >::Box
 CKokkos::Example::BoxElemFixture< Device, Order, CoordinateMap >Generate a distributed unstructured finite element mesh from a partitioned NX*NY*NZ box of elements
 CKokkos::Example::BoxElemPartPartition a box of hexahedral elements among subdomains
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::cbrt_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::cbrt_quad_func
 CDerivExpansionUnitTest::CbrtFunc
 CForUQTKExpansionUnitTest::CbrtFunc
 CPseudoSpectralExpansionUnitTest::CbrtFunc
 CQuadExpansionUnitTest::CbrtFunc
 CStokhos::ProductBasisUtils::Cijk_1D_Iterator< ordinal_type >
 CStokhos::CijkData< ordinal_type, scalar_type >
 CCijkData
 CStokhos::LTBSparse3Tensor< ordinal_type, value_type >::CijkNodeNode type used in constructing the tree
 CCijkNonzeros
 CStokhos::CrsProductTensor< ValueType, ExecutionSpace, Memory >::CijkRowCount
 CKokkos::CijkType< view_type, Enabled >
 CKokkos::CijkType< ViewType, typename std::enable_if< is_view_uq_pce< ViewType >::value >::type >
 CStokhos::CrsProductTensor< ValueType, ExecutionSpace, Memory >::CompareCijkRowCount
 CStokhos::CompletePolynomialBasisUtils< ordinal_type, value_type >Utilities for indexing a multi-variate complete polynomial basis
 CCompObject
 CSacado::Fad::ConstExpr< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > > >Constant expression template
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, true >::ConstructDestructFunctor< ExecSpace >
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, false >::ConstructDestructFunctor< ExecSpace >
 CKokkos::Experimental::Impl::PCEAllocation< ValueType >::ConstructDestructFunctor< ExecSpace >
 CStokhos::Multiply< BlockCrsMatrix< CooProductTensor< TensorScalar, Kokkos::Cuda, Pack >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::CooKernel
 CStokhos::CooProductTensor< ValueType, ExecutionSpace, PackIndex >Sparse product tensor using 'COO'-like storage format
 CStokhos::CooProductTensor< ValueType, ExecutionSpace, false >Specialization of CooProductTensor for unpacked (i,j,k)
 CStokhos::CooProductTensor< ValueType, ExecutionSpace, true >Specialization of CooProductTensor for packed (i,j,k)
 CStokhos::SimpleTiledCrsProductTensor< ValueType, ExecutionSpace >::Coord
 CCoord
 CStokhos::RCB< TupleType >::CoordCompare
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::cos_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::cos_quad_func
 CDerivExpansionUnitTest::CosFunc
 CForUQTKExpansionUnitTest::CosFunc
 CPseudoSpectralExpansionUnitTest::CosFunc
 CQuadExpansionUnitTest::CosFunc
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::cosh_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::cosh_quad_func
 CDerivExpansionUnitTest::CoshFunc
 CForUQTKExpansionUnitTest::CoshFunc
 CPseudoSpectralExpansionUnitTest::CoshFunc
 CQuadExpansionUnitTest::CoshFunc
 CCoupledSolver
 CAmesos2::create_mp_vector_solver_impl< ConcreteSolver, ST, LO, GO, NO >
 CKokkos::Example::FENL::CreateDeviceConfigs< ScalarType >
 CKokkos::Example::FENL::CreateDeviceConfigs< Sacado::MP::Vector< StorageType > >
 CKokkos::Example::FENL::CrsMatrix< ValueType, Space >
 CStokhos::CrsMatrix< ValueType, Device, Layout >CRS matrix
 CStokhos::CrsProductTensor< ValueType, ExecutionSpace, Memory >Sparse product tensor with replicated entries to provide subsets with a given coordinate
 CStokhos::CrsProductTensor< Value, Execution, Memory >
 CKokkos::Impl::ctor_prop_has_cijk< AllocProp >
 CKokkos::Impl::ctor_prop_has_cijk< ViewCtorProp< Stokhos::CrsProductTensor< Value, Execution, Memory > > >
 CKokkos::Impl::ctor_prop_has_cijk< ViewCtorProp< T > >
 CKokkos::Impl::ctor_prop_has_cijk< ViewCtorProp< T, P... > >
 CKokkos::Experimental::Impl::DeepCopyNonContiguous< OutputView, InputView >
 Ccusp::default_block_monitor< ValueType >
 CStokhos::DefaultMultiply
 CStokhos::DefaultPointCompare< ordinal_type, value_type >Struct defining default point compare type
 CStokhos::Dense3Tensor< ordinal_type, value_type >Data structure storing a dense 3-tensor C(i,j,k)
 CStokhos::DenseOperator< ord_type, val_type >
 CKokkos::Example::FENL::DeviceConfig
 CStokhos::DeviceConfig
 CStokhos::DeviceForNode< Node >Trait class that determines (new) Kokkos execution space type from Kokkos(Classic) Node type
 CStokhos::DeviceForNode2< Node >
 CStokhos::DeviceForNode2< Kokkos::Compat::KokkosDeviceWrapperNode< Device > >
 CStokhos::DeviceProp
 CStokhos::DiagonalOperator< ord_type, val_type >
 CKokkos::Example::FENL::DeviceConfig::Dim3
 CStokhos::DeviceConfig::Dim3
 CKokkos::Example::FENL::DirichletComputation< FixtureType, SparseMatrixType >
 CKokkos::Example::FENL::DirichletComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, Kokkos::Example::FENL::CrsMatrix< ScalarType, ExecutionSpace > >
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::div_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::div_quad_func
 CAlgebraicExpansionUnitTest::DivideFunc
 CDerivExpansionUnitTest::DivideFunc
 CForUQTKExpansionUnitTest::DivideFunc
 CPseudoSpectralExpansionUnitTest::DivideFunc
 CQuadExpansionUnitTest::DivideFunc
 CStokhos::DivisionExpansionStrategy< ordinal_type, value_type, node_type >Strategy interface for computing PCE of a/b
 CSacado::ETPCE::DivisionOp< ExprT1, ExprT2 >
 CKokkosClassic::DotOp1< Sacado::PCE::OrthogPoly< ScalarType, StorageType > >
 CKokkosClassic::DotOp2< Sacado::PCE::OrthogPoly< ScalarType, StorageType > >
 CStokhos::ds_array< T, isScalar >Dynamic array allocation class that works for any type
 CStokhos::ds_array< T, true >Dynamic array allocation class that is specialized for scalar i.e., fundamental or built-in types (float, double, etc...)
 CStokhos::DynamicStorage< ordinal_t, value_t, device_t >
 CStokhos::DynamicStridedStorage< ordinal_t, value_t, device_t >
 CStokhos::DynamicThreadedStorage< ordinal_t, value_t, device_t >Dynamically allocated storage class with striding
 CStokhos::DynArrayTraits< T, device_t, isScalar >Dynamic array allocation class that is specialized for scalar i.e., fundamental or built-in types (float, double, etc...)
 CStokhos::DynArrayTraits< T, device_t, false >Dynamic array allocation class that works for any type
 CStokhos::KL::OneDExponentialCovarianceFunction< value_type >::EigFuncCosNonlinear function whose roots define eigenvalues for cos() eigenfunction
 CStokhos::KL::OneDExponentialCovarianceFunction< value_type >::EigFuncSinNonlinear function whose roots define eigenvalues for sin() eigenfunction
 CKokkos::Example::FENL::ElementComputation< FiniteElementMeshType, SparseMatrixType, Method, CoeffFunctionType >
 CKokkos::Example::FENL::ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, Kokkos::Example::FENL::CrsMatrix< ScalarType, ExecutionSpace >, CoeffFunctionType >
 CKokkos::Example::FENL::ElementComputationBase< ExecutionSpace, Order, CoordinateMap, ScalarType >
 CKokkos::Example::FENL::ElementComputationConstantCoefficient
 CEpetra_Operator
 CStokhos::EpetraCrsMatrixClonerCloner for Epetra_CrsMatrix coefficients
 CStokhos::EpetraMultiVectorClonerCloner for Epetra_MultiVector coefficients
 CStokhos::EpetraOperatorClonerCloner for Epetra_Operator coefficients
 CStokhos::EpetraSparse3Tensor
 CStokhos::EpetraVectorClonerCloner for Epetra_Vector coefficients
 CStokhos::error_storage_type_is_not_allocateable
 CStokhos::error_storage_type_is_not_resizeable
 Cexp_func
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::exp_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::exp_quad_func
 CStokhos::ExpansionFactory< ordinal_type, value_type >Factory for building multivariate expansion strategies
 CDerivExpansionUnitTest::ExpFunc
 CForUQTKExpansionUnitTest::ExpFunc
 CPseudoSpectralExpansionUnitTest::ExpFunc
 CQuadExpansionUnitTest::ExpFunc
 CKokkos::Example::FENL::ExponentialKLCoefficient< Scalar, MeshScalar, Device >
 CStokhos::KL::ExponentialOneDEigenFunction< Value >One-dimensional eigenfunction for exponential covariance function
 CStokhos::KL::ExponentialRandomField< value_type, execution_space >Class representing a KL expansion of an exponential random field
 CStokhos::KL::ExponentialRandomField< MeshScalar, Device >
 CSacado::MP::Expr< T >
 CSacado::ETPCE::Expr< T >
 CSacado::ETPCE::Expr< DivisionOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< DivisionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::ETPCE::Expr< DivisionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::ETPCE::Expr< MultiplicationOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< MultiplicationOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::ETPCE::Expr< MultiplicationOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::Fad::Expr< SFadExprTag< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num >, ExprSpecMPVector >Expression template forward-mode AD class with static memory allocation
 CSacado::ETPCE::ExprQuadFuncWrapper< NN, ExprT >
 CSacado::Fad::ExprSpec< DFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > > > >
 CSacado::Fad::ExprSpec< GeneralFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Storage > >
 CSacado::Fad::ExprSpec< SFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > >
 CSacado::Fad::ExprSpec< SFadExprTag< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > >
 CSacado::Fad::ExprSpec< SLFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > >
 CSacado::Fad::ExprSpec< ViewFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, length, stride, BaseFadT > >
 CSacado::Fad::ExprSpecMPVector
 Cfalse_type
 CKokkos::FlatArrayType< view_type, Enabled >
 CKokkos::FlatArrayType< View< D, P... >, typename std::enable_if< is_view_mp_vector< View< D, P... > >::value >::type >
 CKokkos::FlatArrayType< View< D, P... >, typename std::enable_if< is_view_uq_pce< View< D, P... > >::value >::type >
 CStokhos::FlatLTBSparse3Tensor< ordinal_type, value_type >
 CStokhos::FlatLTBSparse3TensorNode< ordinal_type >
 CStokhos::FlatSparse3Tensor< ValueType, ExecutionSpace >Sparse product tensor with replicated entries to provide subsets with a given coordinate
 CStokhos::FlatSparse3Tensor_kji< ValueType, ExecutionSpace >Sparse product tensor with replicated entries to provide subsets with a given coordinate
 CStokhos::FloatingPointLess< value_type >A functor for comparing floating-point numbers to some tolerance
 CStokhos::mpl::for_each< Seq, Iter1, Iter2 >
 CStokhos::mpl::for_each< Seq, Iter1, Iter1 >
 CGammaModel
 CProductBasisUtilsUnitTest::general_predicate< basis_set_type >
 CStokhos::GetMeanValsFunc< ViewType >Get mean values matrix for mean-based preconditioning
 CStokhos::GetMeanValsFunc< Kokkos::View< Sacado::MP::Vector< Storage > *, P... > >Get mean values matrix for mean-based preconditioning
 CStokhos::GetMeanValsFunc< Kokkos::View< Sacado::UQ::PCE< Storage > *, P... > >Get mean values matrix for mean-based preconditioning
 CKokkos::Impl::GetSacadoSize< Rank >
 CKokkos::Impl::GetSacadoSize< 0 >
 CKokkos::Impl::GetSacadoSize< 1 >
 CKokkos::Impl::GetSacadoSize< 2 >
 CKokkos::Impl::GetSacadoSize< 3 >
 CKokkos::Impl::GetSacadoSize< 4 >
 CKokkos::Impl::GetSacadoSize< 5 >
 CKokkos::Impl::GetSacadoSize< 6 >
 CKokkos::Impl::GetSacadoSize< 7 >
 CTeuchos::details::GivensRotator< Sacado::MP::Vector< Storage >, false >
 Cgram_schmidt_pce_binary_quad_func
 Cgram_schmidt_pce_unary_quad_func
 CGramSchmidt_PCE_Setup< OrdinalType, ValueType >
 CStokhos::GrowthRule< value_type >Interface for abstract growth rules
 CKokkos::Example::HexElement_Data< NodeCount >
 CKokkos::Example::HexElement_TensorData< NodeCount >
 CKokkos::Example::HexElement_TensorData< 27 >
 CKokkos::Example::HexElement_TensorData< 8 >Evaluate Hex element on interval [-1,1]^3
 CKokkos::Example::HexElement_TensorEval< NodeCount, Device >
 CKokkos::Details::InnerProductSpaceTraits< const Sacado::UQ::PCE< S > >
 CKokkos::Details::InnerProductSpaceTraits< Sacado::UQ::PCE< S > >
 CStokhos::IntegralRank< unsigned >
 CKokkos::IntrinsicScalarType< view_type, Enabled >
 CKokkos::IntrinsicScalarType< AV >
 CKokkos::IntrinsicScalarType< CMV >
 CKokkos::IntrinsicScalarType< CV >
 CKokkos::is_view_mp_vector< view_type >
 CKokkos::is_view_mp_vector< View< T, P... > >
 CKokkos::is_view_uq_pce< view_type >
 CKokkos::is_view_uq_pce< View< T, P... > >
 CKokkos::Experimental::Impl::is_ViewMPVectorContiguous< Args >
 CKokkos::Experimental::Impl::is_ViewMPVectorContiguous< Kokkos::View< D, P... >, Args... >
 CKokkos::Experimental::Impl::is_ViewPCEContiguous< Args >
 CKokkos::Experimental::Impl::is_ViewPCEContiguous< Kokkos::View< D, P... >, Args... >
 CStokhos::is_ViewStorage< Storage >
 CStokhos::is_ViewStorage< ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t > >
 CSacado::IsADType< ETPCE::Expr< T > >Specialization of IsADType to Expr types
 CSacado::IsADType< ETPCE::OrthogPoly< T, S > >Specialization of IsADType to OrthogPoly types
 CSacado::IsADType< MP::Expr< T > >Specialization of IsADType to Expr types
 CSacado::IsADType< MP::Vector< S > >Specialization of IsADType to Vector types
 CSacado::IsADType< PCE::OrthogPoly< T, S > >Specialization of IsADType to OrthogPoly types
 CSacado::IsADType< UQ::PCE< S > >Specialization of IsADType to PCE types
 CSacado::IsEqual< ETPCE::OrthogPoly< T, S > >Specialization of IsEqual to OrthogPoly types
 CSacado::IsEqual< MP::Vector< S > >Specialization of IsEqual to Vector types
 CSacado::IsEqual< PCE::OrthogPoly< T, S > >Specialization of IsEqual to OrthogPoly types
 CSacado::IsEqual< UQ::PCE< S > >Specialization of IsEqual to PCE types
 CStokhos::IsScalarType< T >Base template specification for IsScalarType
 CStokhos::IsScalarType2< T >Base template specification for IsScalarType
 CSacado::IsScalarType< ETPCE::Expr< T > >Specialization of IsADType to Expr types
 CSacado::IsScalarType< ETPCE::OrthogPoly< T, S > >Specialization of IsADType to OrthogPoly types
 CSacado::IsScalarType< MP::Expr< T > >Specialization of IsADType to Expr types
 CSacado::IsScalarType< MP::Vector< S > >Specialization of IsADType to Vector types
 CSacado::IsScalarType< PCE::OrthogPoly< T, S > >Specialization of IsADType to OrthogPoly types
 CSacado::IsScalarType< UQ::PCE< S > >Specialization of IsADType to PCE types
 CSacado::IsStaticallySized< ETPCE::OrthogPoly< T, S > >Specialization of IsStaticallySized to OrthogPoly types
 CSacado::IsStaticallySized< MP::Vector< S > >Specialization of IsStaticallySized to Vector types
 CSacado::IsStaticallySized< PCE::OrthogPoly< T, S > >Specialization of IsStaticallySized to OrthogPoly types
 CSacado::IsStaticallySized< UQ::PCE< S > >Specialization of IsStaticallySized to PCE types
 Citerator
 CStokhos::JacobiTester
 CStokhos::MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > >::Kernel
 CtwoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node >::KL_Diffusion_Func
 CKokkos_MV_Multiply_Op
 CStokhos::Lanczos< vectorspace_type, operator_type >Applies Lanczos procedure to a given matrix
 CLanczos_Cos_Func< Ordinal_Type, Value_Type >
 CLanczos_Exp_Func< Ordinal_Type, Value_Type >
 Clanczos_pce_quad_func
 CLanczos_PCE_Setup< Func >
 CLanczos_Sin_Func< Ordinal_Type, Value_Type >
 CTeuchos::LAPACKSpecialization for Sacado::UQ::PCE< Storage<...> >
 CTeuchos::LAPACK< int, double >
 CTeuchos::LAPACK< ordinal_type, value_type >
 CTeuchos::LAPACK< OrdinalType, Sacado::MP::Vector< Storage > >
 CTeuchos::LAPACK< OrdinalType, Sacado::UQ::PCE< Storage > >
 CBelos::Details::LapackSupportsScalar< S >
 CBelos::Details::LapackSupportsScalar< Sacado::MP::Vector< S > >
 Ccusp::block_multilevel< MatrixType, SmootherType, SolverType >::level
 CStokhos::LexicographicBlockSparse3Tensor< ValueType, ExecutionSpace >Sparse product tensor with replicated entries to provide subsets with a given coordinate
 CStokhos::LexicographicTreeBasisNode< ordinal_type >
 CStokhos::LexographicLess< term_type, compare_type >A comparison functor implementing a strict weak ordering based lexographic ordering
 Clinear_operator
 CStokhos::LinearSparse3Tensor< ValueType, ExecutionSpace, BlockSize >Sparse product tensor with replicated entries to provide subsets with a given coordinate
 CKokkos::LocalMPVectorView< ViewType, LocalSize, isStatic >
 CKokkos::LocalMPVectorView< View< D, P... >, LocalSize, true >
 CKokkos::LocalMPVectorView< ViewType, LocalSize, false >
 CIfpack2::Details::LocalReciprocalThreshold< XV, SizeType >
 CIfpack2::Details::LocalReciprocalThreshold< Kokkos::View< Sacado::MP::Vector< S > *, P... >, SizeType >
 CIfpack2::Details::LocalReciprocalThreshold< Kokkos::View< Sacado::UQ::PCE< S > *, P... >, SizeType >
 CKokkos::LocalUQPCEView< ViewType, LocalSize, Rank, isStatic >
 CKokkos::LocalUQPCEView< ViewType, LocalSize, 1, false >
 CKokkos::LocalUQPCEView< ViewType, LocalSize, 1, true >
 CKokkos::Example::FENL::LocalViewTraits< ViewType, Enabled >
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::log10_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::log10_quad_func
 CDerivExpansionUnitTest::Log10Func
 CForUQTKExpansionUnitTest::Log10Func
 CPseudoSpectralExpansionUnitTest::Log10Func
 CQuadExpansionUnitTest::Log10Func
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::log_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::log_quad_func
 CDerivExpansionUnitTest::LogFunc
 CPseudoSpectralExpansionUnitTest::LogFunc
 CQuadExpansionUnitTest::LogFunc
 CForUQTKExpansionUnitTest::LogFunc
 CtwoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node >::LogNormal_Diffusion_Func< DiffusionFunc >
 CStokhos::LTBSparse3Tensor< ordinal_type, value_type >Data structure storing a sparse 3-tensor C(i,j,k) in a a tree-based format for lexicographically ordered product bases
 CKokkos::Example::MapGridUnitCubeMap a grid onto a unit cube with smooth nonlinear grading of the map
 CStokhos::MatrixMarketWriter< MatrixType >
 CStokhos::MatrixMarketWriter< CrsMatrix< MatrixValue, Device, Layout > >
 CStokhos::MeanMultiply< MatrixType, InputViewType, OutputViewType >
 CStokhos::MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > **, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > **, OutputP... > >
 CStokhos::MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > >
 CStokhos::MemoryTraits< MemorySpace >Traits class encapsulting memory alignment
 CStokhos::MemoryTraits< Kokkos::HostSpace >Specialization of MemoryTraits for host memory spaces
 CtwoD_diffusion_ME::MeshPoint
 CtwoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node >::MeshPoint
 CAlgebraicExpansionUnitTest::MinusFunc
 CDerivExpansionUnitTest::MinusFunc
 CForUQTKExpansionUnitTest::MinusFunc
 CPseudoSpectralExpansionUnitTest::MinusFunc
 CQuadExpansionUnitTest::MinusFunc
 CModelEvaluator
 CStokhos::MortonZLess< term_type >A comparison functor implementing a strict weak ordering based Morton Z-ordering
 CStokhos::details::MPMultiply< Matrix, InputVector, OutputVector, Update, Enabled >
 CStokhos::details::MPMultiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > **, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > **, OutputP... >, Update >
 CStokhos::details::MPMultiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > *, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > *, OutputP... >, Update >
 CStokhos::MPPreconditionerFactoryFactory for generating stochastic Galerkin preconditioners
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, is_static >
 CKokkos::Experimental::Impl::MPVectorAllocation< sacado_mp_vector_type >
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, false >
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, true >
 CTeuchos::details::MPVectorArrayHelper< Storage >
 CTeuchos::details::MPVectorArrayHelper< Stokhos::DynamicStorage< Ordinal, Value, Device > >
 CTeuchos::details::MPVectorArrayHelper< Stokhos::StaticFixedStorage< Ordinal, Value, Num, Device > >
 CTest::MPVectorAtomicFunctor< ViewType >
 CKokkos::MPVectorWorkConfig< ExecSpace >Team-based parallel work configuration for Sacado::MP::Vector
 CStokhos::MultiIndex< ordinal_t >A multidimensional index
 CStokhos::MultiIndex< ordinal_type >
 CSacado::ETPCE::MultiplicationOp< ExprT1, ExprT2 >
 CStokhos::Multiply< MatrixType, InputVectorType, OutputVectorType, ColumnIndicesType, VectorRank, ImplTag >
 CStokhos::Multiply< BlockCrsMatrix< BlockSpec, MatrixValue, Device >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Device >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Device > >
 CStokhos::Multiply< BlockCrsMatrix< BlockSpec, MatrixValue, Kokkos::Cuda >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< CooProductTensor< TensorScalar, Kokkos::Cuda, Pack >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< FlatSparse3Tensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< FlatSparse3Tensor_kji< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< LexicographicBlockSparse3Tensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< LinearSparse3Tensor< TensorScalar, Kokkos::Cuda, BlockSize >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< SimpleTiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< StochasticProductTensor< TensorScalar, TensorType, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< BlockCrsMatrix< StochasticProductTensor< ValueType, CrsProductTensor< ValueType, Kokkos::OpenMP >, Kokkos::OpenMP >, MatrixValue, Kokkos::OpenMP >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::OpenMP >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::OpenMP > >
 CStokhos::Multiply< BlockCrsMatrix< StochasticProductTensor< ValueType, CrsProductTensor< ValueType, Kokkos::Serial >, Kokkos::Serial >, MatrixValue, Kokkos::Serial >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Serial >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Serial > >
 CStokhos::Multiply< BlockCrsMatrix< StochasticProductTensor< ValueType, CrsProductTensor< ValueType, Kokkos::Threads >, Kokkos::Threads >, MatrixValue, Kokkos::Threads >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Threads >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Threads > >
 CStokhos::Multiply< BlockCrsMatrix< TiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >
 CStokhos::Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputMultiVectorType, OutputMultiVectorType, std::vector< OrdinalType >, IntegralRank< 2 > >
 CStokhos::Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputMultiVectorType, OutputMultiVectorType, void, IntegralRank< 2 > >
 CStokhos::Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputVectorType, OutputVectorType, void, IntegralRank< 1 > >
 CStokhos::Multiply< CrsMatrix< MatrixValue, Device, Layout >, std::vector< InputViewType >, std::vector< OutputViewType >, void, IntegralRank< 1 > >
 CStokhos::Multiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > **, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > **, OutputP... > >
 CStokhos::Multiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > *, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > *, OutputP... > >
 CStokhos::Multiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > **, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > **, OutputP... > >
 CStokhos::Multiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > >
 CStokhos::details::MultiplyAssign
 CStokhos::MultiplyImpl< ValueType, MatrixValue, VectorValue, Device >
 CStokhos::Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::MultiplyKernel
 CStokhos::details::MultiplyScaledAssign< Value >
 CStokhos::details::MultiplyScaledUpdate< Value >
 CStokhos::details::MultiplyScaledUpdate2< Value >
 CStokhos::details::MultiplyUpdate
 CTpetra::MultiVector< S, L, G, N, bool >
 CBelos::MultiVecTraits< BaseScalar, Tpetra::MultiVector< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node > >Specialization of Tpetra MultiVecTraits for PCE scalar types
 CBelos::MultiVecTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::MP::Vector< Storage >, LO, GO, Node > >Partial specialization of MultiVecTraits for MV = Tpetra::MultiVector
 CBelos::MultiVecTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::UQ::PCE< Storage >, LO, GO, Node > >Partial specialization of MultiVecTraits for MV = Tpetra::MultiVector
 CKokkosBlas::Impl::MV_MultFunctor< Kokkos::View< Sacado::UQ::PCE< CS > **, CP... >, Kokkos::View< const Sacado::UQ::PCE< AS > *, AP... >, Kokkos::View< const Sacado::UQ::PCE< BS > **, BP... >, scalar_ab, scalar_c, SizeType >
 CKokkosBlas::Impl::MV_Reciprocal_Functor< Kokkos::View< Sacado::UQ::PCE< RS > **, RP... >, Kokkos::View< const Sacado::UQ::PCE< XS > **, XP... >, SizeType >
 CKokkosBlas::Impl::MV_ReciprocalSelf_Functor< Kokkos::View< Sacado::UQ::PCE< RS > **, RP... >, SizeType >
 CMyOptions
 CMyResults
 CNISPCoupledSolver
 CKokkos::Example::FENL::NodeNodeGraph< ElemNodeIdView, CrsGraphType, ElemNode >
 CNoLayout
 CNZCompare
 CNZPairCompare
 CObject
 CStokhos::KL::OneDEigenPair< eigen_function_type >Container for one-dimensional eigenfunction and eigenvalue
 CStokhos::KL::OneDExponentialCovarianceFunction< value_type >Class representing an exponential covariance function and its KL eigevalues/eigenfunctions
 CStokhos::OneDOrthogPolyBasis< ordinal_type, value_type >Abstract base class for 1-D orthogonal polynomials
 CStokhos::OneDOrthogPolyBasis< OrdinalType, ValueType >
 CStokhos::Operator< ordinal_type, value_type >
 CStokhos::Operator< ordinal_type, double >
 CBelos::OperatorTraits< BaseScalar, Tpetra::MultiVector< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node >, Tpetra::Operator< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node > >Partial specialization of OperatorTraits for Tpetra::Operator
 CBelos::OperatorTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::MP::Vector< Storage >, LO, GO, Node >, Tpetra::Operator< Sacado::MP::Vector< Storage >, LO, GO, Node > >Partial specialization of OperatorTraits for Tpetra::Operator
 CBelos::OperatorTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::UQ::PCE< Storage >, LO, GO, Node >, Tpetra::Operator< Sacado::UQ::PCE< Storage >, LO, GO, Node > >Partial specialization of OperatorTraits for Tpetra::Operator
 CStokhos::OrthogonalizationFactory< ordinal_type, value_type >Encapsulate various orthogonalization (ie QR) methods
 CSacado::PCE::OrthogPoly< T, S >
 CSacado::ETPCE::OrthogPoly< T, S >
 CSacado::PCE::OrthogPoly< double, Storage >
 CStokhos::OrthogPolyApprox< ordinal_type, value_type, storage_type >Class to store coefficients of a projection onto an orthogonal polynomial basis
 CStokhos::OrthogPolyApprox< int, double >
 CStokhos::OrthogPolyApprox< ordinal_type, value_type >
 CStokhos::OrthogPolyApprox< OrdinalType, ValueType >
 CStokhos::OrthogPolyBasis< ordinal_type, value_type >Abstract base class for multivariate orthogonal polynomials
 CStokhos::OrthogPolyBasis< int, double >
 CStokhos::OrthogPolyExpansion< ordinal_type, value_type, node_type >Abstract base class for orthogonal polynomial-based expansions
 CStokhos::OrthogPolyExpansion< ordinal_type, value_type >
 CStokhos::OrthogPolyExpansion< ordinal_type, value_type, Stokhos::StandardStorage< ordinal_type, value_type > >
 CTpetra::KokkosRefactor::Details::PackArrayMultiColumn< Kokkos::View< Sacado::MP::Vector< DS > *, DP... >, Kokkos::View< const Sacado::MP::Vector< SS > **, SP... >, IdxView >
 CTpetra::KokkosRefactor::Details::PackArrayMultiColumn< Kokkos::View< Sacado::UQ::PCE< DS > *, DP... >, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP... >, IdxView >
 CTpetra::KokkosRefactor::Details::PackArrayMultiColumnVariableStride< Kokkos::View< Sacado::MP::Vector< DS > *, DP... >, Kokkos::View< const Sacado::MP::Vector< SS > **, SP... >, IdxView, ColView >
 CTpetra::KokkosRefactor::Details::PackArrayMultiColumnVariableStride< Kokkos::View< Sacado::UQ::PCE< DS > *, DP... >, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP... >, IdxView, ColView >
 CTpetra::KokkosRefactor::Details::PackArraySingleColumn< Kokkos::View< Sacado::MP::Vector< DS > *, DP... >, Kokkos::View< const Sacado::MP::Vector< SS > **, SP... >, IdxView >
 CTpetra::KokkosRefactor::Details::PackArraySingleColumn< Kokkos::View< Sacado::UQ::PCE< DS > *, DP... >, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP... >, IdxView >
 CTpetra::Details::PackTraits< Sacado::UQ::PCE< S >, D >Partial specialization of PackTraits for Sacado's PCE UQ type
 CStokhos::ParallelData
 CSacado::UQ::PCE< S >
 Cpce_quad_func
 CKokkos::Experimental::Impl::PCEAllocation< ValueType >
 CKokkos::Experimental::Impl::PCEAllocation< sacado_uq_pce_type >
 CTeuchos::details::PCEArrayHelper< Storage >
 CTeuchos::details::PCEArrayHelper< Stokhos::DynamicStorage< Ordinal, Value, Device > >
 CTest::PCEAtomicFunctor< ViewType >
 CKokkos::Experimental::Impl::PCEAllocation< ValueType >::PCEConstruct< ExecSpace >
 CPerf
 Cunit_test::performance_test_driver< Scalar, Device >
 Cunit_test::performance_test_driver< Scalar, Kokkos::Cuda >
 CPerformanceDriverOp< Storage, Method >
 CTpetra::KokkosRefactor::Details::PermuteArrayMultiColumn< Kokkos::View< Sacado::MP::Vector< DS > **, DP... >, Kokkos::View< const Sacado::MP::Vector< SS > **, SP... >, DstIdxView, SrcIdxView >
 CTpetra::KokkosRefactor::Details::PermuteArrayMultiColumn< Kokkos::View< Sacado::UQ::PCE< DS > **, DP... >, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP... >, DstIdxView, SrcIdxView >
 CTpetra::KokkosRefactor::Details::PermuteArrayMultiColumnVariableStride< Kokkos::View< Sacado::MP::Vector< DS > **, DP... >, Kokkos::View< const Sacado::MP::Vector< SS > **, SP... >, DstIdxView, SrcIdxView, DstColView, SrcColView >
 CTpetra::KokkosRefactor::Details::PermuteArrayMultiColumnVariableStride< Kokkos::View< Sacado::UQ::PCE< DS > **, DP... >, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP... >, DstIdxView, SrcIdxView, DstColView, SrcColView >
 CAlgebraicExpansionUnitTest::PlusFunc
 CPseudoSpectralExpansionUnitTest::PlusFunc
 CQuadExpansionUnitTest::PlusFunc
 CDerivExpansionUnitTest::PlusFunc
 CForUQTKExpansionUnitTest::PlusFunc
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::pow_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::pow_quad_func
 CForUQTKExpansionUnitTest::PowFunc
 CPseudoSpectralExpansionUnitTest::PowFunc
 CQuadExpansionUnitTest::PowFunc
 CDerivExpansionUnitTest::PowFunc
 CStokhos::ProductBasisUtilsUtilities for indexing a multi-variate complete polynomial basis
 CStokhos::ProductContainer< coeff_type >A product (in the mathematical sense) container class whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor.
 CStokhos::ProductContainer< Epetra_MultiVector >
 CStokhos::ProductContainer< Epetra_Operator >
 CStokhos::ProductContainer< Epetra_Vector >
 CStokhos::ProductContainerTraits< coeff_type >Base traits definition for ProductContainer
 CStokhos::ProductContainerTraits< Epetra_CrsMatrix >Specialization of ProductContainerTraits to Epetra_CrsMatrix coefficients
 CStokhos::ProductContainerTraits< Epetra_MultiVector >Specialization of ProductContainerTraits to Epetra_MultiVector coefficients
 CStokhos::ProductContainerTraits< Epetra_Operator >Specialization of ProductContainerTraits to Epetra_Operator coefficients
 CStokhos::ProductContainerTraits< Epetra_Vector >Specialization of ProductContainerTraits to Epetra_Vector coefficients
 CStokhos::KL::ProductEigenPair< eigen_function_type, ExecutionSpace >Container for multi-dimensional product of 1-D eigenfunctions/values
 CStokhos::Multiply< BlockCrsMatrix< SimpleTiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::ProductTensorLoop
 CStokhos::Multiply< BlockCrsMatrix< TiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::ProductTensorLoop
 CStokhos::PseudoSpectralOperator< ordinal_t, value_t, point_compare_type >An operator interface for building pseudo-spectral approximations
 CStokhos::PseudoSpectralOperatorFactory< ordinal_type, value_type >Factory for building multivariate quadrature strategies
 CStokhos::Quadrature< ordinal_type, value_type >Abstract base class for quadrature methods
 CStokhos::QuadratureFactory< ordinal_type, value_type >Factory for building multivariate quadrature strategies
 CStokhos::RCB< TupleType >
 CStokhos::aligned_allocator< T >::rebind< U >
 CStokhos::aligned_allocator< const T >::rebind< U >
 CKokkos::Impl::RebindStokhosStorageDevice< T, Device >
 CKokkos::Impl::RebindStokhosStorageDevice< const Sacado::MP::Vector< OldStorageType >, Device >
 CKokkos::Impl::RebindStokhosStorageDevice< const Sacado::UQ::PCE< OldStorageType >, Device >
 CKokkos::Impl::RebindStokhosStorageDevice< Sacado::MP::Vector< OldStorageType >, Device >
 CKokkos::Impl::RebindStokhosStorageDevice< Sacado::UQ::PCE< OldStorageType >, Device >
 CKokkos::Impl::RebindStokhosStorageDevice< T *, Device >
 CKokkos::Impl::RebindStokhosStorageDevice< T [], Device >
 CKokkos::Impl::RebindStokhosStorageDevice< T[N], Device >
 CStokhos::ReducedBasisFactory< ordinal_type, value_type >Generate a basis from a given set of PCE expansions that is orthogonal with respect to the product measure induced by these expansions
 CStokhos::ReducedQuadratureFactory< ordinal_type, value_type >Generate a basis from a given set of PCE expansions that is orthogonal with respect to the product measure induced by these expansions
 CReplaceDiagonalValuesKernel< MatrixType >
 CKokkos::Example::FENL::ResponseComputation< FixtureType, VectorType >
 Creverse_iterator
 CRF< Value, Device >
 CRhoModel
 Cs_quad_func< Num >
 Ccusp::precond::aggregation::sa_level< MatrixType >
 CKokkos::Impl::ViewError::sacado_mp_vector_partition_constructor_requires_unmanaged_view
 CScalarTol< Scalar >
 CScalarTol< double >
 CScalarTol< float >
 Cunit_test::ScalarTolerances< Scalar >
 Cunit_test::ScalarTolerances< double >
 Cunit_test::ScalarTolerances< float >
 CSacado::ScalarType< ETPCE::Expr< T > >Specialization of ScalarType to Expr types
 CSacado::ScalarType< ETPCE::OrthogPoly< T, S > >Specialization of Promote to OrthogPoly types
 CSacado::ScalarType< MP::Expr< T > >Specialization of ScalarType to Expr types
 CSacado::ScalarType< MP::Vector< S > >Specialization of Promote to Vector types
 CSacado::ScalarType< PCE::OrthogPoly< T, S > >Specialization of Promote to OrthogPoly types
 CSacado::ScalarType< UQ::PCE< S > >Specialization of Promote to PCE types
 CSacado::ScalarValue< ETPCE::Expr< T > >Specialization of ScalarValue to Expr types
 CSacado::ScalarValue< ETPCE::OrthogPoly< T, S > >Specialization of ScalarValue to OrthogPoly types
 CSacado::ScalarValue< MP::Expr< T > >Specialization of ScalarValue to Expr types
 CSacado::ScalarValue< MP::Vector< S > >Specialization of ScalarValue to Vector types
 CSacado::ScalarValue< PCE::OrthogPoly< T, S > >Specialization of ScalarValue to OrthogPoly types
 CSacado::ScalarValue< UQ::PCE< S > >Specialization of ScalarValue to PCE types
 CSemiIntrusiveCoupledSolver
 CTeuchos::SerialQRDenseSolverSpecialization for Sacado::UQ::PCE< Storage<...> >
 CTeuchos::SerialQRDenseSolver< OrdinalType, BaseScalarType >
 CStokhos::SGOperatorFactoryFactory for generating stochastic Galerkin preconditioners
 CStokhos::SGPreconditionerFactoryFactory for generating stochastic Galerkin preconditioners
 CShape
 CStokhos::SimpleTiledCrsProductTensor< ValueType, ExecutionSpace >
 Csin_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sin_quad_func
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sin_quad_func
 CDerivExpansionUnitTest::SinFunc
 CQuadExpansionUnitTest::SinFunc
 CForUQTKExpansionUnitTest::SinFunc
 CPseudoSpectralExpansionUnitTest::SinFunc
 CStokhos::SingleColumnMultivectorMultiply
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sinh_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sinh_quad_func
 CForUQTKExpansionUnitTest::SinhFunc
 CDerivExpansionUnitTest::SinhFunc
 CPseudoSpectralExpansionUnitTest::SinhFunc
 CQuadExpansionUnitTest::SinhFunc
 CStokhos::SmolyakBasis< ordinal_type, value_type, coeff_compare_type >::SmolyakPredicate< tp_predicate_type >Predicate functor for building sparse triple products
 CStokhos::SmolyakBasis< ordinal_type, value_type, coeff_compare_type >::SmolyakPredicate< Stokhos::TensorProductPredicate< ordinal_type > >
 CSolver
 CAmesos2::solver_supports_scalar< ConcreteSolver, Sacado::MP::Vector< Storage > >
 CStokhos::Sparse3Tensor< ordinal_type, value_type >Data structure storing a sparse 3-tensor C(i,j,k) in a a compressed format
 CStokhos::Sparse3Tensor< int, double >
 CStokhos::AdaptivityManager::Sparse3TensorHash
 CStokhos::SparseArray< ordinal_type, val_type >Container for a "sparse" array
 CStokhos::SparseArray< int, ji_sparse_array >
 CStokhos::SparseArray< int, kj_sparse_array >
 CStokhos::SparseArray< ordinal_type, ji_sparse_array >
 CStokhos::SparseArray< ordinal_type, kj_sparse_array >
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sqrt_quad_func
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sqrt_quad_func
 CQuadExpansionUnitTest::SqrtFunc
 CPseudoSpectralExpansionUnitTest::SqrtFunc
 CDerivExpansionUnitTest::SqrtFunc
 CForUQTKExpansionUnitTest::SqrtFunc
 CStokhos::StandardStorage< ordinal_type, value_type >
 CStokhos::StandardStorage< int, double >
 CStokhos::StaticArrayTraits< T, device, isScalar >Static array allocation class
 CStokhos::StaticArrayTraits< T, D, false >Static array allocation class that works for any type
 CStokhos::StaticArrayTraits< T, D, true >Static array allocation class that is specialized for scalar i.e., fundamental or built-in types (float, double, etc...)
 CStokhos::StaticFixedStandardStorage< ordinal_type, value_type, Num >Statically allocated storage class
 CStokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t >Statically allocated storage class
 CStokhos::StaticStandardStorage< ordinal_type, value_type, Num >Statically allocated storage class
 CStokhos::StaticStorage< ordinal_t, value_t, Num, device_t >Statically allocated storage class
 CBelos::StatusTestGenResNormAn implementation of StatusTestResNorm using a family of residual norms
 CStatusTestResNorm
 CStieltjesCosTest::Stieltjes_Cos_Func< Ordinal_Type, Value_Type >
 CStieltjesExpTest::Stieltjes_Exp_Func< Ordinal_Type, Value_Type >
 Cstieltjes_pce_quad_func
 CStieltjes_PCE_Setup< Func >
 CStieltjesSinTest::Stieltjes_Sin_Func< Ordinal_Type, Value_Type >
 CStieltjesCoupledSolver
 CStokhos::StieltjesGramSchmidtBuilder< ordinal_type, value_type >Class for building a reduced-dimension basis and quadrature from a given set of polynomial chaos expansions. First generates 1-D orthogonal bases using the discretized Stieltjes procedure, forms their tensor product, and then orthogonalizes using Gram-Schmidt
 CStokhos::StochasticProductTensor< ValueType, TensorType, Device >Bases defined by combinatorial product of polynomial bases
 CStokhos_MV_Multiply_Op< Tag >
 CSacado::StringName< ETPCE::OrthogPoly< T, S > >Specialization of StringName to OrthogPoly types
 CSacado::StringName< MP::Vector< S > >Specialization of StringName to Vector types
 CSacado::StringName< PCE::OrthogPoly< T, S > >Specialization of StringName to OrthogPoly types
 CSacado::StringName< Stokhos::DynamicStorage< ordinal_t, value_t, device_t > >
 CSacado::StringName< Stokhos::DynamicStridedStorage< ordinal_t, value_t, device_t > >
 CSacado::StringName< Stokhos::DynamicThreadedStorage< ordinal_t, value_t, device_t > >
 CSacado::StringName< Stokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t > >
 CSacado::StringName< Stokhos::StaticStorage< ordinal_t, value_t, Num, device_t > >
 CSacado::StringName< Stokhos::ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t > >
 CSacado::StringName< UQ::PCE< S > >Specialization of StringName to PCE types
 CStokhos::SymmetricDiagonalSpec< ExecutionSpace >Symmetric diagonal storage for a dense matrix
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::tan_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::tan_quad_func
 CDerivExpansionUnitTest::TanFunc
 CQuadExpansionUnitTest::TanFunc
 CPseudoSpectralExpansionUnitTest::TanFunc
 CForUQTKExpansionUnitTest::TanFunc
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::tanh_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::tanh_quad_func
 CForUQTKExpansionUnitTest::TanhFunc
 CDerivExpansionUnitTest::TanhFunc
 CPseudoSpectralExpansionUnitTest::TanhFunc
 CQuadExpansionUnitTest::TanhFunc
 CTensorData
 CStokhos::TensorProductElement< ordinal_t, element_t >Container storing a term in a generalized tensor product
 CStokhos::TensorProductIndexSet< ordinal_t >A tensor product index set
 CStokhos::TensorProductPredicate< ordinal_type >Predicate functor for building sparse triple products
 CStokhos::Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::TensorReadEntry
 CStokhos::SimpleTiledCrsProductTensor< ValueType, ExecutionSpace >::Tile< coord_t >
 CTile< coord_t >
 CStokhos::TiledCrsProductTensor< ValueType, ExecutionSpace >
 CKokkos::Example::FENL::NodeNodeGraph< ElemNodeIdView, CrsGraphType, ElemNode >::Times
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::times_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::times_quad_func
 CDerivExpansionUnitTest::TimesFunc
 CForUQTKExpansionUnitTest::TimesFunc
 CAlgebraicExpansionUnitTest::TimesFunc
 CPseudoSpectralExpansionUnitTest::TimesFunc
 CQuadExpansionUnitTest::TimesFunc
 CStokhos::TinyVec< ValueType, N, UseIntrinsics, Mask >
 CStokhos::TinyVec< ValueType, N, UseIntrinsics, true >
 CProductBasisUtilsUnitTest::total_order_predicate< ordinal_type >
 CStokhos::TotalOrderIndexSet< ordinal_t >An isotropic total order index set
 CStokhos::TotalOrderLess< term_type, compare_type >A comparison functor implementing a strict weak ordering based total-order ordering, recursive on the dimension
 CStokhos::TotalOrderPredicate< ordinal_type >Predicate functor for building sparse triple products based on total order
 CtwoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node >A linear 2-D diffusion problem
 CPseudoSpectralExpansionUnitTest::UMinusFunc
 CQuadExpansionUnitTest::UMinusFunc
 CAlgebraicExpansionUnitTest::UMinusFunc
 CDerivExpansionUnitTest::UMinusFunc
 CForUQTKExpansionUnitTest::UMinusFunc
 CQuadExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CSacadoPCEUnitTest::UnitTestSetup< PCEType >
 CAlgebraicExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CTensorProductBasisUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CLegendreBasisUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CForUQTKExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CProductBasisUtilsUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CSparseGridQuadratureUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CHermiteBasisUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CKokkosKernelsUnitTest::UnitTestSetup< Device >
 CSparse3TensorUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CSmolyakBasisUtilsUnitTest::UnitTestSetup< ordinal_type, value_type >
 CMatrixFreeOperatorUnitTest::UnitTestSetup
 CDerivExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CTotalOrderBasisUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CUnitTestSetup< VecType, FadType >
 CConstantExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CTensorProductUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CPseudoSpectralExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CDivisionOperatorUnitTest::UnitTestSetup< OrdinalType, ValueType >
 CTpetra::KokkosRefactor::Details::UnpackArrayMultiColumn< Kokkos::View< Sacado::MP::Vector< DS > **, DP... >, Kokkos::View< const Sacado::MP::Vector< SS > *, SP... >, IdxView, Op >
 CTpetra::KokkosRefactor::Details::UnpackArrayMultiColumn< Kokkos::View< Sacado::UQ::PCE< DS > **, DP... >, Kokkos::View< const Sacado::UQ::PCE< SS > *, SP... >, IdxView, Op >
 CTpetra::KokkosRefactor::Details::UnpackArrayMultiColumnVariableStride< Kokkos::View< Sacado::MP::Vector< DS > **, DP... >, Kokkos::View< const Sacado::MP::Vector< SS > *, SP... >, IdxView, ColView, Op >
 CTpetra::KokkosRefactor::Details::UnpackArrayMultiColumnVariableStride< Kokkos::View< Sacado::UQ::PCE< DS > **, DP... >, Kokkos::View< const Sacado::UQ::PCE< SS > *, SP... >, IdxView, ColView, Op >
 CStokhos::Update< ValueType, VectorType >
 CKokkosBlas::Impl::V_MultFunctor< Kokkos::View< Sacado::UQ::PCE< CS > *, CP... >, Kokkos::View< const Sacado::UQ::PCE< AS > *, AP... >, Kokkos::View< const Sacado::UQ::PCE< BS > *, BP... >, scalar_ab, scalar_c, SizeType >
 CKokkosBlas::Impl::V_Reciprocal_Functor< Kokkos::View< Sacado::UQ::PCE< RS > *, RP... >, Kokkos::View< const Sacado::UQ::PCE< XS > *, XP... >, SizeType >
 CKokkosBlas::Impl::V_ReciprocalSelf_Functor< Kokkos::View< Sacado::UQ::PCE< RS > *, RP... >, SizeType >
 CIfpack2::Details::V_ReciprocalThresholdSelfFunctor< XV, SizeType >
 CIfpack2::Details::V_ReciprocalThresholdSelfFunctor< Kokkos::View< Sacado::UQ::PCE< S > *, P... >, SizeType >
 CSacado::Value< ETPCE::Expr< T > >Specialization of Value to Expr types
 CSacado::Value< ETPCE::OrthogPoly< T, S > >Specialization of Value to OrthogPoly types
 CSacado::Value< MP::Expr< T > >Specialization of Value to Expr types
 CSacado::Value< MP::Vector< S > >Specialization of Value to Vector types
 CSacado::Value< PCE::OrthogPoly< T, S > >Specialization of Value to OrthogPoly types
 CSacado::Value< UQ::PCE< S > >Specialization of Value to PCE types
 CSacado::ValueType< ETPCE::Expr< T > >Specialization of ValueType to Expr types
 CSacado::ValueType< ETPCE::OrthogPoly< T, S > >Specialization of ValueType to OrthogPoly types
 CSacado::ValueType< MP::Expr< T > >Specialization of ValueType to Expr types
 CSacado::ValueType< MP::Vector< S > >Specialization of ValueType to Vector types
 CSacado::ValueType< PCE::OrthogPoly< T, S > >Specialization of ValueType to OrthogPoly types
 CSacado::ValueType< UQ::PCE< S > >Specialization of ValueType to PCE types
 CSacado::MP::Vector< S >
 CTpetra::Vector< S, L, G, N, bool >
 CSacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, false >::VectorConstruct< ExecSpace >
 CKokkos::Example::VectorImport< CommMessageType, CommIdentType, VectorType >
 CKokkos::Impl::ViewAssignment< ViewDefault, ViewMPVectorInterlaced, void >
 CKokkos::Impl::ViewAssignment< ViewMPVectorInterlaced, ViewMPVectorInterlaced, void >
 CKokkos::Impl::ViewCtorProp< void, Stokhos::CrsProductTensor< Value, Execution, Memory > >
 CKokkos::Experimental::Impl::ViewDataAnalysis< DataType, ArrayLayout, Sacado::MP::Vector< StorageType > >
 CKokkos::Experimental::Impl::ViewDataAnalysis< DataType, ArrayLayout, Sacado::UQ::PCE< StorageType > >
 CKokkos::Experimental::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(std::is_same< typename DstTraits::memory_space, typename SrcTraits::memory_space >::value &&std::is_same< typename DstTraits::specialize, ViewMPVectorContiguous >::value &&std::is_same< typename SrcTraits::specialize, ViewMPVectorContiguous >::value)>::type >Assign compatible Sacado::MP::Vector view mappings
 CKokkos::Experimental::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(std::is_same< typename DstTraits::memory_space, typename SrcTraits::memory_space >::value &&std::is_same< typename DstTraits::specialize, ViewMPVectorContiguous >::value &&std::is_same< typename SrcTraits::specialize, ViewSpecializeSacadoFad >::value)>::type >Assign compatible Sacado FAD<MP::Vector> view mappings
 CKokkos::Experimental::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(std::is_same< typename DstTraits::memory_space, typename SrcTraits::memory_space >::value &&std::is_same< typename DstTraits::specialize, ViewPCEContiguous >::value &&std::is_same< typename SrcTraits::specialize, ViewPCEContiguous >::value)>::type >Assign compatible Sacado::UQ::PCE view mappings
 CKokkos::Experimental::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(std::is_same< typename DstTraits::memory_space, typename SrcTraits::memory_space >::value &&std::is_same< typename DstTraits::specialize, void >::value &&std::is_same< typename SrcTraits::specialize, ViewMPVectorContiguous >::value &&unsigned(DstTraits::dimension::rank)==unsigned(SrcTraits::dimension::rank))>::type >Assign compatible Sacado::MP::Vector view mappings
 CKokkos::Experimental::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(std::is_same< typename DstTraits::memory_space, typename SrcTraits::memory_space >::value &&std::is_same< typename DstTraits::specialize, void >::value &&std::is_same< typename SrcTraits::specialize, ViewMPVectorContiguous >::value &&unsigned(DstTraits::dimension::rank)==unsigned(SrcTraits::dimension::rank)+1)>::type >Assign compatible Sacado::MP::Vector view mappings
 CKokkos::Experimental::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(std::is_same< typename DstTraits::memory_space, typename SrcTraits::memory_space >::value &&std::is_same< typename DstTraits::specialize, void >::value &&std::is_same< typename SrcTraits::specialize, ViewPCEContiguous >::value &&unsigned(DstTraits::dimension::rank)==unsigned(SrcTraits::dimension::rank))>::type >Assign compatible Sacado::UQ::PCE view mappings
 CKokkos::Experimental::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(std::is_same< typename DstTraits::memory_space, typename SrcTraits::memory_space >::value &&std::is_same< typename DstTraits::specialize, void >::value &&std::is_same< typename SrcTraits::specialize, ViewPCEContiguous >::value &&unsigned(DstTraits::dimension::rank)==unsigned(SrcTraits::dimension::rank)+1)>::type >Assign compatible Sacado::UQ::PCE view mappings
 CKokkos::Experimental::Impl::ViewMapping< Traits, typename std::enable_if<(std::is_same< typename Traits::specialize, ViewMPVectorContiguous >::value &&(std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Traits::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Traits::array_layout, Kokkos::LayoutStride >::value))>::type >
 CKokkos::Experimental::Impl::ViewMapping< Traits, typename std::enable_if<(std::is_same< typename Traits::specialize, ViewPCEContiguous >::value &&(std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Traits::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Traits::array_layout, Kokkos::LayoutStride >::value))>::type >
 CKokkos::Experimental::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::Experimental::ViewTraits< DataType, P... >::specialize, ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::Experimental::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::Experimental::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::Experimental::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::Experimental::ViewTraits< DataType, P... >, Arg0, Args ... >
 CKokkos::Experimental::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::Experimental::ViewTraits< DataType, P... >::specialize, ViewPCEContiguous >::value &&(std::is_same< typename Kokkos::Experimental::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::Experimental::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::Experimental::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value))>::type, Kokkos::Experimental::ViewTraits< DataType, P... >, Arg0, Args ... >
 CKokkos::Experimental::Impl::ViewMapping< void, ViewTraits< DataType, P... >, Sacado::MP::VectorPartition< Size > >
 CKokkos::Experimental::Impl::ViewMPVectorContiguous
 CKokkos::Impl::ViewMPVectorInterlaced
 CKokkos::Experimental::Impl::ViewPCEContiguous
 CStokhos::ViewRank< T >
 CStokhos::ViewRank< std::vector< T > >
 CKokkos::Impl::ViewSpecialize< ValueType, ViewMPVectorInterlaced, LayoutLeft, MemorySpace, MemoryTraits >
 CKokkos::Impl::ViewSpecialize< ValueType, ViewMPVectorInterlaced, LayoutRight, MemorySpace, MemoryTraits >
 CStokhos::ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t >Dynamic storage with view semantics and contiguous access
 CViewTraits
 CStokhos::WeightedVectorSpace< ord_type, val_type >
 CKokkosClassic::WeightNormOp< Sacado::PCE::OrthogPoly< ScalarType, StorageType > >