Stokhos Development
Loading...
Searching...
No Matches
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 CSacado::ETPCE::AbsOp< ExprT >
 CStokhos::AbstractPreconditionerFactoryAn abstract class to represent a generic preconditioner factory
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::acos_quad_func
 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 >::acosh_quad_func
 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
 CSacado::ETPCE::ACoshOp< ExprT >
 CSacado::ETPCE::ACosOp< ExprT >
 CStokhos::AdaptivityManager
 CSacado::ETPCE::AdditionOp< ExprT1, ExprT2 >
 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::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::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::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::StaticStandardStorage< ordinal_type, value_type, Num >::apply< ord_t, val_t >Turn StaticStandardStorage 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::DynamicStorage< ordinal_t, value_t, device_t >::apply_N< N >
 CStokhos::StaticFixedStorage< ordinal_t, value_t, Num, 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 >
 CKokkos::Details::ArithTraits< Sacado::MP::Vector< S > >
 CKokkos::Details::ArithTraits< Sacado::UQ::PCE< S > >
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::asin_quad_func
 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 >::asinh_quad_func
 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
 CSacado::ETPCE::ASinhOp< ExprT >
 CSacado::ETPCE::ASinOp< ExprT >
 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
 CSacado::ETPCE::Atan2Op< ExprT1, ExprT2 >
 CStokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::atan_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 >::atanh_quad_func
 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
 CSacado::ETPCE::ATanhOp< ExprT >
 CSacado::ETPCE::ATanOp< ExprT >
 CSacado::BaseExprType< MP::AbsOp< T > >
 CSacado::BaseExprType< MP::ACoshOp< T > >
 CSacado::BaseExprType< MP::ACosOp< T > >
 CSacado::BaseExprType< MP::AdditionOp< T1, T2 > >
 CSacado::BaseExprType< MP::ASinhOp< T > >
 CSacado::BaseExprType< MP::ASinOp< T > >
 CSacado::BaseExprType< MP::Atan2Op< T1, T2 > >
 CSacado::BaseExprType< MP::ATanhOp< T > >
 CSacado::BaseExprType< MP::ATanOp< T > >
 CSacado::BaseExprType< MP::CbrtOp< T > >
 CSacado::BaseExprType< MP::CeilOp< T > >
 CSacado::BaseExprType< MP::CoshOp< T > >
 CSacado::BaseExprType< MP::CosOp< T > >
 CSacado::BaseExprType< MP::DivisionOp< T1, T2 > >
 CSacado::BaseExprType< MP::ExpOp< T > >
 CSacado::BaseExprType< MP::FAbsOp< T > >
 CSacado::BaseExprType< MP::Log10Op< T > >
 CSacado::BaseExprType< MP::LogOp< T > >
 CSacado::BaseExprType< MP::MaxOp< T1, T2 > >
 CSacado::BaseExprType< MP::MinOp< T1, T2 > >
 CSacado::BaseExprType< MP::MultiplicationOp< T1, T2 > >
 CSacado::BaseExprType< MP::PowerOp< T1, T2 > >
 CSacado::BaseExprType< MP::SinhOp< T > >
 CSacado::BaseExprType< MP::SinOp< T > >
 CSacado::BaseExprType< MP::SqrtOp< T > >
 CSacado::BaseExprType< MP::SubtractionOp< T1, T2 > >
 CSacado::BaseExprType< MP::TanhOp< T > >
 CSacado::BaseExprType< MP::TanOp< T > >
 CSacado::BaseExprType< MP::UnaryMinusOp< T > >
 CSacado::BaseExprType< MP::UnaryPlusOp< T > >
 CStokhos::BasisFactory< ordinal_type, value_type >Factory for building multivariate orthogonal polynomial bases
 CStokhos::BasisInteractionGraph
 Cstd::binary_function
 Ccusp::relaxation::detail::block_jacobi_postsmooth_functor< ValueType >
 Ccusp::relaxation::detail::block_jacobi_presmooth_functor< ValueType >
 CEpetraExt::BlockCrsMatrix
 CStokhos::BlockCrsMatrix< BlockSpec, ValueType, Device >CRS matrix of dense blocks
 CStokhos::MeanMultiply< KokkosSparse::CrsMatrix< const Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const 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
 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
 CSacado::ETPCE::CbrtOp< ExprT >
 CCGIteration
 CStokhos::ProductBasisUtils::Cijk_1D_Iterator< ordinal_type >
 CStokhos::CijkData< ordinal_type, scalar_type >
 CStokhos::LTBSparse3Tensor< ordinal_type, value_type >::CijkNodeNode type used in constructing the tree
 CKokkos::CijkType< view_type, Enabled >
 CKokkos::CijkType< ViewType, typename std::enable_if< is_view_uq_pce< ViewType >::value >::type >
 CStokhos::CompletePolynomialBasisUtils< ordinal_type, value_type >Utilities for indexing a multi-variate complete polynomial basis
 CCompObject
 CSacado::ETPCE::ConstExpr< T >
 CSacado::Fad::ConstExpr< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > > >Constant expression template
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, false >::ConstructDestructFunctor< ExecSpace >
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, true >::ConstructDestructFunctor< ExecSpace >
 CKokkos::Experimental::Impl::PCEAllocation< ValueType >::ConstructDestructFunctor< ExecSpace >
 CSacado::Fad::Exp::ConstTypeRef< ConstType, ValueType >
 CSacado::Fad::Exp::ConstTypeRef< ConstT, value_type >
 CSacado::Fad::Exp::ConstTypeRef< ValueType, ValueType >
 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::RCB< TupleType >::CoordCompare
 CStokhos::Impl::CopyPCE2Scalar< ExecSpace >
 CStokhos::Impl::CopyScalar2PCE< ExecSpace >
 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
 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
 CSacado::ETPCE::CoshOp< ExprT >
 CSacado::ETPCE::CosOp< ExprT >
 CAmesos2::create_mp_vector_solver_impl< ConcreteSolver, ST, LO, GO, NO >
 CAmesos2::create_solver_with_supported_type< ConcreteSolver, Tpetra::CrsMatrix< Sacado::UQ::PCE< ST >, LO, GO, Kokkos::Compat::KokkosDeviceWrapperNode< D > >, Tpetra::MultiVector< Sacado::UQ::PCE< ST >, LO, GO, Kokkos::Compat::KokkosDeviceWrapperNode< D > > >
 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 >
 CTeuchos::DefaultBLASImpl
 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 >
 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 >
 CStokhos::DeviceConfig::Dim3
 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
 CStokhos::DivisionExpansionStrategy< ordinal_type, value_type, node_type >Strategy interface for computing PCE of a/b
 CSacado::ETPCE::DivisionOp< ExprT1, ExprT2 >
 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
 CEnsembleTraits_m< T >
 CEnsembleTraits_m< Sacado::MP::Vector< S > >
 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
 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
 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
 CSacado::ETPCE::ExpOp< ExprT >
 CExpr
 CSacado::ETPCE::Expr< T >
 CSacado::MP::Expr< T >
 CSacado::ETPCE::Expr< AbsOp< ExprT > >
 CSacado::Fad::Expr< AbsOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< AbsOp< T > >
 CSacado::ETPCE::Expr< ACoshOp< ExprT > >
 CSacado::Fad::Expr< ACoshOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< ACoshOp< T > >
 CSacado::ETPCE::Expr< ACosOp< ExprT > >
 CSacado::Fad::Expr< ACosOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< ACosOp< T > >
 CSacado::Fad::Expr< AdditionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >
 CSacado::ETPCE::Expr< AdditionOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< AdditionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::Fad::Expr< AdditionOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >
 CSacado::Fad::Expr< AdditionOp< ExprT1, ExprT2 >, ExprSpecMPVector >
 CSacado::MP::Expr< AdditionOp< T1, T1::value_type > >
 CSacado::MP::Expr< AdditionOp< T1, T2 > >
 CSacado::MP::Expr< AdditionOp< T2::value_type, T2 > >
 CSacado::ETPCE::Expr< AdditionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::ETPCE::Expr< ASinhOp< ExprT > >
 CSacado::Fad::Expr< ASinhOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< ASinhOp< T > >
 CSacado::ETPCE::Expr< ASinOp< ExprT > >
 CSacado::Fad::Expr< ASinOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< ASinOp< T > >
 CSacado::Fad::Expr< Atan2Op< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >
 CSacado::ETPCE::Expr< Atan2Op< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< Atan2Op< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::Fad::Expr< Atan2Op< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >
 CSacado::Fad::Expr< Atan2Op< ExprT1, ExprT2 >, ExprSpecMPVector >
 CSacado::MP::Expr< Atan2Op< T1, T1::value_type > >
 CSacado::MP::Expr< Atan2Op< T1, T2 > >
 CSacado::MP::Expr< Atan2Op< T2::value_type, T2 > >
 CSacado::ETPCE::Expr< Atan2Op< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::ETPCE::Expr< ATanhOp< ExprT > >
 CSacado::Fad::Expr< ATanhOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< ATanhOp< T > >
 CSacado::ETPCE::Expr< ATanOp< ExprT > >
 CSacado::Fad::Expr< ATanOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< ATanOp< T > >
 CSacado::ETPCE::Expr< CbrtOp< ExprT > >
 CSacado::MP::Expr< CbrtOp< T > >
 CSacado::MP::Expr< CeilOp< T > >
 CSacado::ETPCE::Expr< CoshOp< ExprT > >
 CSacado::Fad::Expr< CoshOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< CoshOp< T > >
 CSacado::ETPCE::Expr< CosOp< ExprT > >
 CSacado::Fad::Expr< CosOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< CosOp< T > >
 CSacado::Fad::Expr< DivisionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >
 CSacado::ETPCE::Expr< DivisionOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< DivisionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::Fad::Expr< DivisionOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >
 CSacado::Fad::Expr< DivisionOp< ExprT1, ExprT2 >, ExprSpecMPVector >
 CSacado::MP::Expr< DivisionOp< T1, T1::value_type > >
 CSacado::MP::Expr< DivisionOp< T1, T2 > >
 CSacado::MP::Expr< DivisionOp< T2::value_type, T2 > >
 CSacado::ETPCE::Expr< DivisionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::ETPCE::Expr< ExpOp< ExprT > >
 CSacado::Fad::Expr< ExpOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< ExpOp< T > >
 CSacado::ETPCE::Expr< FAbsOp< ExprT > >
 CSacado::Fad::Expr< FAbsOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< FAbsOp< T > >
 CSacado::ETPCE::Expr< Log10Op< ExprT > >
 CSacado::Fad::Expr< Log10Op< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< Log10Op< T > >
 CSacado::ETPCE::Expr< LogOp< ExprT > >
 CSacado::Fad::Expr< LogOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< LogOp< T > >
 CSacado::Fad::Expr< MaxOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >
 CSacado::ETPCE::Expr< MaxOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< MaxOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::Fad::Expr< MaxOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >
 CSacado::Fad::Expr< MaxOp< ExprT1, ExprT2 >, ExprSpecMPVector >
 CSacado::MP::Expr< MaxOp< T1, T1::value_type > >
 CSacado::MP::Expr< MaxOp< T1, T2 > >
 CSacado::MP::Expr< MaxOp< T2::value_type, T2 > >
 CSacado::ETPCE::Expr< MaxOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::Fad::Expr< MinOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >
 CSacado::ETPCE::Expr< MinOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< MinOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::Fad::Expr< MinOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >
 CSacado::Fad::Expr< MinOp< ExprT1, ExprT2 >, ExprSpecMPVector >
 CSacado::MP::Expr< MinOp< T1, T1::value_type > >
 CSacado::MP::Expr< MinOp< T1, T2 > >
 CSacado::MP::Expr< MinOp< T2::value_type, T2 > >
 CSacado::ETPCE::Expr< MinOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::Fad::Expr< MultiplicationOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >
 CSacado::ETPCE::Expr< MultiplicationOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< MultiplicationOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::Fad::Expr< MultiplicationOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >
 CSacado::Fad::Expr< MultiplicationOp< ExprT1, ExprT2 >, ExprSpecMPVector >
 CSacado::MP::Expr< MultiplicationOp< T1, T1::value_type > >
 CSacado::MP::Expr< MultiplicationOp< T1, T2 > >
 CSacado::MP::Expr< MultiplicationOp< T2::value_type, T2 > >
 CSacado::ETPCE::Expr< MultiplicationOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::Fad::Expr< PowerOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >
 CSacado::ETPCE::Expr< PowerOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< PowerOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::Fad::Expr< PowerOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >
 CSacado::Fad::Expr< PowerOp< ExprT1, ExprT2 >, ExprSpecMPVector >
 CSacado::MP::Expr< PowerOp< T1, T1::value_type > >
 CSacado::MP::Expr< PowerOp< T1, T2 > >
 CSacado::MP::Expr< PowerOp< T2::value_type, T2 > >
 CSacado::ETPCE::Expr< PowerOp< 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::Expr< SinhOp< ExprT > >
 CSacado::Fad::Expr< SinhOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< SinhOp< T > >
 CSacado::ETPCE::Expr< SinOp< ExprT > >
 CSacado::Fad::Expr< SinOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< SinOp< T > >
 CSacado::ETPCE::Expr< SqrtOp< ExprT > >
 CSacado::Fad::Expr< SqrtOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< SqrtOp< T > >
 CSacado::Fad::Expr< SubtractionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >
 CSacado::ETPCE::Expr< SubtractionOp< Expr< T1 >, Expr< T2 > > >
 CSacado::ETPCE::Expr< SubtractionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
 CSacado::Fad::Expr< SubtractionOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >
 CSacado::Fad::Expr< SubtractionOp< ExprT1, ExprT2 >, ExprSpecMPVector >
 CSacado::MP::Expr< SubtractionOp< T1, T1::value_type > >
 CSacado::MP::Expr< SubtractionOp< T1, T2 > >
 CSacado::MP::Expr< SubtractionOp< T2::value_type, T2 > >
 CSacado::ETPCE::Expr< SubtractionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
 CSacado::ETPCE::Expr< TanhOp< ExprT > >
 CSacado::Fad::Expr< TanhOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< TanhOp< T > >
 CSacado::ETPCE::Expr< TanOp< ExprT > >
 CSacado::Fad::Expr< TanOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< TanOp< T > >
 CSacado::ETPCE::Expr< UnaryMinusOp< ExprT > >
 CSacado::Fad::Expr< UnaryMinusOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< UnaryMinusOp< T > >
 CSacado::ETPCE::Expr< UnaryPlusOp< ExprT > >
 CSacado::Fad::Expr< UnaryPlusOp< ExprT >, ExprSpecMPVector >
 CSacado::MP::Expr< UnaryPlusOp< T > >
 CSacado::Fad::Exp::ExprAssign< DstType, typename std::enable_if< Sacado::IsStaticallySized< DstType >::value &&std::is_same< typename DstType::expr_spec_type, ExprSpecMPVector >::value >::type >Specialization of ExprAssign for statically sized Fad types and MP::Vector types
 CSacado::Fad::Exp::ExprAssign< DstType, typename std::enable_if< std::is_same< typename DstType::expr_spec_type, ExprSpecMPVector >::value >::type >Specialization of ExprAssign for MP::Vector scalar types
 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::Exp::ExprSpecMPVectorExpression template specialization tag for Fad< MP::Vector >
 CSacado::Fad::ExprSpecMPVector
 CSacado::ETPCE::FAbsOp< ExprT >
 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 >
 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 >
 CStokhos::GetScalarMeanValsFunc< ViewType >Get mean values matrix for mean-based preconditioning
 CStokhos::GetScalarMeanValsFunc< Kokkos::View< Sacado::MP::Vector< Storage > *, P... > >Get mean values matrix for mean-based preconditioning
 CStokhos::GetScalarMeanValsFunc< Kokkos::View< Sacado::UQ::PCE< Storage > *, P... > >Get mean values matrix for mean-based preconditioning
 CTeuchos::details::GivensRotator< Sacado::MP::Vector< Storage >, false >
 CTeuchos::details::GivensRotator< Sacado::UQ::PCE< Storage >, false >
 CStokhos::GrowthRule< value_type >Interface for abstract growth rules
 CinnerF< AViewType, XViewType, YViewType, IndexType >
 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 >
 CStokhos::is_power_of_two< N >
 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
 CSacado::IsExpr< MP::AbsOp< T > >
 CSacado::IsExpr< MP::ACoshOp< T > >
 CSacado::IsExpr< MP::ACosOp< T > >
 CSacado::IsExpr< MP::AdditionOp< T1, T2 > >
 CSacado::IsExpr< MP::ASinhOp< T > >
 CSacado::IsExpr< MP::ASinOp< T > >
 CSacado::IsExpr< MP::Atan2Op< T1, T2 > >
 CSacado::IsExpr< MP::ATanhOp< T > >
 CSacado::IsExpr< MP::ATanOp< T > >
 CSacado::IsExpr< MP::CbrtOp< T > >
 CSacado::IsExpr< MP::CeilOp< T > >
 CSacado::IsExpr< MP::CoshOp< T > >
 CSacado::IsExpr< MP::CosOp< T > >
 CSacado::IsExpr< MP::DivisionOp< T1, T2 > >
 CSacado::IsExpr< MP::ExpOp< T > >
 CSacado::IsExpr< MP::FAbsOp< T > >
 CSacado::IsExpr< MP::Log10Op< T > >
 CSacado::IsExpr< MP::LogOp< T > >
 CSacado::IsExpr< MP::MaxOp< T1, T2 > >
 CSacado::IsExpr< MP::MinOp< T1, T2 > >
 CSacado::IsExpr< MP::MultiplicationOp< T1, T2 > >
 CSacado::IsExpr< MP::PowerOp< T1, T2 > >
 CSacado::IsExpr< MP::SinhOp< T > >
 CSacado::IsExpr< MP::SinOp< T > >
 CSacado::IsExpr< MP::SqrtOp< T > >
 CSacado::IsExpr< MP::SubtractionOp< T1, T2 > >
 CSacado::IsExpr< MP::TanhOp< T > >
 CSacado::IsExpr< MP::TanOp< T > >
 CSacado::IsExpr< MP::UnaryMinusOp< T > >
 CSacado::IsExpr< MP::UnaryPlusOp< T > >
 CStokhos::IsScalarType< T >Base template specification for IsScalarType
 CStokhos::IsScalarType2< T >Base template specification for IsScalarType
 CStokhos::IsScalarType2< double >
 CStokhos::IsScalarType2< float >
 CStokhos::IsScalarType2< int >
 CStokhos::IsScalarType2< long >
 CStokhos::IsScalarType< double >
 CSacado::IsScalarType< ETPCE::Expr< T > >Specialization of IsADType to Expr types
 CSacado::IsScalarType< ETPCE::OrthogPoly< T, S > >Specialization of IsADType to OrthogPoly types
 CStokhos::IsScalarType< float >
 CStokhos::IsScalarType< int >
 CStokhos::IsScalarType< long >
 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
 CIteration
 Cstd::iterator
 CStokhos::MeanMultiply< KokkosSparse::CrsMatrix< const Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > >::Kernel
 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 >
 CLAPACKSpecialization for Sacado::UQ::PCE< Storage<...> >
 CLAPACK< 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
 Ccusp::linear_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 >
 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
 CSacado::ETPCE::Log10Op< ExprT >
 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
 CSacado::ETPCE::LogOp< ExprT >
 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
 CKokkosBatched::MagnitudeScalarType< Sacado::MP::Vector< S > >
 CKokkosBatched::MagnitudeScalarType< Sacado::UQ::PCE< S > >
 CMask< scalar >
 CMask< MagnitudeType >
 CMask< Sacado::MP::Vector >
 CMaskedAssign< scalar >
 CMaskedAssign< Sacado::MP::Vector< S > >
 CMaskedAssign< Sacado::MP::Vector< Stokhos::DynamicStorage< ordinal_t, value_t, device_t > > >
 CMatOrthoManager
 CStokhos::MatrixMarketWriter< MatrixType >
 CStokhos::MatrixMarketWriter< CrsMatrix< MatrixValue, Device, Layout > >
 CSacado::ETPCE::MaxOp< ExprT1, ExprT2 >
 CStokhos::MeanMultiply< MatrixType, InputViewType, OutputViewType >
 CStokhos::MeanMultiply< KokkosSparse::CrsMatrix< const Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const Sacado::UQ::PCE< InputStorage > **, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > **, OutputP... > >
 CStokhos::MeanMultiply< KokkosSparse::CrsMatrix< const Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const 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< const 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< const 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
 CSacado::ETPCE::MinOp< ExprT1, ExprT2 >
 CKokkos::Impl::MirrorType< Space, T, P >
 CKokkos::Impl::MirrorViewType< Space, T, P >
 CEpetraExt::ModelEvaluator
 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< const Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const Sacado::MP::Vector< InputStorage > **, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > **, OutputP... >, Update >
 CStokhos::details::MPMultiply< KokkosSparse::CrsMatrix< const Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const 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< const 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< const 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 > >
 CKokkos::MPVectorWorkConfig< ExecSpace, Tag >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< const Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const Sacado::UQ::PCE< InputStorage > **, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > **, OutputP... > >
 CStokhos::Multiply< KokkosSparse::CrsMatrix< const Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > >
 CStokhos::Multiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< const 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< const 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< const 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< const 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
 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 >
 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::Operator< ordinal_type, value_type >
 CTpetra::Operator
 CStokhos::Operator< ordinal_type, double >
 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::ETPCE::OrthogPoly< T, S >
 CSacado::PCE::OrthogPoly< T, S >
 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< 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, node_type >
 CStokhos::OrthogPolyExpansion< ordinal_type, value_type, Stokhos::StandardStorage< ordinal_type, value_type > >
 CTpetra::KokkosRefactor::Details::PackArrayMultiColumn< DstView, SrcView, IdxView, typename std::enable_if< Kokkos::is_view_mp_vector< DstView >::value &&Kokkos::is_view_mp_vector< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::PackArrayMultiColumn< DstView, SrcView, IdxView, typename std::enable_if< Kokkos::is_view_uq_pce< DstView >::value &&Kokkos::is_view_uq_pce< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::PackArrayMultiColumnVariableStride< DstView, SrcView, IdxView, ColView, typename std::enable_if< Kokkos::is_view_mp_vector< DstView >::value &&Kokkos::is_view_mp_vector< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::PackArrayMultiColumnVariableStride< DstView, SrcView, IdxView, ColView, typename std::enable_if< Kokkos::is_view_uq_pce< DstView >::value &&Kokkos::is_view_uq_pce< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::PackArraySingleColumn< DstView, SrcView, IdxView, typename std::enable_if< Kokkos::is_view_mp_vector< DstView >::value &&Kokkos::is_view_mp_vector< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::PackArraySingleColumn< DstView, SrcView, IdxView, typename std::enable_if< Kokkos::is_view_uq_pce< DstView >::value &&Kokkos::is_view_uq_pce< SrcView >::value >::type >
 CTpetra::Details::PackTraits< Sacado::UQ::PCE< S > >Partial specialization of PackTraits for Sacado's PCE UQ type
 CStokhos::ParallelData
 CSacado::UQ::PCE< Storage >
 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 > >
 CKokkos::Experimental::Impl::PCEAllocation< ValueType >::PCEConstruct< ExecSpace >
 CSacado::UQ::PCEScalarTraitsImp< PCEType >Implementation for Teuchos::ScalarTraits for all PCE types
 CSacado::UQ::PCEScalarTraitsImp< Sacado::UQ::PCE< S > >
 CSacado::UQ::PCESerializationTraitsImp< Ordinal, PCEType >Implementation of Teuchos::SerializationTraits for all PCE types
 CSacado::UQ::PCESerializationTraitsImp< Ordinal, Sacado::UQ::PCE< S > >
 CSacado::UQ::PCESerializerImp< Ordinal, PCEType, ValueSerializer >Serializer object for all PCE types
 CSacado::UQ::PCESerializerImp< Ordinal, Sacado::UQ::PCE< S >, ValueTypeSerializer< Ordinal, S::value_type > >
 CSacado::UQ::PCEValueTypeConversionTraitsImp< TypeTo, PCEType >Implementation for Teuchos::ValueTypeConversionTraits for all PCE types
 CSacado::UQ::PCEValueTypeConversionTraitsImp< TypeTo, Sacado::UQ::PCE< S > >
 CTpetra::KokkosRefactor::Details::PermuteArrayMultiColumn< DstView, SrcView, DstIdxView, SrcIdxView, Op, typename std::enable_if< Kokkos::is_view_mp_vector< DstView >::value &&Kokkos::is_view_mp_vector< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::PermuteArrayMultiColumn< DstView, SrcView, DstIdxView, SrcIdxView, Op, typename std::enable_if< Kokkos::is_view_uq_pce< DstView >::value &&Kokkos::is_view_uq_pce< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::PermuteArrayMultiColumnVariableStride< DstView, SrcView, DstIdxView, SrcIdxView, DstColView, SrcColView, Op, typename std::enable_if< Kokkos::is_view_mp_vector< DstView >::value &&Kokkos::is_view_mp_vector< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::PermuteArrayMultiColumnVariableStride< DstView, SrcView, DstIdxView, SrcIdxView, DstColView, SrcColView, Op, typename std::enable_if< Kokkos::is_view_uq_pce< DstView >::value &&Kokkos::is_view_uq_pce< SrcView >::value >::type >
 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
 CStokhos::power_of_two< N, OK >
 CStokhos::power_of_two< 1, true >
 CStokhos::power_of_two< 2, true >
 CStokhos::power_of_two< N, true >
 CSacado::ETPCE::PowerOp< ExprT1, ExprT2 >
 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
 CTeuchos::PromotionTraits< L, Sacado::ETPCE::OrthogPoly< T, S > >Specialization of Teuchos::PromotionTraits to DFad types
 CTeuchos::PromotionTraits< L, Sacado::MP::Vector< S > >Specialization of Teuchos::PromotionTraits to Vector types
 CTeuchos::PromotionTraits< L, Sacado::PCE::OrthogPoly< T, S > >Specialization of Teuchos::PromotionTraits to DFad types
 CTeuchos::PromotionTraits< L, Sacado::UQ::PCE< S > >Specialization of Teuchos::PromotionTraits to DFad types
 CTeuchos::PromotionTraits< Sacado::ETPCE::OrthogPoly< T, S >, R >Specialization of Teuchos::PromotionTraits to DFad types
 CTeuchos::PromotionTraits< Sacado::ETPCE::OrthogPoly< T, S >, Sacado::ETPCE::OrthogPoly< T, S > >Specialization of Teuchos::PromotionTraits to DFad types
 CTeuchos::PromotionTraits< Sacado::MP::Vector< S >, R >Specialization of Teuchos::PromotionTraits to Vector types
 CTeuchos::PromotionTraits< Sacado::MP::Vector< S >, Sacado::MP::Vector< S > >Specialization of Teuchos::PromotionTraits to Vector types
 CTeuchos::PromotionTraits< Sacado::PCE::OrthogPoly< T, S >, R >Specialization of Teuchos::PromotionTraits to DFad types
 CTeuchos::PromotionTraits< Sacado::PCE::OrthogPoly< T, S >, Sacado::PCE::OrthogPoly< T, S > >Specialization of Teuchos::PromotionTraits to DFad types
 CTeuchos::PromotionTraits< Sacado::UQ::PCE< S >, R >Specialization of Teuchos::PromotionTraits to DFad types
 CTeuchos::PromotionTraits< Sacado::UQ::PCE< S >, Sacado::UQ::PCE< S > >Specialization of Teuchos::PromotionTraits to DFad types
 CPseudoBlockCGIterThis class implements the pseudo-block CG iteration, where the basic CG algorithm is performed on all of the linear systems simultaneously
 CPseudoBlockGmresIterThis class implements the pseudo-block GMRES iteration, where a block Krylov subspace is constructed for all of the linear systems simultaneously. The QR decomposition of each block, upper Hessenberg matrix is performed each iteration to update the least squares system and give the current linear system residuals
 CStokhos::PseudoSpectralOperator< ordinal_t, value_t, point_compare_type >An operator interface for building pseudo-spectral approximations
 CStokhos::PseudoSpectralOperator< ordinal_t, value_t, typename DefaultPointCompare< ordinal_t, value_t >::type >
 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
 Cstd::reverse_iterator
 Ccusp::precond::aggregation::sa_level< MatrixType >
 CKokkos::Impl::ViewError::sacado_mp_vector_partition_constructor_requires_unmanaged_view
 CSacado::MP::ScalarTraitsImp< S, reduct_across_vector >
 CSacado::PCE::ScalarTraitsImp< PCEType >Implementation for Teuchos::ScalarTraits for all PCE types
 CSacado::MP::ScalarTraitsImp< S, false >
 CSacado::MP::ScalarTraitsImp< S, true >
 CSacado::PCE::ScalarTraitsImp< Sacado::ETPCE::OrthogPoly< T, S > >
 CSacado::PCE::ScalarTraitsImp< Sacado::PCE::OrthogPoly< T, S > >
 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
 CTpetra::Details::ScalarViewTraits< Sacado::UQ::PCE< S >, D >Partial specialization of ScalarViewTraits for Sacado's PCE UQ type
 CSacado::MP::SerializationImp< Ordinal, VecType, Serializer >Serialization implementation for all Vector types
 CSacado::MP::SerializationTraitsImp< Ordinal, VecType, is_static >Implementation of Teuchos::SerializationTraits for all Vector types
 CSacado::PCE::SerializationTraitsImp< Ordinal, PCEType >Implementation of Teuchos::SerializationTraits for all PCE types
 CSacado::PCE::SerializationTraitsImp< Ordinal, Sacado::ETPCE::OrthogPoly< T, S > >
 CSacado::MP::SerializationTraitsImp< Ordinal, Sacado::MP::Vector< S >, S::is_static >
 CSacado::PCE::SerializationTraitsImp< Ordinal, Sacado::PCE::OrthogPoly< T, S > >
 CSacado::MP::SerializationTraitsImp< Ordinal, VecType, true >Implementation of Teuchos::SerializationTraits for all static Vec types
 CSacado::MP::SerializerImp< Ordinal, VecType, ValueSerializer >An indirect serialization object for all Vector types
 CSacado::PCE::SerializerImp< Ordinal, PCEType, ValueSerializer >Serializer object for all PCE types
 CSacado::PCE::SerializerImp< Ordinal, Sacado::ETPCE::OrthogPoly< T, S >, ValueTypeSerializer< Ordinal, T > >
 CSacado::MP::SerializerImp< Ordinal, Sacado::MP::Vector< S >, ValueTypeSerializer< Ordinal, Sacado::MP::Vector< S >::value_type > >
 CSacado::PCE::SerializerImp< Ordinal, Sacado::PCE::OrthogPoly< T, S >, ValueTypeSerializer< Ordinal, T > >
 CSerialQRDenseSolverSpecialization for Sacado::UQ::PCE< Storage<...> >
 CSerialQRDenseSolver< OrdinalType, BaseScalarType >
 CStokhos::SGOperatorFactoryFactory for generating stochastic Galerkin preconditioners
 CStokhos::SGPreconditionerFactoryFactory for generating stochastic Galerkin preconditioners
 CShape
 CStokhos::SimpleTiledCrsProductTensor< ValueType, ExecutionSpace >
 CStokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sin_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sin_quad_func
 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
 CSacado::ETPCE::SinhOp< ExprT >
 CSacado::ETPCE::SinOp< ExprT >
 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 > >
 CAmesos2::solver_supports_scalar< ConcreteSolver, Sacado::UQ::PCE< 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::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::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sqrt_quad_func
 CStokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sqrt_quad_func
 CSacado::ETPCE::SqrtOp< ExprT >
 CStokhos::StandardStorage< ordinal_type, value_type >
 CStokhos::StandardStorage< int, double >
 CStokhos::StandardStorage< OrdinalType, ValueType >
 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
 CSacado::StaticSize< MP::Vector< S > >Specialization of StaticSize to Vector types
 CStokhos::StaticStandardStorage< ordinal_type, value_type, Num >Statically allocated storage class
 CStokhos::StaticStorage< ordinal_t, value_t, Num, device_t >Statically allocated storage class
 CStatusTestGenResNormAn implementation of StatusTestResNorm using a family of residual norms
 CStatusTestImpResNormConvergence test using the implicit residual norm(s), with an explicit residual norm(s) check for loss of accuracy if necessary
 CStatusTestResNorm
 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
 CKokkos::Impl::StokhosViewFill< OutputView, Enabled >
 CStorage
 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
 CSacado::ETPCE::SubtractionOp< ExprT1, ExprT2 >
 CStokhos::SymmetricDiagonalSpec< ExecutionSpace >Symmetric diagonal storage for a dense matrix
 CT
 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
 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
 CSacado::ETPCE::TanhOp< ExprT >
 CSacado::ETPCE::TanOp< ExprT >
 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::TiledCrsProductTensor< ValueType, ExecutionSpace >
 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
 CStokhos::TinyVec< ValueType, N, UseIntrinsics, Mask >
 CStokhos::TinyVec< ValueType, N, UseIntrinsics, true >
 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
 CSacado::ETPCE::UnaryMinusOp< ExprT >
 CSacado::ETPCE::UnaryPlusOp< ExprT >
 CTpetra::KokkosRefactor::Details::UnpackArrayMultiColumn< ExecutionSpace, DstView, SrcView, IdxView, Op, typename std::enable_if< Kokkos::is_view_mp_vector< DstView >::value &&Kokkos::is_view_mp_vector< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::UnpackArrayMultiColumn< ExecutionSpace, DstView, SrcView, IdxView, Op, typename std::enable_if< Kokkos::is_view_uq_pce< DstView >::value &&Kokkos::is_view_uq_pce< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::UnpackArrayMultiColumnVariableStride< ExecutionSpace, DstView, SrcView, IdxView, ColView, Op, typename std::enable_if< Kokkos::is_view_mp_vector< DstView >::value &&Kokkos::is_view_mp_vector< SrcView >::value >::type >
 CTpetra::KokkosRefactor::Details::UnpackArrayMultiColumnVariableStride< ExecutionSpace, DstView, SrcView, IdxView, ColView, Op, typename std::enable_if< Kokkos::is_view_uq_pce< DstView >::value &&Kokkos::is_view_uq_pce< SrcView >::value >::type >
 CStokhos::Update< ValueType, VectorType >
 CupdateF< AViewType, XViewType, YViewType, IndexType >
 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
 CTeuchos::ValueTypeConversionTraits< TypeTo, Sacado::MP::Expr< ExprFrom > >
 CTeuchos::ValueTypeConversionTraits< TypeTo, Sacado::MP::Vector< StorageFrom > >Specializations for Teuchos::as<T>
 CSacado::PCE::ValueTypeConversionTraitsImp< TypeTo, PCEType >Implementation for Teuchos::ValueTypeConversionTraits for all PCE types
 CSacado::PCE::ValueTypeConversionTraitsImp< TypeTo, Sacado::PCE::OrthogPoly< T, S > >
 CSacado::MP::Vector< S >
 CSacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >
 CKokkos::Experimental::Impl::MPVectorAllocation< ValueType, false >::VectorConstruct< ExecSpace >
 CKokkos::Impl::ViewAssignment< ViewDefault, ViewMPVectorInterlaced, void >
 CKokkos::Impl::ViewAssignment< ViewMPVectorInterlaced, ViewMPVectorInterlaced, void >
 CKokkos::Impl::ViewCtorProp< void, Stokhos::CrsProductTensor< Value, Execution, Memory > >
 CKokkos::Impl::ViewDataAnalysis< DataType, ArrayLayout, Sacado::MP::Vector< StorageType > >
 CKokkos::Impl::ViewDataAnalysis< DataType, ArrayLayout, Sacado::UQ::PCE< StorageType > >
 CKokkos::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space, typename SrcTraits::memory_space >::assignable &&std::is_same< typename DstTraits::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&std::is_same< typename SrcTraits::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value), typename DstTraits::specialize >::type >Assign compatible Sacado::MP::Vector view mappings
 CKokkos::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space, typename SrcTraits::memory_space >::assignable &&std::is_same< typename DstTraits::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&std::is_same< typename SrcTraits::specialize, ViewSpecializeSacadoFad >::value), typename DstTraits::specialize >::type >Assign compatible Sacado FAD<MP::Vector> view mappings
 CKokkos::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space, typename SrcTraits::memory_space >::assignable &&std::is_same< typename DstTraits::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::value &&std::is_same< typename SrcTraits::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::value), typename DstTraits::specialize >::type >Assign compatible Sacado::UQ::PCE view mappings
 CKokkos::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space, typename SrcTraits::memory_space >::assignable &&std::is_same< typename DstTraits::specialize, void >::value &&std::is_same< typename SrcTraits::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&unsigned(DstTraits::dimension::rank)==unsigned(SrcTraits::dimension::rank)), typename DstTraits::specialize >::type >Assign compatible Sacado::MP::Vector view mappings
 CKokkos::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space, typename SrcTraits::memory_space >::assignable &&std::is_same< typename DstTraits::specialize, void >::value &&std::is_same< typename SrcTraits::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&unsigned(DstTraits::dimension::rank)==unsigned(SrcTraits::dimension::rank)+1), typename DstTraits::specialize >::type >Assign compatible Sacado::MP::Vector view mappings
 CKokkos::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space, typename SrcTraits::memory_space >::assignable &&std::is_same< typename DstTraits::specialize, void >::value &&std::is_same< typename SrcTraits::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::value &&unsigned(DstTraits::dimension::rank)==unsigned(SrcTraits::dimension::rank)), typename DstTraits::specialize >::type >Assign compatible Sacado::UQ::PCE view mappings
 CKokkos::Impl::ViewMapping< DstTraits, SrcTraits, typename std::enable_if<(Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space, typename SrcTraits::memory_space >::assignable &&std::is_same< typename DstTraits::specialize, void >::value &&std::is_same< typename SrcTraits::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::value &&unsigned(DstTraits::dimension::rank)==unsigned(SrcTraits::dimension::rank)+1), typename DstTraits::specialize >::type >Assign compatible Sacado::UQ::PCE view mappings
 CKokkos::Impl::ViewMapping< Traits, typename std::enable_if<(std::is_same< typename Traits::specialize, Kokkos::Experimental::Impl::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)), typename Traits::specialize >::type >
 CKokkos::Impl::ViewMapping< Traits, typename std::enable_if<(std::is_same< typename Traits::specialize, Kokkos::Experimental::Impl::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)), typename Traits::specialize >::type >
 CKokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >
 CKokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value))>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >
 CKokkos::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 >