  Stokhos::AbstractPreconditionerFactory | An abstract class to represent a generic preconditioner factory |
  Stokhos::IfpackPreconditionerFactory | A factory for building Ifpack preconditioners |
| Stokhos::MLPreconditionerFactory | A factory for building ML preconditioners |
 Stokhos::PreconditionerFactory | An class for building preconditioners |
| Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::acos_quad_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::acos_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::acos_quad_func | |
| DerivExpansionUnitTest::ACosFunc | |
| ForUQTKExpansionUnitTest::ACosFunc | |
| PseudoSpectralExpansionUnitTest::ACosFunc | |
| QuadExpansionUnitTest::ACosFunc | |
| Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::acosh_quad_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::acosh_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::acosh_quad_func | |
| AlgebraicExpansionUnitTest::ACoshFunc | |
| ConstantExpansionUnitTest::ACoshFunc | |
| DerivExpansionUnitTest::ACoshFunc | |
| ForUQTKExpansionUnitTest::ACoshFunc | |
| PseudoSpectralExpansionUnitTest::ACoshFunc | |
| QuadExpansionUnitTest::ACoshFunc | |
| Stokhos::AdaptivityManager | |
| AddDiagonalValuesAtomicKernel< MatrixType > | |
| AddDiagonalValuesKernel< MatrixType > | |
| Stokhos::aligned_allocator< T > | An aligned STL allocator |
| Stokhos::aligned_allocator< const T > | An aligned STL allocator |
| cusp::precond::aggregation::amg_container< IndexType, ValueType, MemorySpace > | |
| cusp::precond::aggregation::amg_container< IndexType, ValueType, cusp::device_memory > | |
| cusp::precond::aggregation::amg_container< IndexType, ValueType, cusp::host_memory > | |
| Stokhos::AnisotropicTotalOrderIndexSet< ordinal_t > | An anisotropic total order index set |
| Stokhos::StandardStorage< ordinal_type, value_type >::apply< ord_t, val_t > | Turn StandardStorage into a meta-function class usable with mpl::apply |
| Stokhos::StaticFixedStandardStorage< ordinal_type, value_type, Num >::apply< ord_t, val_t > | Turn StaticFixedStandardStorage into a meta-function class usable with mpl::apply |
| Stokhos::StaticStandardStorage< ordinal_type, value_type, Num >::apply< ord_t, val_t > | Turn StaticStandardStorage into a meta-function class usable with mpl::apply |
| Kokkos::Example::FENL::ExponentialKLCoefficient< Scalar, MeshScalar, Device >::apply< T1, T2, T3 > | |
| Stokhos::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 |
| Stokhos::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 |
| Stokhos::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 |
| Stokhos::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 |
| Stokhos::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 |
| Stokhos::DynamicStorage< ordinal_t, value_t, device_t >::apply_N< N > | |
| Stokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t >::apply_N< N > | |
| Stokhos::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 > | |
| Stokhos::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 > | |
| ApplyView< DataType, LayoutType, ExecutionSpace > | |
| ApplyView< DataType, NoLayout, ExecutionSpace > | |
| Kokkos::Details::ArithTraits< Sacado::MP::Vector< S > > | |
| Kokkos::Details::ArithTraits< Sacado::UQ::PCE< S > > | |
| Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::asin_quad_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::asin_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::asin_quad_func | |
| DerivExpansionUnitTest::ASinFunc | |
| ForUQTKExpansionUnitTest::ASinFunc | |
| PseudoSpectralExpansionUnitTest::ASinFunc | |
| QuadExpansionUnitTest::ASinFunc | |
| Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::asinh_quad_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::asinh_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::asinh_quad_func | |
| AlgebraicExpansionUnitTest::ASinhFunc | |
| ConstantExpansionUnitTest::ASinhFunc | |
| DerivExpansionUnitTest::ASinhFunc | |
| ForUQTKExpansionUnitTest::ASinhFunc | |
| PseudoSpectralExpansionUnitTest::ASinhFunc | |
| QuadExpansionUnitTest::ASinhFunc | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::atan2_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::atan2_quad_func | |
| Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::atan_quad_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::atan_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::atan_quad_func | |
| DerivExpansionUnitTest::ATanFunc | |
| ForUQTKExpansionUnitTest::ATanFunc | |
| PseudoSpectralExpansionUnitTest::ATanFunc | |
| QuadExpansionUnitTest::ATanFunc | |
| Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::atanh_quad_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::atanh_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::atanh_quad_func | |
| AlgebraicExpansionUnitTest::ATanhFunc | |
| ConstantExpansionUnitTest::ATanhFunc | |
| DerivExpansionUnitTest::ATanhFunc | |
| ForUQTKExpansionUnitTest::ATanhFunc | |
| PseudoSpectralExpansionUnitTest::ATanhFunc | |
| QuadExpansionUnitTest::ATanhFunc | |
| Stokhos::BasisFactory< ordinal_type, value_type > | Factory for building multivariate orthogonal polynomial bases |
| Stokhos::BasisInteractionGraph | |
| binary_function | |
| Stokhos::KL::ProductEigenPairGreater< E, D > | Predicate class for sorting product eigenfunctions based on eigenvalue |
| BlockCrsMatrix | |
| Stokhos::FullyAssembledOperator | An Epetra operator representing the block stochastic Galerkin operator generated by fully assembling the matrix |
| Stokhos::InterlacedOperator | An Epetra operator representing the block stochastic Galerkin operator generated by fully assembling the matrix. The ordering of this operator is interlaced. That means that all stochastic degrees of freedom associated with a deterministic degree of freedom are interlaced. The result is a large sparse matrix that is composed of small (relatively) dense blocks |
| Stokhos::BlockCrsMatrix< BlockSpec, ValueType, Device > | CRS matrix of dense blocks |
| Stokhos::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 > | |
| Stokhos::BlockMultiply< BlockSpec > | |
| Stokhos::BlockMultiply< CooProductTensor< ValueType, Device, Pack > > | |
| Stokhos::BlockMultiply< CrsProductTensor< ValueType, Device > > | |
| Stokhos::BlockMultiply< FlatSparse3Tensor< ValueType, Device > > | |
| Stokhos::BlockMultiply< FlatSparse3Tensor_kji< ValueType, Device > > | |
| Stokhos::BlockMultiply< LexicographicBlockSparse3Tensor< ValueType, Device > > | |
| Stokhos::BlockMultiply< LinearSparse3Tensor< ValueType, Device, BlockSize > > | |
| Stokhos::BlockMultiply< SimpleTiledCrsProductTensor< ValueType, Device > > | |
| Stokhos::BlockMultiply< StochasticProductTensor< ValueType, TensorType, Device > > | |
| Stokhos::BlockMultiply< SymmetricDiagonalSpec< Device > > | |
| Stokhos::BlockMultiply< SymmetricDiagonalSpec< Kokkos::Cuda > > | |
| Stokhos::BlockMultiply< TiledCrsProductTensor< ValueType, Device > > | |
| Stokhos::RCB< TupleType >::Box | |
| Kokkos::Example::BoxElemFixture< Device, Order, CoordinateMap > | Generate a distributed unstructured finite element mesh from a partitioned NX*NY*NZ box of elements |
| Kokkos::Example::BoxElemPart | Partition a box of hexahedral elements among subdomains |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::cbrt_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::cbrt_quad_func | |
| DerivExpansionUnitTest::CbrtFunc | |
| ForUQTKExpansionUnitTest::CbrtFunc | |
| PseudoSpectralExpansionUnitTest::CbrtFunc | |
| QuadExpansionUnitTest::CbrtFunc | |
| CGIteration | |
| Belos::PseudoBlockCGIter< Sacado::MP::Vector< Storage >, MV, OP > | |
| Stokhos::ProductBasisUtils::Cijk_1D_Iterator< ordinal_type > | |
| Stokhos::CijkData< ordinal_type, scalar_type > | |
| CijkData | |
| Stokhos::LTBSparse3Tensor< ordinal_type, value_type >::CijkNode | Node type used in constructing the tree |
| CijkNonzeros | |
| Stokhos::CrsProductTensor< ValueType, ExecutionSpace, Memory >::CijkRowCount | |
| Kokkos::CijkType< view_type, Enabled > | |
| Kokkos::CijkType< ViewType, typename std::enable_if< is_view_uq_pce< ViewType >::value >::type > | |
| Stokhos::CrsProductTensor< ValueType, ExecutionSpace, Memory >::CompareCijkRowCount | |
| Stokhos::CompletePolynomialBasisUtils< ordinal_type, value_type > | Utilities for indexing a multi-variate complete polynomial basis |
| Teuchos::CompObject [external] | |
| Teuchos::SerialQRDenseSolver< OrdinalType, Sacado::MP::Vector< Storage > > | |
| Teuchos::SerialQRDenseSolver< OrdinalType, Sacado::UQ::PCE< Storage > > | |
| Sacado::Fad::ConstExpr< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > > > | Constant expression template |
| Kokkos::Experimental::Impl::MPVectorAllocation< ValueType, true >::ConstructDestructFunctor< ExecSpace > | |
| Kokkos::Experimental::Impl::MPVectorAllocation< ValueType, false >::ConstructDestructFunctor< ExecSpace > | |
| Kokkos::Experimental::Impl::PCEAllocation< ValueType >::ConstructDestructFunctor< ExecSpace > | |
| Stokhos::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 | |
| Stokhos::CooProductTensor< ValueType, ExecutionSpace, PackIndex > | Sparse product tensor using 'COO'-like storage format |
| Stokhos::CooProductTensor< ValueType, ExecutionSpace, false > | Specialization of CooProductTensor for unpacked (i,j,k) |
| Stokhos::CooProductTensor< ValueType, ExecutionSpace, true > | Specialization of CooProductTensor for packed (i,j,k) |
| Coord | |
| Stokhos::SimpleTiledCrsProductTensor< ValueType, ExecutionSpace >::Coord | |
| Stokhos::RCB< TupleType >::CoordCompare | |
| Stokhos::Impl::CopyPCE2Scalar< ExecSpace > | |
| Stokhos::Impl::CopyScalar2PCE< ExecSpace > | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::cos_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::cos_quad_func | |
| DerivExpansionUnitTest::CosFunc | |
| ForUQTKExpansionUnitTest::CosFunc | |
| PseudoSpectralExpansionUnitTest::CosFunc | |
| QuadExpansionUnitTest::CosFunc | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::cosh_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::cosh_quad_func | |
| DerivExpansionUnitTest::CoshFunc | |
| ForUQTKExpansionUnitTest::CoshFunc | |
| PseudoSpectralExpansionUnitTest::CoshFunc | |
| QuadExpansionUnitTest::CoshFunc | |
| CoupledSolver | |
| Amesos2::create_mp_vector_solver_impl< ConcreteSolver, ST, LO, GO, NO > | |
| Amesos2::create_solver_with_supported_type< ConcreteSolver, Tpetra::CrsMatrix< Sacado::MP::Vector< ST >, LO, GO, NO >, Tpetra::MultiVector< Sacado::MP::Vector< ST >, LO, GO, NO > > | |
| Kokkos::Example::FENL::CreateDeviceConfigs< ScalarType > | |
| Kokkos::Example::FENL::CreateDeviceConfigs< Sacado::MP::Vector< StorageType > > | |
| Kokkos::Example::FENL::CrsMatrix< ValueType, Space > | |
| Stokhos::CrsMatrix< ValueType, Device, Layout > | CRS matrix |
| Stokhos::CrsProductTensor< ValueType, ExecutionSpace, Memory > | Sparse product tensor with replicated entries to provide subsets with a given coordinate |
| Stokhos::CrsProductTensor< Value, Execution, Memory > | |
| Kokkos::Impl::ctor_prop_has_cijk< AllocProp > | |
| Kokkos::Impl::ctor_prop_has_cijk< ViewCtorProp< Stokhos::CrsProductTensor< Value, Execution, Memory > > > | |
| Kokkos::Impl::ctor_prop_has_cijk< ViewCtorProp< T > > | |
| Kokkos::Impl::ctor_prop_has_cijk< ViewCtorProp< T, P...> > | |
| Kokkos::Experimental::Impl::DeepCopyNonContiguous< OutputView, InputView > | |
| cusp::default_block_monitor< ValueType > | |
| Teuchos::DefaultBLASImpl< OrdinalType, Sacado::MP::Vector< Storage > > [external] | |
| Teuchos::BLAS< OrdinalType, Sacado::MP::Vector< Storage > > | Vector specializations for Teuchos::BLAS wrappers |
| Stokhos::DefaultMultiply | |
| Stokhos::DefaultPointCompare< ordinal_type, value_type > | Struct defining default point compare type |
| Stokhos::Dense3Tensor< ordinal_type, value_type > | Data structure storing a dense 3-tensor C(i,j,k) |
| Stokhos::Dense3Tensor< int, double > | |
| Stokhos::DenseOperator< ord_type, val_type > | |
| Kokkos::Example::FENL::DeviceConfig | |
| Stokhos::DeviceConfig | |
| Stokhos::DeviceForNode< Node > | Trait class that determines (new) Kokkos execution space type from Kokkos(Classic) Node type |
| Stokhos::DeviceForNode2< Node > | |
| Stokhos::DeviceForNode2< Kokkos::Compat::KokkosDeviceWrapperNode< Device > > | |
| Stokhos::DeviceProp | |
| Stokhos::DiagonalOperator< ord_type, val_type > | |
| Kokkos::Example::FENL::DeviceConfig::Dim3 | |
| Stokhos::DeviceConfig::Dim3 | |
| Kokkos::Example::FENL::DirichletComputation< FixtureType, SparseMatrixType > | |
| Kokkos::Example::FENL::DirichletComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, Kokkos::Example::FENL::CrsMatrix< ScalarType, ExecutionSpace > > | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::div_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::div_quad_func | |
| AlgebraicExpansionUnitTest::DivideFunc | |
| DerivExpansionUnitTest::DivideFunc | |
| ForUQTKExpansionUnitTest::DivideFunc | |
| PseudoSpectralExpansionUnitTest::DivideFunc | |
| QuadExpansionUnitTest::DivideFunc | |
| Stokhos::DivisionExpansionStrategy< ordinal_type, value_type, node_type > | Strategy interface for computing PCE of a/b |
| Stokhos::DenseDirectDivisionExpansionStrategy< int, double, Stokhos::StandardStorage< int, double > > | |
| Stokhos::CGDivisionExpansionStrategy< ordinal_type, value_type, node_type > | Strategy interface for computing PCE of a/b using only b[0] |
| Stokhos::DenseDirectDivisionExpansionStrategy< ordinal_type, value_type, node_type > | Strategy interface for computing PCE of a/b using only b[0] |
| Stokhos::GMRESDivisionExpansionStrategy< ordinal_type, value_type, node_type > | Strategy interface for computing PCE of a/b using only b[0] |
| Stokhos::MeanBasedDivisionExpansionStrategy< ordinal_type, value_type, node_type > | Strategy interface for computing PCE of a/b using only b[0] |
| Stokhos::SPDDenseDirectDivisionExpansionStrategy< ordinal_type, value_type, node_type > | Strategy interface for computing PCE of a/b using only b[0] |
| Stokhos::DivisionExpansionStrategy< int, double, Stokhos::StandardStorage< int, double > > | |
| Sacado::ETPCE::DivisionOp< ExprT1, ExprT2 > | |
| Stokhos::ds_array< T, isScalar > | Dynamic array allocation class that works for any type |
| Stokhos::ds_array< T, true > | Dynamic array allocation class that is specialized for scalar i.e., fundamental or built-in types (float, double, etc...) |
| Stokhos::DynamicStorage< ordinal_t, value_t, device_t > | |
| Stokhos::DynamicStridedStorage< ordinal_t, value_t, device_t > | |
| Stokhos::DynamicThreadedStorage< ordinal_t, value_t, device_t > | Dynamically allocated storage class with striding |
| Stokhos::DynArrayTraits< T, device_t, isScalar > | Dynamic array allocation class that is specialized for scalar i.e., fundamental or built-in types (float, double, etc...) |
| Stokhos::DynArrayTraits< T, device_t, false > | Dynamic array allocation class that works for any type |
| Stokhos::KL::OneDExponentialCovarianceFunction< value_type >::EigFuncCos | Nonlinear function whose roots define eigenvalues for cos() eigenfunction |
| Stokhos::KL::OneDExponentialCovarianceFunction< value_type >::EigFuncSin | Nonlinear function whose roots define eigenvalues for sin() eigenfunction |
| Kokkos::Example::FENL::ElementComputation< FiniteElementMeshType, SparseMatrixType, Method, CoeffFunctionType > | |
| Kokkos::Example::FENL::ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, Kokkos::Example::FENL::CrsMatrix< ScalarType, ExecutionSpace >, CoeffFunctionType > | |
| Kokkos::Example::FENL::ElementComputationBase< ExecutionSpace, Order, CoordinateMap, ScalarType > | |
| Kokkos::Example::FENL::ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, Analytic, CoeffFunctionType > | |
| Kokkos::Example::FENL::ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadQuadPoint, CoeffFunctionType > | |
 Kokkos::Example::FENL::ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadElement, CoeffFunctionType > | |
 Kokkos::Example::FENL::ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadElementOptimized, CoeffFunctionType > | |
| Kokkos::Example::FENL::ElementComputationConstantCoefficient | |
| EnsembleTraits_m< T > | |
| EnsembleTraits_m< Sacado::MP::Vector< S > > | |
| Epetra_Operator [external] | |
| Stokhos::BlockDiagonalOperator | An Epetra operator representing the block stochastic Galerkin operator |
| Stokhos::DiagEpetraOp | An Epetra operator representing the block stochastic Galerkin operator |
| Stokhos::EpetraMultiVectorOperator | An adaptor that supplies the operator interface to a multi-vector |
| Stokhos::MPPreconditioner | An abstract class to represent a generic stochastic Galerkin preconditioner as an Epetra_Operator |
| Stokhos::MPBlockDiagonalPreconditioner | A multi-point preconditioner based on applying the inverse of the diagonal |
| Stokhos::MPMeanBasedPreconditioner | A multi-point preconditioner based on applying the inverse of the mean |
| Stokhos::PCECovarianceOp | An Epetra operator representing the covariance operator of a polynomial chaos expansion |
| Stokhos::ProductEpetraOperator | A container class for products of Epetra_Vector's |
| Stokhos::EpetraOperatorOrthogPoly | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::EpetraMultiVectorOperatorOrthogPoly | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::ProductEpetraMultiVectorOperator | A container class for products of Epetra_Vector's |
| Stokhos::EpetraMultiVectorOperatorOrthogPoly | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::SGOperator | An abstract class to represent a generic stochastic Galerkin operator as an Epetra_Operator |
| Stokhos::FullyAssembledOperator | An Epetra operator representing the block stochastic Galerkin operator generated by fully assembling the matrix |
| Stokhos::InterlacedOperator | An Epetra operator representing the block stochastic Galerkin operator generated by fully assembling the matrix. The ordering of this operator is interlaced. That means that all stochastic degrees of freedom associated with a deterministic degree of freedom are interlaced. The result is a large sparse matrix that is composed of small (relatively) dense blocks |
| Stokhos::KLMatrixFreeOperator | An Epetra operator representing the block stochastic Galerkin operator |
| Stokhos::KLReducedMatrixFreeOperator | An Epetra operator representing the block stochastic Galerkin operator |
| Stokhos::MatrixFreeOperator | An Epetra operator representing the block stochastic Galerkin operator |
| Stokhos::SGPreconditioner | An abstract class to represent a generic stochastic Galerkin preconditioner as an Epetra_Operator |
| Stokhos::ApproxGaussSeidelPreconditioner | A stochastic preconditioner based on applying one iteration of approximate Gauss-Seidel |
| Stokhos::ApproxJacobiPreconditioner | A stochastic preconditioner based on applying two iterations of approximate Jacobi |
| Stokhos::ApproxSchurComplementPreconditioner | A stochastic preconditioner based on applying the approximate Schur complement preconditioner as defined by Sousedik, Ghanem, and Phipps, Numerical Linear Algebra and Applications, 2012 |
| Stokhos::FullyAssembledPreconditioner | A stochastic preconditioner based on applying a preconditioner to the fully assembled operator |
| Stokhos::KroneckerProductPreconditioner | An Epetra operator representing applying the mean in a block stochastic Galerkin expansion |
| Stokhos::MeanBasedPreconditioner | A stochastic preconditioner based on applying the inverse of the mean |
| Stokhos::EpetraCrsMatrixCloner | Cloner for Epetra_CrsMatrix coefficients |
| Stokhos::EpetraMultiVectorCloner | Cloner for Epetra_MultiVector coefficients |
| Stokhos::EpetraOperatorCloner | Cloner for Epetra_Operator coefficients |
| Stokhos::EpetraSparse3Tensor | |
| Stokhos::EpetraVectorCloner | Cloner for Epetra_Vector coefficients |
| Stokhos::error_storage_type_is_not_allocateable | |
| Stokhos::error_storage_type_is_not_resizeable | |
| exp_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::exp_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::exp_quad_func | |
| Stokhos::ExpansionFactory< ordinal_type, value_type > | Factory for building multivariate expansion strategies |
| DerivExpansionUnitTest::ExpFunc | |
| ForUQTKExpansionUnitTest::ExpFunc | |
| PseudoSpectralExpansionUnitTest::ExpFunc | |
| QuadExpansionUnitTest::ExpFunc | |
| Kokkos::Example::FENL::ExponentialKLCoefficient< Scalar, MeshScalar, Device > | |
| Stokhos::KL::ExponentialOneDEigenFunction< Value > | One-dimensional eigenfunction for exponential covariance function |
| Stokhos::KL::ExponentialRandomField< value_type, execution_space > | Class representing a KL expansion of an exponential random field |
| Stokhos::KL::ExponentialRandomField< MeshScalar > | |
| Stokhos::KL::ExponentialRandomField< MeshScalar, Device > | |
| Expr | |
| Sacado::Fad::Exp::IfThenElseOp< CondT, T1, T2, false, false, ExprSpecMPVector > | |
| Sacado::Fad::Exp::IfThenElseOp< CondT, T1, T2, false, true, ExprSpecMPVector > | |
| Sacado::Fad::Exp::IfThenElseOp< CondT, T1, T2, true, false, ExprSpecMPVector > | |
| Sacado::MP::Expr< T > | |
| Sacado::ETPCE::Expr< T > | |
| Sacado::ETPCE::Expr< DivisionOp< Expr< T1 >, Expr< T2 > > > | |
| Sacado::ETPCE::Expr< DivisionOp< Expr< T1 >, typename Expr< T1 >::value_type > > | |
| Sacado::ETPCE::Expr< DivisionOp< typename Expr< T2 >::value_type, Expr< T2 > > > | |
| Expr< MultiplicationOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > | |
| Sacado::ETPCE::Expr< MultiplicationOp< Expr< T1 >, Expr< T2 > > > | |
| Sacado::ETPCE::Expr< MultiplicationOp< Expr< T1 >, typename Expr< T1 >::value_type > > | |
| Expr< MultiplicationOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > | |
| Sacado::ETPCE::Expr< MultiplicationOp< typename Expr< T2 >::value_type, Expr< T2 > > > | |
| Sacado::Fad::Expr< SFadExprTag< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num >, ExprSpecMPVector > | Expression template forward-mode AD class with static memory allocation |
| Sacado::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 |
| Sacado::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 |
| Sacado::ETPCE::ExprQuadFuncWrapper< NN, ExprT > | |
| Sacado::Fad::ExprSpec< DFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > > > > | |
| Sacado::Fad::ExprSpec< GeneralFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Storage > > | |
| Sacado::Fad::ExprSpec< SFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > > | |
| Sacado::Fad::ExprSpec< SFadExprTag< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > > | |
| Sacado::Fad::ExprSpec< SLFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > > | |
| Sacado::Fad::ExprSpec< ViewFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, length, stride, BaseFadT > > | |
| Sacado::Fad::Exp::ExprSpecMPVector | Expression template specialization tag for Fad< MP::Vector > |
| Sacado::Fad::ExprSpecMPVector | |
| false_type | |
| Tpetra::KokkosRefactor::Details::device_is_cuda< D > | |
| Kokkos::FlatArrayType< view_type, Enabled > | |
| Kokkos::FlatArrayType< View< D, P...>, typename std::enable_if< is_view_mp_vector< View< D, P...> >::value >::type > | |
| Kokkos::FlatArrayType< View< D, P...>, typename std::enable_if< is_view_uq_pce< View< D, P...> >::value >::type > | |
| Stokhos::FlatLTBSparse3Tensor< ordinal_type, value_type > | |
| Stokhos::FlatLTBSparse3TensorNode< ordinal_type > | |
| Stokhos::FlatSparse3Tensor< ValueType, ExecutionSpace > | Sparse product tensor with replicated entries to provide subsets with a given coordinate |
| Stokhos::FlatSparse3Tensor_kji< ValueType, ExecutionSpace > | Sparse product tensor with replicated entries to provide subsets with a given coordinate |
| Stokhos::FloatingPointLess< value_type > | A functor for comparing floating-point numbers to some tolerance |
| Stokhos::mpl::for_each< Seq, Iter1, Iter2 > | |
| Stokhos::mpl::for_each< Seq, Iter1, Iter1 > | |
| GammaModel | |
| ProductBasisUtilsUnitTest::general_predicate< basis_set_type > | |
| Stokhos::GetMeanValsFunc< ViewType > | Get mean values matrix for mean-based preconditioning |
| Stokhos::GetMeanValsFunc< Kokkos::View< Sacado::MP::Vector< Storage > *, P... > > | Get mean values matrix for mean-based preconditioning |
| Stokhos::GetMeanValsFunc< Kokkos::View< Sacado::UQ::PCE< Storage > *, P... > > | Get mean values matrix for mean-based preconditioning |
| Kokkos::Impl::GetSacadoSize< Rank > | |
| Kokkos::Impl::GetSacadoSize< 0 > | |
| Kokkos::Impl::GetSacadoSize< 1 > | |
| Kokkos::Impl::GetSacadoSize< 2 > | |
| Kokkos::Impl::GetSacadoSize< 3 > | |
| Kokkos::Impl::GetSacadoSize< 4 > | |
| Kokkos::Impl::GetSacadoSize< 5 > | |
| Kokkos::Impl::GetSacadoSize< 6 > | |
| Kokkos::Impl::GetSacadoSize< 7 > | |
| Stokhos::GetScalarMeanValsFunc< ViewType > | Get mean values matrix for mean-based preconditioning |
| Stokhos::GetScalarMeanValsFunc< Kokkos::View< Sacado::MP::Vector< Storage > *, P... > > | Get mean values matrix for mean-based preconditioning |
| Stokhos::GetScalarMeanValsFunc< Kokkos::View< Sacado::UQ::PCE< Storage > *, P... > > | Get mean values matrix for mean-based preconditioning |
| Teuchos::details::GivensRotator< Sacado::MP::Vector< Storage >, false > | |
| Teuchos::details::GivensRotator< Sacado::UQ::PCE< Storage >, false > | |
| gram_schmidt_pce_binary_quad_func | |
| gram_schmidt_pce_unary_quad_func | |
| GramSchmidt_PCE_Setup< OrdinalType, ValueType > | |
| Stokhos::GrowthRule< value_type > | Interface for abstract growth rules |
| Stokhos::ClenshawCurtisExponentialGrowthRule< value_type > | An exponential growth rule for Clenshaw-Curtis |
| Stokhos::EvenGrowthRule< value_type > | A growth rule that always makes the supplied order even |
| Stokhos::GaussPattersonExponentialGrowthRule< value_type > | An exponential growth rule for Gauss-Patterson |
| Stokhos::IdentityGrowthRule< value_type > | A growth rule that is the identity |
| Stokhos::LinearGrowthRule< value_type > | A linear growth rule |
| Kokkos::Example::HexElement_Data< NodeCount > | |
| Kokkos::Example::HexElement_TensorData< NodeCount > | |
| Kokkos::Example::HexElement_TensorData< 27 > | |
| Kokkos::Example::HexElement_TensorData< 8 > | Evaluate Hex element on interval [-1,1]^3 |
| Kokkos::Example::HexElement_TensorEval< NodeCount, Device > | |
| innerF< AViewType, XViewType, YViewType, IndexType > | |
| Kokkos::Details::InnerProductSpaceTraits< const Sacado::UQ::PCE< S > > | |
| Kokkos::Details::InnerProductSpaceTraits< Sacado::UQ::PCE< S > > | |
| Stokhos::IntegralRank< unsigned > | |
| Kokkos::IntrinsicScalarType< view_type, Enabled > | |
| Kokkos::IntrinsicScalarType< AV > | |
| Kokkos::IntrinsicScalarType< CMV > | |
| Kokkos::IntrinsicScalarType< CV > | |
| Kokkos::is_view_mp_vector< view_type > | |
| Kokkos::is_view_mp_vector< View< T, P...> > | |
| Kokkos::is_view_uq_pce< view_type > | |
| Kokkos::is_view_uq_pce< View< T, P...> > | |
| Kokkos::Experimental::Impl::is_ViewMPVectorContiguous< Args > | |
| Kokkos::Experimental::Impl::is_ViewMPVectorContiguous< Kokkos::View< D, P...>, Args... > | |
| Kokkos::Experimental::Impl::is_ViewPCEContiguous< Args > | |
| Kokkos::Experimental::Impl::is_ViewPCEContiguous< Kokkos::View< D, P...>, Args... > | |
| Stokhos::is_ViewStorage< Storage > | |
| Stokhos::is_ViewStorage< ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t > > | |
| Sacado::IsADType< ETPCE::Expr< T > > | Specialization of IsADType to Expr types |
| Sacado::IsADType< ETPCE::OrthogPoly< T, S > > | Specialization of IsADType to OrthogPoly types |
| Sacado::IsADType< MP::Expr< T > > | Specialization of IsADType to Expr types |
| Sacado::IsADType< MP::Vector< S > > | Specialization of IsADType to Vector types |
| Sacado::IsADType< PCE::OrthogPoly< T, S > > | Specialization of IsADType to OrthogPoly types |
| Sacado::IsADType< UQ::PCE< S > > | Specialization of IsADType to PCE types |
| Sacado::IsEqual< ETPCE::OrthogPoly< T, S > > | Specialization of IsEqual to OrthogPoly types |
| Sacado::IsEqual< MP::Vector< S > > | Specialization of IsEqual to Vector types |
| Sacado::IsEqual< PCE::OrthogPoly< T, S > > | Specialization of IsEqual to OrthogPoly types |
| Sacado::IsEqual< UQ::PCE< S > > | Specialization of IsEqual to PCE types |
| Stokhos::IsScalarType< T > | Base template specification for IsScalarType |
| Stokhos::IsScalarType2< T > | Base template specification for IsScalarType |
| Sacado::IsScalarType< ETPCE::Expr< T > > | Specialization of IsADType to Expr types |
| Sacado::IsScalarType< ETPCE::OrthogPoly< T, S > > | Specialization of IsADType to OrthogPoly types |
| Sacado::IsScalarType< MP::Expr< T > > | Specialization of IsADType to Expr types |
| Sacado::IsScalarType< MP::Vector< S > > | Specialization of IsADType to Vector types |
| Sacado::IsScalarType< PCE::OrthogPoly< T, S > > | Specialization of IsADType to OrthogPoly types |
| Sacado::IsScalarType< UQ::PCE< S > > | Specialization of IsADType to PCE types |
| Sacado::IsStaticallySized< ETPCE::OrthogPoly< T, S > > | Specialization of IsStaticallySized to OrthogPoly types |
| Sacado::IsStaticallySized< MP::Vector< S > > | Specialization of IsStaticallySized to Vector types |
| Sacado::IsStaticallySized< PCE::OrthogPoly< T, S > > | Specialization of IsStaticallySized to OrthogPoly types |
| Sacado::IsStaticallySized< UQ::PCE< S > > | Specialization of IsStaticallySized to PCE types |
| Iteration | |
| Belos::PseudoBlockGmresIter< Sacado::MP::Vector< Storage >, MV, OP > | |
| iterator | |
| Stokhos::AnisotropicTotalOrderIndexSet< ordinal_t >::Iterator | Iterator class for iterating over elements of the index set |
| Stokhos::SparseArrayIterator< index_iterator, value_iterator > | Bi-directional iterator for traversing a sparse array |
| Stokhos::TensorProductIndexSet< ordinal_t >::Iterator | Iterator class for iterating over elements of the index set |
| Stokhos::TotalOrderIndexSet< ordinal_t >::Iterator | Iterator class for iterating over elements of the index set |
| Stokhos::JacobiTester | |
| Stokhos::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 | |
| twoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node >::KL_Diffusion_Func | |
| Kokkos_MV_Multiply_Op | |
| Stokhos::Lanczos< vectorspace_type, operator_type > | Applies Lanczos procedure to a given matrix |
| Lanczos_Cos_Func< Ordinal_Type, Value_Type > | |
| Lanczos_Exp_Func< Ordinal_Type, Value_Type > | |
| lanczos_pce_quad_func | |
| Lanczos_PCE_Setup< Func > | |
| Lanczos_Sin_Func< Ordinal_Type, Value_Type > | |
| Teuchos::LAPACK< OrdinalType, Sacado::MP::Vector< Storage > > | |
| Teuchos::LAPACK< OrdinalType, Sacado::UQ::PCE< Storage > > | |
| Belos::Details::LapackSupportsScalar< S > | |
| Belos::Details::LapackSupportsScalar< Sacado::MP::Vector< S > > | |
| cusp::block_multilevel< MatrixType, SmootherType, SolverType >::level | |
| Stokhos::LexicographicBlockSparse3Tensor< ValueType, ExecutionSpace > | Sparse product tensor with replicated entries to provide subsets with a given coordinate |
| Stokhos::LexicographicTreeBasisNode< ordinal_type > | |
| Stokhos::LexographicLess< term_type, compare_type > | A comparison functor implementing a strict weak ordering based lexographic ordering |
| linear_operator | |
| cusp::block_multilevel< amg_container< IndexType, ValueType, MemorySpace >::solve_type, SmootherType, SolverType > | |
| cusp::precond::aggregation::block_smoothed_aggregation< IndexType, ValueType, MemorySpace, SmootherType, SolverType > | |
| cusp::block_multilevel< MatrixType, SmootherType, SolverType > | |
| cusp::detail::block_lu_solver< ValueType, MemorySpace > | |
| cusp::relaxation::block_jacobi< ValueType, MemorySpace > | |
| cusp::relaxation::block_polynomial< ValueType, MemorySpace, Orientation > | |
| Stokhos::LinearSparse3Tensor< ValueType, ExecutionSpace, BlockSize > | Sparse product tensor with replicated entries to provide subsets with a given coordinate |
| Kokkos::LocalMPVectorView< ViewType, LocalSize, isStatic > | |
| Kokkos::LocalMPVectorView< View< D, P...>, LocalSize, true > | |
| Kokkos::LocalMPVectorView< ViewType, LocalSize, false > | |
| Ifpack2::Details::LocalReciprocalThreshold< XV, SizeType > | |
| Ifpack2::Details::LocalReciprocalThreshold< Kokkos::View< Sacado::MP::Vector< S > *, P...>, SizeType > | |
| Ifpack2::Details::LocalReciprocalThreshold< Kokkos::View< Sacado::UQ::PCE< S > *, P... >, SizeType > | |
| Kokkos::LocalUQPCEView< ViewType, LocalSize, Rank, isStatic > | |
| Kokkos::LocalUQPCEView< ViewType, LocalSize, 1, false > | |
| Kokkos::LocalUQPCEView< ViewType, LocalSize, 1, true > | |
| Kokkos::Example::FENL::LocalViewTraits< ViewType, Enabled > | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::log10_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::log10_quad_func | |
| DerivExpansionUnitTest::Log10Func | |
| ForUQTKExpansionUnitTest::Log10Func | |
| PseudoSpectralExpansionUnitTest::Log10Func | |
| QuadExpansionUnitTest::Log10Func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::log_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::log_quad_func | |
| DerivExpansionUnitTest::LogFunc | |
| ForUQTKExpansionUnitTest::LogFunc | |
| PseudoSpectralExpansionUnitTest::LogFunc | |
| QuadExpansionUnitTest::LogFunc | |
| twoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node >::LogNormal_Diffusion_Func< DiffusionFunc > | |
| twoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node >::LogNormal_Diffusion_Func< twoD_diffusion_problem::KL_Diffusion_Func > | |
| Stokhos::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 |
| KokkosBatched::MagnitudeScalarType< Sacado::MP::Vector< S > > | |
| KokkosBatched::MagnitudeScalarType< Sacado::UQ::PCE< S > > | |
| Kokkos::Example::MapGridUnitCube | Map a grid onto a unit cube with smooth nonlinear grading of the map |
| Mask< scalar > | |
| Mask< MagnitudeType > | |
| Mask< Sacado::MP::Vector > | |
| MaskedAssign< scalar > | |
| MaskedAssign< Sacado::MP::Vector< S > > | |
| MaskedAssign< Sacado::MP::Vector< Stokhos::DynamicStorage< ordinal_t, value_t, device_t > > > | |
| MatOrthoManager | |
| Belos::DGKSOrthoManager< Sacado::MP::Vector< Storage >, MV, OP > | |
| Belos::ICGSOrthoManager< Sacado::MP::Vector< Storage >, MV, OP > | |
| Belos::IMGSOrthoManager< Sacado::MP::Vector< Storage >, MV, OP > | |
| Stokhos::MatrixMarketWriter< MatrixType > | |
| Stokhos::MatrixMarketWriter< CrsMatrix< MatrixValue, Device, Layout > > | |
| Stokhos::MeanMultiply< MatrixType, InputViewType, OutputViewType > | |
| Stokhos::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... > > | |
| Stokhos::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... > > | |
| Stokhos::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... > > | |
| Stokhos::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... > > | |
| Stokhos::MemoryTraits< MemorySpace > | Traits class encapsulting memory alignment |
| Stokhos::MemoryTraits< Kokkos::HostSpace > | Specialization of MemoryTraits for host memory spaces |
| twoD_diffusion_ME::MeshPoint | |
| twoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node >::MeshPoint | |
| AlgebraicExpansionUnitTest::MinusFunc | |
| DerivExpansionUnitTest::MinusFunc | |
| ForUQTKExpansionUnitTest::MinusFunc | |
| PseudoSpectralExpansionUnitTest::MinusFunc | |
| QuadExpansionUnitTest::MinusFunc | |
| Kokkos::Impl::MirrorType< Space, T, P > | |
| ModelEvaluator | |
| SimpleME | |
| SimpleME | |
| Stokhos::MPInverseModelEvaluator | Nonlinear, inverse multi-point ModelEvaluator |
| Stokhos::MPModelEvaluator | Multi-point model evaluator |
| Stokhos::MPModelEvaluatorAdapter | ModelEvaluator adapter that implements the multi-point evaluations through sampling |
| Stokhos::ResponseStatisticModelEvaluator | ModelEvaluator providing statistic response functions |
| Stokhos::SGInverseModelEvaluator | Nonlinear, inverse stochastic Galerkin ModelEvaluator |
| Stokhos::SGModelEvaluatorBase | Base class for stochastic Galerkin model evaluators |
| Stokhos::SGModelEvaluator | Nonlinear, stochastic Galerkin ModelEvaluator |
| Stokhos::SGModelEvaluator_Adaptive | Nonlinear, stochastic Galerkin ModelEvaluator that constructs an adapted Jacobian |
| Stokhos::SGModelEvaluator_Interlaced | Nonlinear, stochastic Galerkin ModelEvaluator that constructs a interlaced Jacobian |
| Stokhos::SGQuadModelEvaluator | ModelEvaluator adaptor that implements the stochastic Galerkin residual and Jacobian computations using quadrature |
| Stokhos::SGQuadMPModelEvaluator | ModelEvaluator adaptor that implements the stochastic Galerkin residual and Jacobian computations using quadrature |
| twoD_diffusion_ME | ModelEvaluator for a linear 2-D diffusion problem |
| Stokhos::MortonZLess< term_type > | A comparison functor implementing a strict weak ordering based Morton Z-ordering |
| Stokhos::details::MPMultiply< Matrix, InputVector, OutputVector, Update, Enabled > | |
| Stokhos::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 > | |
| Stokhos::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 > | |
| Stokhos::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 > | |
| Stokhos::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 > | |
| Stokhos::MPPreconditionerFactory | Factory for generating stochastic Galerkin preconditioners |
| Kokkos::Experimental::Impl::MPVectorAllocation< ValueType, is_static > | |
| Kokkos::Experimental::Impl::MPVectorAllocation< sacado_mp_vector_type > | |
| Kokkos::Experimental::Impl::MPVectorAllocation< ValueType, false > | |
| Kokkos::Experimental::Impl::MPVectorAllocation< ValueType, true > | |
| Teuchos::details::MPVectorArrayHelper< Storage > | |
| Teuchos::details::MPVectorArrayHelper< Stokhos::DynamicStorage< Ordinal, Value, Device > > | |
| Teuchos::details::MPVectorArrayHelper< Stokhos::StaticFixedStorage< Ordinal, Value, Num, Device > > | |
| Test::MPVectorAtomicFunctor< ViewType > | |
| Kokkos::MPVectorWorkConfig< ExecSpace > | Team-based parallel work configuration for Sacado::MP::Vector |
| Stokhos::MultiIndex< ordinal_t > | A multidimensional index |
| Stokhos::MultiIndex< ordinal_type > | |
| Sacado::ETPCE::MultiplicationOp< ExprT1, ExprT2 > | |
| Stokhos::Multiply< MatrixType, InputVectorType, OutputVectorType, ColumnIndicesType, VectorRank, ImplTag > | |
| Stokhos::Multiply< BlockCrsMatrix< BlockSpec, MatrixValue, Device >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Device >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Device > > | |
| Stokhos::Multiply< BlockCrsMatrix< BlockSpec, MatrixValue, Kokkos::Cuda >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< BlockCrsMatrix< CooProductTensor< TensorScalar, Kokkos::Cuda, Pack >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< BlockCrsMatrix< FlatSparse3Tensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< BlockCrsMatrix< FlatSparse3Tensor_kji< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< BlockCrsMatrix< LexicographicBlockSparse3Tensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< BlockCrsMatrix< LinearSparse3Tensor< TensorScalar, Kokkos::Cuda, BlockSize >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< BlockCrsMatrix< SimpleTiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< BlockCrsMatrix< StochasticProductTensor< TensorScalar, TensorType, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::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 > > | |
| Stokhos::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 > > | |
| Stokhos::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 > > | |
| Stokhos::Multiply< BlockCrsMatrix< TiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > | |
| Stokhos::Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputMultiVectorType, OutputMultiVectorType, std::vector< OrdinalType >, IntegralRank< 2 > > | |
| Stokhos::Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputMultiVectorType, OutputMultiVectorType, void, IntegralRank< 2 > > | |
| Stokhos::Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputVectorType, OutputVectorType, void, IntegralRank< 1 > > | |
| Stokhos::Multiply< CrsMatrix< MatrixValue, Device, Layout >, std::vector< InputViewType >, std::vector< OutputViewType >, void, IntegralRank< 1 > > | |
| Stokhos::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... > > | |
| Stokhos::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... > > | |
| Stokhos::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... > > | |
| Stokhos::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... > > | |
| Stokhos::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... > > | |
| Stokhos::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... > > | |
| Stokhos::details::MultiplyAssign | |
| Stokhos::MultiplyImpl< ValueType, MatrixValue, VectorValue, Device > | |
| Stokhos::Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::MultiplyKernel | |
| Stokhos::details::MultiplyScaledAssign< Value > | |
| Stokhos::details::MultiplyScaledUpdate< Value > | |
| Stokhos::details::MultiplyScaledUpdate2< Value > | |
| Stokhos::details::MultiplyUpdate | |
| Belos::MultiVecTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::MP::Vector< Storage >, LO, GO, Node > > | Partial specialization of MultiVecTraits for MV = Tpetra::MultiVector |
| Belos::MultiVecTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::UQ::PCE< Storage >, LO, GO, Node > > | Partial specialization of MultiVecTraits for MV = Tpetra::MultiVector |
| KokkosBlas::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 > | |
| KokkosBlas::Impl::MV_Reciprocal_Functor< Kokkos::View< Sacado::UQ::PCE< RS > **, RP...>, Kokkos::View< const Sacado::UQ::PCE< XS > **, XP...>, SizeType > | |
| KokkosBlas::Impl::MV_ReciprocalSelf_Functor< Kokkos::View< Sacado::UQ::PCE< RS > **, RP...>, SizeType > | |
| MyOptions | |
| MyResults | |
| NISPCoupledSolver | |
| Kokkos::Example::FENL::NodeNodeGraph< ElemNodeIdView, CrsGraphType, ElemNode > | |
| NoLayout | |
| NZCompare | |
| NZPairCompare | |
| Teuchos::Object [external] | |
| Teuchos::SerialQRDenseSolver< OrdinalType, Sacado::MP::Vector< Storage > > | |
| Teuchos::SerialQRDenseSolver< OrdinalType, Sacado::UQ::PCE< Storage > > | |
| Stokhos::KL::OneDEigenPair< eigen_function_type > | Container for one-dimensional eigenfunction and eigenvalue |
| Stokhos::KL::OneDExponentialCovarianceFunction< value_type > | Class representing an exponential covariance function and its KL eigevalues/eigenfunctions |
| Stokhos::OneDOrthogPolyBasis< ordinal_type, value_type > | Abstract base class for 1-D orthogonal polynomials |
| Stokhos::RecurrenceBasis< ordinal_type, value_type > | Implementation of OneDOrthogPolyBasis based on the general three-term recurrence relationship:
![\[ \gamma_{k+1}\psi_{k+1}(x) = (\delta_k x - \alpha_k)\psi_k(x) - \beta_k\psi_{k-1}(x) \]](form_132.png)
for  where  ,  , and  |
| Stokhos::DiscretizedStieltjesBasis< ordinal_type, value_type > | Generates three-term recurrence using the Discretized Stieltjes procedure |
| Stokhos::RysBasis< ordinal_type, value_type > | Rys polynomial basis |
| Stokhos::HermiteBasis< ordinal_type, value_type > | Hermite polynomial basis |
| Stokhos::HouseTriDiagPCEBasis< ordinal_type, value_type > | Generates three-term recurrence using the Lanczos procedure applied to a polynomial chaos expansion in another basis |
| Stokhos::JacobiBasis< ordinal_type, value_type > | Jacobi polynomial basis |
| Stokhos::LanczosPCEBasis< ordinal_type, value_type > | Generates three-term recurrence using the Lanczos procedure applied to a polynomial chaos expansion in another basis |
| Stokhos::LanczosProjPCEBasis< ordinal_type, value_type > | Generates three-term recurrence using the Lanczos procedure applied to a polynomial chaos expansion in another basis |
| Stokhos::LegendreBasis< ordinal_type, value_type > | Legendre polynomial basis |
| Stokhos::ClenshawCurtisLegendreBasis< ordinal_type, value_type > | Legendre polynomial basis using Clenshaw-Curtis quadrature points |
| Stokhos::GaussPattersonLegendreBasis< ordinal_type, value_type > | Legendre polynomial basis using Gauss-Patterson quadrature points |
| Stokhos::MonoProjPCEBasis< ordinal_type, value_type > | Generates three-term recurrence using the Lanczos procedure applied to a polynomial chaos expansion in another basis |
| Stokhos::StieltjesBasis< ordinal_type, value_type, func_type > | Generates three-term recurrence using the Discretized Stieltjes procedure applied to a functional mapping another basis |
| Stokhos::StieltjesPCEBasis< ordinal_type, value_type > | Generates three-term recurrence using the Discretized Stieltjes procedure applied to a polynomial chaos expansion in another basis |
| Stokhos::OneDOrthogPolyBasis< OrdinalType, ValueType > | |
| Stokhos::RecurrenceBasis< OrdinalType, ValueType > | |
| Stokhos::HermiteBasis< OrdinalType, ValueType > | |
| Stokhos::HouseTriDiagPCEBasis< OrdinalType, ValueType > | |
| Stokhos::LanczosPCEBasis< OrdinalType, ValueType > | |
| Stokhos::LanczosProjPCEBasis< OrdinalType, ValueType > | |
| Stokhos::LegendreBasis< OrdinalType, ValueType > | |
| Stokhos::MonoProjPCEBasis< OrdinalType, ValueType > | |
| Stokhos::StieltjesPCEBasis< OrdinalType, ValueType > | |
| Operator | |
| Stokhos::MeanBasedTpetraOperator< Scalar, LocalOrdinal, GlobalOrdinal, Node > | |
| Stokhos::Operator< ordinal_type, value_type > | |
| Stokhos::BlockPreconditioner< ordinal_type, value_type > | |
| Stokhos::DiagPreconditioner< ordinal_type, value_type > | |
| Stokhos::GSPreconditioner< ordinal_type, value_type > | |
| Stokhos::JacobiPreconditioner< ordinal_type, value_type > | |
| Stokhos::SchurPreconditioner< ordinal_type, value_type > | |
| Stokhos::Operator< ordinal_type, double > | |
| Stokhos::InversePreconditioner< ordinal_type, value_type > | |
| Belos::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 |
| Belos::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 |
| Stokhos::OrthogonalizationFactory< ordinal_type, value_type > | Encapsulate various orthogonalization (ie QR) methods |
| Sacado::ETPCE::OrthogPoly< T, S > | |
| Sacado::PCE::OrthogPoly< T, S > | |
| Sacado::ETPCE::OrthogPoly< double, Stokhos::StandardStorage< int, double > > | |
| Stokhos::OrthogPolyApprox< ordinal_type, value_type, storage_type > | Class to store coefficients of a projection onto an orthogonal polynomial basis |
| Stokhos::OrthogPolyApprox< int, double > | |
| Stokhos::OrthogPolyApprox< ordinal_type, value_type > | |
| Stokhos::OrthogPolyApprox< OrdinalType, ValueType > | |
| Stokhos::OrthogPolyBasis< ordinal_type, value_type > | Abstract base class for multivariate orthogonal polynomials |
| Stokhos::GramSchmidtBasis< OrdinalType, ValueType > | |
| Stokhos::DerivBasis< ordinal_type, value_type > | Abstract base class for multivariate orthogonal polynomials that support computing double and triple products involving derivatives of the basis polynomials |
| Stokhos::CompletePolynomialBasis< ordinal_type, value_type > | Multivariate orthogonal polynomial basis generated from a total-order complete-polynomial tensor product of univariate polynomials |
| Stokhos::GramSchmidtBasis< ordinal_type, value_type > | Transforms a non-orthogonal multivariate basis to an orthogonal one using the Gram-Schmit procedure |
| Stokhos::ProductBasis< ordinal_type, value_type > | Abstract base class for multivariate orthogonal polynomials generated from tensor products of univariate polynomials |
| Stokhos::CompletePolynomialBasis< int, double > | |
| Stokhos::CompletePolynomialBasis< OrdinalType, ValueType > | |
| Stokhos::CompletePolynomialBasis< ordinal_type, value_type > | Multivariate orthogonal polynomial basis generated from a total-order complete-polynomial tensor product of univariate polynomials |
| Stokhos::ProductLanczosPCEBasis< 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 |
| Stokhos::SmolyakBasis< ordinal_type, value_type, coeff_compare_type > | Multivariate orthogonal polynomial basis generated from a Smolyak sparse grid |
| Stokhos::TensorProductBasis< ordinal_type, value_type, coeff_compare_type > | Multivariate orthogonal polynomial basis generated from a tensor product of univariate polynomials |
| Stokhos::TotalOrderBasis< ordinal_type, value_type, coeff_compare_type > | Multivariate orthogonal polynomial basis generated from a total order tensor product of univariate polynomials |
| Stokhos::ReducedPCEBasis< ordinal_type, value_type > | Abstract base class for reduced basis strategies built from polynomial chaos expansions in some other basis |
| Stokhos::GSReducedPCEBasisBase< 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 |
| Stokhos::MonomialGramSchmidtPCEBasis< 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 |
| Stokhos::MonomialProjGramSchmidtPCEBasis< 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 |
| Stokhos::MonomialProjGramSchmidtPCEBasis2< 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 |
| Stokhos::ProductLanczosGramSchmidtPCEBasis< 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 |
| Stokhos::ProductLanczosPCEBasis< 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 |
| Stokhos::OrthogPolyBasis< int, double > | |
| Stokhos::DerivBasis< int, double > | |
| Stokhos::CompletePolynomialBasis< int, double > | |
| Stokhos::ProductBasis< int, double > | |
| Stokhos::ProductBasis< int, double > | |
| Stokhos::OrthogPolyBasis< OrdinalType, ValueType > | |
| Stokhos::DerivBasis< OrdinalType, ValueType > | |
| Stokhos::CompletePolynomialBasis< OrdinalType, ValueType > | |
| Stokhos::ProductBasis< OrdinalType, ValueType > | |
| Stokhos::OrthogPolyBasis< OrdinalType, ValueType > | |
| Stokhos::OrthogPolyExpansion< ordinal_type, value_type, node_type > | Abstract base class for orthogonal polynomial-based expansions |
| Stokhos::OrthogPolyExpansionBase< ordinal_type, value_type, node_type > | Base class for consolidating common expansion implementations |
| Stokhos::PseudoSpectralOrthogPolyExpansion< OrdinalType, ValueType > | |
| Stokhos::QuadOrthogPolyExpansion< int, double > | |
| Stokhos::QuadOrthogPolyExpansion< OrdinalType, ValueType > | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type > | Orthogonal polynomial expansions based on numerical quadrature |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type > | Orthogonal polynomial expansions based on numerical quadrature |
| Stokhos::OrthogPolyExpansion< int, double, Stokhos::StandardStorage< int, double > > | |
| Stokhos::OrthogPolyExpansionBase< int, double, Stokhos::StandardStorage< int, double > > | |
| Stokhos::AlgebraicOrthogPolyExpansion< int, double > | |
| Stokhos::OrthogPolyExpansionBase< int, double, Stokhos::StandardStorage< int, double > > | |
| Stokhos::OrthogPolyExpansion< ordinal_type, value_type > | |
| Stokhos::ConstantOrthogPolyExpansion< ordinal_type, value_type > | Orthogonal polynomial expansion class for constant (size 1) expansions |
| Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type > | Othogonal polynomial expansions based on derivative calculations |
| Stokhos::OrthogPolyExpansion< ordinal_type, value_type, Stokhos::StandardStorage< ordinal_type, value_type > > | |
| Stokhos::OrthogPolyExpansionBase< ordinal_type, value_type, Stokhos::StandardStorage< ordinal_type, value_type > > | |
| Stokhos::AlgebraicOrthogPolyExpansion< ordinal_type, value_type > | Orthogonal polynomial expansions limited to algebraic operations |
| Stokhos::OrthogPolyExpansion< OrdinalType, ValueType > | |
| Stokhos::ConstantOrthogPolyExpansion< OrdinalType, ValueType > | |
| Stokhos::DerivOrthogPolyExpansion< OrdinalType, ValueType > | |
| Stokhos::OrthogPolyExpansion< OrdinalType, ValueType, Stokhos::StandardStorage< OrdinalType, ValueType > > | |
| Stokhos::OrthogPolyExpansionBase< OrdinalType, ValueType, Stokhos::StandardStorage< OrdinalType, ValueType > > | |
| Stokhos::AlgebraicOrthogPolyExpansion< OrdinalType, ValueType > | |
| Tpetra::KokkosRefactor::Details::PackArrayMultiColumn< Kokkos::View< Sacado::MP::Vector< DS > *, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, IdxView > | |
| Tpetra::KokkosRefactor::Details::PackArrayMultiColumn< Kokkos::View< Sacado::UQ::PCE< DS > *, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, IdxView > | |
| Tpetra::KokkosRefactor::Details::PackArrayMultiColumnVariableStride< Kokkos::View< Sacado::MP::Vector< DS > *, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, IdxView, ColView > | |
| Tpetra::KokkosRefactor::Details::PackArrayMultiColumnVariableStride< Kokkos::View< Sacado::UQ::PCE< DS > *, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, IdxView, ColView > | |
| Tpetra::KokkosRefactor::Details::PackArraySingleColumn< Kokkos::View< Sacado::MP::Vector< DS > *, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, IdxView > | |
| Tpetra::KokkosRefactor::Details::PackArraySingleColumn< Kokkos::View< Sacado::UQ::PCE< DS > *, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, IdxView > | |
| Tpetra::Details::PackTraits< Sacado::UQ::PCE< S > > | Partial specialization of PackTraits for Sacado's PCE UQ type |
| Stokhos::ParallelData | |
| Sacado::UQ::PCE< Storage > | |
| Sacado::UQ::PCE< S > | |
| pce_quad_func | |
| Kokkos::Experimental::Impl::PCEAllocation< ValueType > | |
| Kokkos::Experimental::Impl::PCEAllocation< sacado_uq_pce_type > | |
| Teuchos::details::PCEArrayHelper< Storage > | |
| Teuchos::details::PCEArrayHelper< Stokhos::DynamicStorage< Ordinal, Value, Device > > | |
| Test::PCEAtomicFunctor< ViewType > | |
| Kokkos::Experimental::Impl::PCEAllocation< ValueType >::PCEConstruct< ExecSpace > | |
| Sacado::UQ::PCEScalarTraitsImp< PCEType > | Implementation for Teuchos::ScalarTraits for all PCE types |
| Sacado::UQ::PCEScalarTraitsImp< Sacado::UQ::PCE< S > > | |
| Teuchos::ScalarTraits< Sacado::UQ::PCE< S > > | Specializtion of Teuchos::ScalarTraits |
| Sacado::UQ::PCESerializationTraitsImp< Ordinal, PCEType > | Implementation of Teuchos::SerializationTraits for all PCE types |
| Sacado::UQ::PCESerializationTraitsImp< Ordinal, Sacado::UQ::PCE< S > > | |
| Teuchos::SerializationTraits< Ordinal, Sacado::UQ::PCE< S > > | Specialization of Teuchos::SerializationTraits |
| Sacado::UQ::PCESerializerImp< Ordinal, PCEType, ValueSerializer > | Serializer object for all PCE types |
| Sacado::UQ::PCESerializerImp< Ordinal, Sacado::UQ::PCE< S >, ValueTypeSerializer< Ordinal, S::value_type > > | |
| Teuchos::ValueTypeSerializer< Ordinal, Sacado::UQ::PCE< S > > | Specialization of Teuchos::ValueTypeSerializer |
| Sacado::UQ::PCEValueTypeConversionTraitsImp< TypeTo, PCEType > | Implementation for Teuchos::ValueTypeConversionTraits for all PCE types |
| Sacado::UQ::PCEValueTypeConversionTraitsImp< TypeTo, Sacado::UQ::PCE< S > > | |
| Teuchos::ValueTypeConversionTraits< TypeTo, Sacado::UQ::PCE< S > > | Specializtion of Teuchos::ValueTypeConversionTraits |
| Perf | |
| unit_test::performance_test_driver< Scalar, Device > | |
| unit_test::performance_test_driver< Scalar, Kokkos::Cuda > | |
| PerformanceDriverOp< Storage, Method > | |
| Tpetra::KokkosRefactor::Details::PermuteArrayMultiColumn< Kokkos::View< Sacado::MP::Vector< DS > **, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, DstIdxView, SrcIdxView > | |
| Tpetra::KokkosRefactor::Details::PermuteArrayMultiColumn< Kokkos::View< Sacado::UQ::PCE< DS > **, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, DstIdxView, SrcIdxView > | |
| Tpetra::KokkosRefactor::Details::PermuteArrayMultiColumnVariableStride< Kokkos::View< Sacado::MP::Vector< DS > **, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, DstIdxView, SrcIdxView, DstColView, SrcColView > | |
| Tpetra::KokkosRefactor::Details::PermuteArrayMultiColumnVariableStride< Kokkos::View< Sacado::UQ::PCE< DS > **, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, DstIdxView, SrcIdxView, DstColView, SrcColView > | |
| PseudoSpectralExpansionUnitTest::PlusFunc | |
| DerivExpansionUnitTest::PlusFunc | |
| AlgebraicExpansionUnitTest::PlusFunc | |
| ForUQTKExpansionUnitTest::PlusFunc | |
| QuadExpansionUnitTest::PlusFunc | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::pow_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::pow_quad_func | |
| DerivExpansionUnitTest::PowFunc | |
| ForUQTKExpansionUnitTest::PowFunc | |
| PseudoSpectralExpansionUnitTest::PowFunc | |
| QuadExpansionUnitTest::PowFunc | |
| Stokhos::ProductBasisUtils | Utilities for indexing a multi-variate complete polynomial basis |
| Stokhos::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 |
| Stokhos::VectorOrthogPoly< coeff_type > | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::ProductContainer< Epetra_MultiVector > | |
| Stokhos::ProductEpetraMultiVector | A container class storing products of Epetra_MultiVector's |
| Stokhos::EpetraMultiVectorOrthogPoly | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::VectorOrthogPoly< Epetra_MultiVector > | |
| Stokhos::EpetraMultiVectorOrthogPoly | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::ProductContainer< Epetra_Operator > | |
| Stokhos::ProductEpetraOperator | A container class for products of Epetra_Vector's |
| Stokhos::VectorOrthogPoly< Epetra_Operator > | |
| Stokhos::EpetraOperatorOrthogPoly | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::ProductContainer< Epetra_Vector > | |
| Stokhos::ProductEpetraVector | A container class for products of Epetra_Vector's |
| Stokhos::EpetraVectorOrthogPoly | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::VectorOrthogPoly< Epetra_Vector > | |
| Stokhos::EpetraVectorOrthogPoly | A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor |
| Stokhos::ProductContainerTraits< coeff_type > | Base traits definition for ProductContainer |
| Stokhos::ProductContainerTraits< Epetra_CrsMatrix > | Specialization of ProductContainerTraits to Epetra_CrsMatrix coefficients |
| Stokhos::ProductContainerTraits< Epetra_MultiVector > | Specialization of ProductContainerTraits to Epetra_MultiVector coefficients |
| Stokhos::ProductContainerTraits< Epetra_Operator > | Specialization of ProductContainerTraits to Epetra_Operator coefficients |
| Stokhos::ProductContainerTraits< Epetra_Vector > | Specialization of ProductContainerTraits to Epetra_Vector coefficients |
| Stokhos::KL::ProductEigenPair< eigen_function_type, ExecutionSpace > | Container for multi-dimensional product of 1-D eigenfunctions/values |
| Stokhos::Multiply< BlockCrsMatrix< SimpleTiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::ProductTensorLoop | |
| Stokhos::Multiply< BlockCrsMatrix< TiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::ProductTensorLoop | |
| Teuchos::PromotionTraits< L, Sacado::ETPCE::OrthogPoly< T, S > > | Specialization of Teuchos::PromotionTraits to DFad types |
| Teuchos::PromotionTraits< L, Sacado::MP::Vector< S > > | Specialization of Teuchos::PromotionTraits to Vector types |
| Teuchos::PromotionTraits< L, Sacado::PCE::OrthogPoly< T, S > > | Specialization of Teuchos::PromotionTraits to DFad types |
| Teuchos::PromotionTraits< L, Sacado::UQ::PCE< S > > | Specialization of Teuchos::PromotionTraits to DFad types |
| Teuchos::PromotionTraits< Sacado::ETPCE::OrthogPoly< T, S >, R > | Specialization of Teuchos::PromotionTraits to DFad types |
| Teuchos::PromotionTraits< Sacado::ETPCE::OrthogPoly< T, S >, Sacado::ETPCE::OrthogPoly< T, S > > | Specialization of Teuchos::PromotionTraits to DFad types |
| Teuchos::PromotionTraits< Sacado::MP::Vector< S >, R > | Specialization of Teuchos::PromotionTraits to Vector types |
| Teuchos::PromotionTraits< Sacado::MP::Vector< S >, Sacado::MP::Vector< S > > | Specialization of Teuchos::PromotionTraits to Vector types |
| Teuchos::PromotionTraits< Sacado::PCE::OrthogPoly< T, S >, R > | Specialization of Teuchos::PromotionTraits to DFad types |
| Teuchos::PromotionTraits< Sacado::PCE::OrthogPoly< T, S >, Sacado::PCE::OrthogPoly< T, S > > | Specialization of Teuchos::PromotionTraits to DFad types |
| Teuchos::PromotionTraits< Sacado::UQ::PCE< S >, R > | Specialization of Teuchos::PromotionTraits to DFad types |
| Teuchos::PromotionTraits< Sacado::UQ::PCE< S >, Sacado::UQ::PCE< S > > | Specialization of Teuchos::PromotionTraits to DFad types |
| Belos::PseudoBlockCGIter | This class implements the pseudo-block CG iteration, where the basic CG algorithm is performed on all of the linear systems simultaneously |
| Belos::PseudoBlockGmresIter | This 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 |
| Stokhos::PseudoSpectralOperator< ordinal_t, value_t, point_compare_type > | An operator interface for building pseudo-spectral approximations |
| Stokhos::QuadraturePseudoSpectralOperator< ordinal_t, value_t, point_compare_type > | An operator for building pseudo-spectral coefficients using an arbitrary quadrature rule |
| Stokhos::SmolyakPseudoSpectralOperator< ordinal_t, value_t, point_compare_type > | An operator for building pseudo-spectral coefficients using a sparse Smolyak construction |
| Stokhos::TensorProductPseudoSpectralOperator< ordinal_t, value_t, point_compare_type > | An operator for building pseudo-spectral coefficients using tensor-product quadrature |
| Stokhos::PseudoSpectralOperator< ordinal_type, value_type, point_compare_type > | |
| Stokhos::PseudoSpectralOperator< OrdinalType, ValueType > | |
| Stokhos::PseudoSpectralOperator< OrdinalType, ValueType, typename DefaultPointCompare< OrdinalType, ValueType >::type > | |
| Stokhos::PseudoSpectralOperatorFactory< ordinal_type, value_type > | Factory for building multivariate quadrature strategies |
| Stokhos::Quadrature< ordinal_type, value_type > | Abstract base class for quadrature methods |
| Stokhos::SmolyakSparseGridQuadrature< ordinal_type, value_type, point_compare_type > | Defines quadrature for a tensor product basis by Smolyak sparse grids |
| Stokhos::TensorProductQuadrature< ordinal_type, value_type > | Defines quadrature for a tensor product basis by tensor products of 1-D quadrature rules |
| Stokhos::UserDefinedQuadrature< ordinal_type, value_type > | |
| Stokhos::Quadrature< int, double > | |
| Stokhos::Quadrature< OrdinalType, ValueType > | |
| Stokhos::QuadratureFactory< ordinal_type, value_type > | Factory for building multivariate quadrature strategies |
| RankTypeSelector< ViewType, OrdinalType, I > | |
| RankTypeSelector< ViewType, OrdinalType, 0 > | |
| RankTypeSelector< ViewType, OrdinalType, 1 > | |
| Stokhos::RCB< TupleType > | |
| Stokhos::aligned_allocator< T >::rebind< U > | |
| Stokhos::aligned_allocator< const T >::rebind< U > | |
| Kokkos::Impl::RebindStokhosStorageDevice< T, Device > | |
| Kokkos::Impl::RebindStokhosStorageDevice< const Sacado::MP::Vector< OldStorageType >, Device > | |
| Kokkos::Impl::RebindStokhosStorageDevice< const Sacado::UQ::PCE< OldStorageType >, Device > | |
| Kokkos::Impl::RebindStokhosStorageDevice< Sacado::MP::Vector< OldStorageType >, Device > | |
| Kokkos::Impl::RebindStokhosStorageDevice< Sacado::UQ::PCE< OldStorageType >, Device > | |
| Kokkos::Impl::RebindStokhosStorageDevice< T *, Device > | |
| Kokkos::Impl::RebindStokhosStorageDevice< T[], Device > | |
| Kokkos::Impl::RebindStokhosStorageDevice< T[N], Device > | |
| Stokhos::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 |
| Stokhos::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 |
| ReplaceDiagonalValuesKernel< MatrixType > | |
| Kokkos::Example::FENL::ResponseComputation< FixtureType, VectorType > | |
| reverse_iterator | |
| Stokhos::SparseArrayReverseIterator< index_iterator, value_iterator > | Bi-directional reverse iterator for traversing a sparse array |
| RF< Value, Device > | |
| RhoModel | |
| s_quad_func< Num > | |
| cusp::precond::aggregation::sa_level< MatrixType > | |
| Kokkos::Impl::ViewError::sacado_mp_vector_partition_constructor_requires_unmanaged_view | |
| ScalarTol< Scalar > | |
| ScalarTol< double > | |
| ScalarTol< float > | |
| unit_test::ScalarTolerances< Scalar > | |
| unit_test::ScalarTolerances< double > | |
| unit_test::ScalarTolerances< float > | |
| Sacado::MP::ScalarTraitsImp< S, reduct_across_vector > | |
| Sacado::PCE::ScalarTraitsImp< PCEType > | Implementation for Teuchos::ScalarTraits for all PCE types |
| Sacado::MP::ScalarTraitsImp< S, false > | |
| Teuchos::ScalarTraits< Sacado::MP::Vector< S > > | Specializtion of Teuchos::ScalarTraits |
| Sacado::MP::ScalarTraitsImp< S, true > | |
| Sacado::PCE::ScalarTraitsImp< Sacado::ETPCE::OrthogPoly< T, S > > | |
| Teuchos::ScalarTraits< Sacado::ETPCE::OrthogPoly< T, S > > | Specializtion of Teuchos::ScalarTraits |
| Sacado::PCE::ScalarTraitsImp< Sacado::PCE::OrthogPoly< T, S > > | |
| Teuchos::ScalarTraits< Sacado::PCE::OrthogPoly< T, S > > | Specializtion of Teuchos::ScalarTraits |
| Sacado::ScalarType< ETPCE::Expr< T > > | Specialization of ScalarType to Expr types |
| Sacado::ScalarType< ETPCE::OrthogPoly< T, S > > | Specialization of Promote to OrthogPoly types |
| Sacado::ScalarType< MP::Expr< T > > | Specialization of ScalarType to Expr types |
| Sacado::ScalarType< MP::Vector< S > > | Specialization of Promote to Vector types |
| Sacado::ScalarType< PCE::OrthogPoly< T, S > > | Specialization of Promote to OrthogPoly types |
| Sacado::ScalarType< UQ::PCE< S > > | Specialization of Promote to PCE types |
| Sacado::ScalarValue< ETPCE::Expr< T > > | Specialization of ScalarValue to Expr types |
| Sacado::ScalarValue< ETPCE::OrthogPoly< T, S > > | Specialization of ScalarValue to OrthogPoly types |
| Sacado::ScalarValue< MP::Expr< T > > | Specialization of ScalarValue to Expr types |
| Sacado::ScalarValue< MP::Vector< S > > | Specialization of ScalarValue to Vector types |
| Sacado::ScalarValue< PCE::OrthogPoly< T, S > > | Specialization of ScalarValue to OrthogPoly types |
| Sacado::ScalarValue< UQ::PCE< S > > | Specialization of ScalarValue to PCE types |
| Tpetra::Details::ScalarViewTraits< Sacado::UQ::PCE< S >, D > | Partial specialization of ScalarViewTraits for Sacado's PCE UQ type |
| SemiIntrusiveCoupledSolver | |
| Sacado::MP::SerializationImp< Ordinal, VecType, Serializer > | Serialization implementation for all Vector types |
| Sacado::MP::SerializationTraitsImp< Ordinal, VecType, is_static > | Implementation of Teuchos::SerializationTraits for all Vector types |
| Sacado::PCE::SerializationTraitsImp< Ordinal, PCEType > | Implementation of Teuchos::SerializationTraits for all PCE types |
| Sacado::PCE::SerializationTraitsImp< Ordinal, Sacado::ETPCE::OrthogPoly< T, S > > | |
| Teuchos::SerializationTraits< Ordinal, Sacado::ETPCE::OrthogPoly< T, S > > | Specialization of Teuchos::SerializationTraits |
| Sacado::MP::SerializationTraitsImp< Ordinal, Sacado::MP::Vector< S >, S::is_static > | |
| Teuchos::SerializationTraits< Ordinal, Sacado::MP::Vector< S > > | Specialization of Teuchos::SerializationTraits |
| Sacado::PCE::SerializationTraitsImp< Ordinal, Sacado::PCE::OrthogPoly< T, S > > | |
| Teuchos::SerializationTraits< Ordinal, Sacado::PCE::OrthogPoly< T, S > > | Specialization of Teuchos::SerializationTraits |
| Sacado::MP::SerializationTraitsImp< Ordinal, VecType, true > | Implementation of Teuchos::SerializationTraits for all static Vec types |
| Sacado::PCE::SerializerImp< Ordinal, PCEType, ValueSerializer > | Serializer object for all PCE types |
| Sacado::MP::SerializerImp< Ordinal, VecType, ValueSerializer > | An indirect serialization object for all Vector types |
| Sacado::PCE::SerializerImp< Ordinal, Sacado::ETPCE::OrthogPoly< T, S >, ValueTypeSerializer< Ordinal, T > > | |
| Teuchos::ValueTypeSerializer< Ordinal, Sacado::ETPCE::OrthogPoly< T, S > > | Specialization of Teuchos::ValueTypeSerializer |
| Sacado::MP::SerializerImp< Ordinal, Sacado::MP::Vector< S >, ValueTypeSerializer< Ordinal, Sacado::MP::Vector< S >::value_type > > | |
| Teuchos::ValueTypeSerializer< Ordinal, Sacado::MP::Vector< S > > | Specialization of Teuchos::ValueTypeSerializer |
| Sacado::PCE::SerializerImp< Ordinal, Sacado::PCE::OrthogPoly< T, S >, ValueTypeSerializer< Ordinal, T > > | |
| Teuchos::ValueTypeSerializer< Ordinal, Sacado::PCE::OrthogPoly< T, S > > | Specialization of Teuchos::ValueTypeSerializer |
| Stokhos::SGOperatorFactory | Factory for generating stochastic Galerkin preconditioners |
| Stokhos::SGPreconditionerFactory | Factory for generating stochastic Galerkin preconditioners |
| Shape | |
| Kokkos::Impl::AnalyzeShape< Sacado::MP::Vector< StorageType > > | Analyze the array shape of a Sacado::MP::Vector |
| Stokhos::SimpleTiledCrsProductTensor< ValueType, ExecutionSpace > | |
| sin_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sin_quad_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sin_quad_func | |
| ForUQTKExpansionUnitTest::SinFunc | |
| QuadExpansionUnitTest::SinFunc | |
| PseudoSpectralExpansionUnitTest::SinFunc | |
| DerivExpansionUnitTest::SinFunc | |
| Stokhos::SingleColumnMultivectorMultiply | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sinh_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sinh_quad_func | |
| ForUQTKExpansionUnitTest::SinhFunc | |
| QuadExpansionUnitTest::SinhFunc | |
| DerivExpansionUnitTest::SinhFunc | |
| PseudoSpectralExpansionUnitTest::SinhFunc | |
| Stokhos::SmolyakBasis< ordinal_type, value_type, coeff_compare_type >::SmolyakPredicate< tp_predicate_type > | Predicate functor for building sparse triple products |
| Stokhos::SmolyakBasis< ordinal_type, value_type, coeff_compare_type >::SmolyakPredicate< Stokhos::TensorProductPredicate< ordinal_type > > | |
| Solver | |
| Amesos2::MPVectorSolverAdapter< Storage, LocalOrdinal, GlobalOrdinal, Node, ConcreteSolver > | Amesos2 solver adapter for MP::Vector scalar type |
| Amesos2::solver_supports_scalar< ConcreteSolver, Sacado::MP::Vector< Storage > > | |
| Stokhos::Sparse3Tensor< ordinal_type, value_type > | Data structure storing a sparse 3-tensor C(i,j,k) in a a compressed format |
| Stokhos::Sparse3Tensor< int, double > | |
| Stokhos::AdaptivityManager::Sparse3TensorHash | |
| Stokhos::SparseArray< ordinal_type, val_type > | Container for a "sparse" array |
| Stokhos::SparseArray< int, ji_sparse_array > | |
| Stokhos::SparseArray< int, kj_sparse_array > | |
| Stokhos::SparseArray< ordinal_type, ji_sparse_array > | |
| Stokhos::SparseArray< ordinal_type, kj_sparse_array > | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sqrt_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sqrt_quad_func | |
| QuadExpansionUnitTest::SqrtFunc | |
| DerivExpansionUnitTest::SqrtFunc | |
| ForUQTKExpansionUnitTest::SqrtFunc | |
| PseudoSpectralExpansionUnitTest::SqrtFunc | |
| Stokhos::StandardStorage< ordinal_type, value_type > | |
| Stokhos::StandardStorage< int, double > | |
| Sacado::Fad::GeneralFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Storage > | Forward-mode AD class templated on the storage for the derivative array |
| Stokhos::StaticArrayTraits< T, device, isScalar > | Static array allocation class |
| Stokhos::StaticArrayTraits< T, D, false > | Static array allocation class that works for any type |
| Stokhos::StaticArrayTraits< T, D, true > | Static array allocation class that is specialized for scalar i.e., fundamental or built-in types (float, double, etc...) |
| Stokhos::StaticFixedStandardStorage< ordinal_type, value_type, Num > | Statically allocated storage class |
| Stokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t > | Statically allocated storage class |
| Sacado::StaticSize< MP::Vector< S > > | Specialization of StaticSize to Vector types |
| Stokhos::StaticStandardStorage< ordinal_type, value_type, Num > | Statically allocated storage class |
| Stokhos::StaticStorage< ordinal_t, value_t, Num, device_t > | Statically allocated storage class |
| Belos::StatusTestGenResNorm | An implementation of StatusTestResNorm using a family of residual norms |
| Belos::StatusTestImpResNorm | Convergence test using the implicit residual norm(s), with an explicit residual norm(s) check for loss of accuracy if necessary |
| StatusTestResNorm | |
| Belos::StatusTestGenResNorm< Sacado::MP::Vector< Storage >, MV, OP > | |
| Belos::StatusTestImpResNorm< Sacado::MP::Vector< Storage >, MV, OP > | |
| StieltjesCosTest::Stieltjes_Cos_Func< Ordinal_Type, Value_Type > | |
| StieltjesExpTest::Stieltjes_Exp_Func< Ordinal_Type, Value_Type > | |
| stieltjes_pce_quad_func | |
| Stieltjes_PCE_Setup< Func > | |
| StieltjesSinTest::Stieltjes_Sin_Func< Ordinal_Type, Value_Type > | |
| StieltjesCoupledSolver | |
| Stokhos::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 |
| Stokhos::StochasticProductTensor< ValueType, TensorType, Device > | Bases defined by combinatorial product of polynomial bases |
| Stokhos_MV_Multiply_Op< Tag > | |
| Kokkos::Impl::StokhosViewFill< OutputView, Enabled > | |
| Sacado::StringName< ETPCE::OrthogPoly< T, S > > | Specialization of StringName to OrthogPoly types |
| Sacado::StringName< MP::Vector< S > > | Specialization of StringName to Vector types |
| Sacado::StringName< PCE::OrthogPoly< T, S > > | Specialization of StringName to OrthogPoly types |
| Sacado::StringName< Stokhos::DynamicStorage< ordinal_t, value_t, device_t > > | |
| Sacado::StringName< Stokhos::DynamicStridedStorage< ordinal_t, value_t, device_t > > | |
| Sacado::StringName< Stokhos::DynamicThreadedStorage< ordinal_t, value_t, device_t > > | |
| Sacado::StringName< Stokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t > > | |
| Sacado::StringName< Stokhos::StaticStorage< ordinal_t, value_t, Num, device_t > > | |
| Sacado::StringName< Stokhos::ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t > > | |
| Sacado::StringName< UQ::PCE< S > > | Specialization of StringName to PCE types |
| Stokhos::SymmetricDiagonalSpec< ExecutionSpace > | Symmetric diagonal storage for a dense matrix |
| T | |
| Sacado::Fad::Exp::Extender< T, typename std::enable_if< Sacado::is_mp_vector< typename T::value_type >::value >::type > | Specialization of extender for MP::Vector scalar types |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::tan_quad_func | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::tan_quad_func | |
| QuadExpansionUnitTest::TanFunc | |
| DerivExpansionUnitTest::TanFunc | |
| PseudoSpectralExpansionUnitTest::TanFunc | |
| ForUQTKExpansionUnitTest::TanFunc | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::tanh_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::tanh_quad_func | |
| ForUQTKExpansionUnitTest::TanhFunc | |
| PseudoSpectralExpansionUnitTest::TanhFunc | |
| QuadExpansionUnitTest::TanhFunc | |
| DerivExpansionUnitTest::TanhFunc | |
| TensorData | |
| Stokhos::TensorProductElement< ordinal_t, element_t > | Container storing a term in a generalized tensor product |
| Stokhos::TensorProductIndexSet< ordinal_t > | A tensor product index set |
| Stokhos::TensorProductPredicate< ordinal_type > | Predicate functor for building sparse triple products |
| Stokhos::Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::TensorReadEntry | |
| Stokhos::SimpleTiledCrsProductTensor< ValueType, ExecutionSpace >::Tile< coord_t > | |
| Tile< coord_t > | |
| Stokhos::TiledCrsProductTensor< ValueType, ExecutionSpace > | |
| Kokkos::Example::FENL::NodeNodeGraph< ElemNodeIdView, CrsGraphType, ElemNode >::Times | |
| Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::times_quad_func | |
| Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::times_quad_func | |
| PseudoSpectralExpansionUnitTest::TimesFunc | |
| QuadExpansionUnitTest::TimesFunc | |
| DerivExpansionUnitTest::TimesFunc | |
| ForUQTKExpansionUnitTest::TimesFunc | |
| AlgebraicExpansionUnitTest::TimesFunc | |
| Stokhos::TinyVec< ValueType, N, UseIntrinsics, Mask > | |
| Stokhos::TinyVec< ValueType, N, UseIntrinsics, true > | |
| ProductBasisUtilsUnitTest::total_order_predicate< ordinal_type > | |
| Stokhos::TotalOrderIndexSet< ordinal_t > | An isotropic total order index set |
| Stokhos::TotalOrderLess< term_type, compare_type > | A comparison functor implementing a strict weak ordering based total-order ordering, recursive on the dimension |
| Stokhos::TotalOrderPredicate< ordinal_type > | Predicate functor for building sparse triple products based on total order |
| twoD_diffusion_problem< Scalar, MeshScalar, BasisScalar, LocalOrdinal, GlobalOrdinal, Node > | A linear 2-D diffusion problem |
| DerivExpansionUnitTest::UMinusFunc | |
| QuadExpansionUnitTest::UMinusFunc | |
| ForUQTKExpansionUnitTest::UMinusFunc | |
| PseudoSpectralExpansionUnitTest::UMinusFunc | |
| AlgebraicExpansionUnitTest::UMinusFunc | |
| SacadoPCEUnitTest::UnitTestSetup< PCEType > | |
| MatrixFreeOperatorUnitTest::UnitTestSetup | |
| KokkosKernelsUnitTest::UnitTestSetup< Device > | |
| DerivExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| TensorProductUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| ConstantExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| LegendreBasisUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| TotalOrderBasisUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| SparseGridQuadratureUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| Sparse3TensorUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| UnitTestSetup< VecType, FadType > | |
| ProductBasisUtilsUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| ForUQTKExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| TensorProductBasisUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| PseudoSpectralExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| SmolyakBasisUtilsUnitTest::UnitTestSetup< ordinal_type, value_type > | |
| AlgebraicExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| HermiteBasisUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| DivisionOperatorUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| QuadExpansionUnitTest::UnitTestSetup< OrdinalType, ValueType > | |
| Tpetra::KokkosRefactor::Details::UnpackArrayMultiColumn< ExecutionSpace, Kokkos::View< Sacado::MP::Vector< DS > **, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > *, SP...>, IdxView, Op > | |
| Tpetra::KokkosRefactor::Details::UnpackArrayMultiColumn< ExecutionSpace, Kokkos::View< Sacado::UQ::PCE< DS > **, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > *, SP...>, IdxView, Op > | |
| Tpetra::KokkosRefactor::Details::UnpackArrayMultiColumnVariableStride< ExecutionSpace, Kokkos::View< Sacado::MP::Vector< DS > **, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > *, SP...>, IdxView, ColView, Op > | |
| Tpetra::KokkosRefactor::Details::UnpackArrayMultiColumnVariableStride< ExecutionSpace, Kokkos::View< Sacado::UQ::PCE< DS > **, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > *, SP...>, IdxView, ColView, Op > | |
| Stokhos::Update< ValueType, VectorType > | |
| updateF< AViewType, XViewType, YViewType, IndexType > | |
| KokkosBlas::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 > | |
| KokkosBlas::Impl::V_Reciprocal_Functor< Kokkos::View< Sacado::UQ::PCE< RS > *, RP...>, Kokkos::View< const Sacado::UQ::PCE< XS > *, XP...>, SizeType > | |
| KokkosBlas::Impl::V_ReciprocalSelf_Functor< Kokkos::View< Sacado::UQ::PCE< RS > *, RP...>, SizeType > | |
| Ifpack2::Details::V_ReciprocalThresholdSelfFunctor< XV, SizeType > | |
| Ifpack2::Details::V_ReciprocalThresholdSelfFunctor< Kokkos::View< Sacado::UQ::PCE< S > *, P... >, SizeType > | |
| Sacado::Value< ETPCE::Expr< T > > | Specialization of Value to Expr types |
| Sacado::Value< ETPCE::OrthogPoly< T, S > > | Specialization of Value to OrthogPoly types |
| Sacado::Value< MP::Expr< T > > | Specialization of Value to Expr types |
| Sacado::Value< MP::Vector< S > > | Specialization of Value to Vector types |
| Sacado::Value< PCE::OrthogPoly< T, S > > | Specialization of Value to OrthogPoly types |
| Sacado::Value< UQ::PCE< S > > | Specialization of Value to PCE types |
| Sacado::ValueType< ETPCE::Expr< T > > | Specialization of ValueType to Expr types |
| Sacado::ValueType< ETPCE::OrthogPoly< T, S > > | Specialization of ValueType to OrthogPoly types |
| Sacado::ValueType< MP::Expr< T > > | Specialization of ValueType to Expr types |
| Sacado::ValueType< MP::Vector< S > > | Specialization of ValueType to Vector types |
| Sacado::ValueType< PCE::OrthogPoly< T, S > > | Specialization of ValueType to OrthogPoly types |
| Sacado::ValueType< UQ::PCE< S > > | Specialization of ValueType to PCE types |
| Teuchos::ValueTypeConversionTraits< TypeTo, Sacado::MP::Expr< ExprFrom > > | |
| Teuchos::ValueTypeConversionTraits< TypeTo, Sacado::MP::Vector< StorageFrom > > | Specializations for Teuchos::as<T> |
| Sacado::PCE::ValueTypeConversionTraitsImp< TypeTo, PCEType > | Implementation for Teuchos::ValueTypeConversionTraits for all PCE types |
| Sacado::PCE::ValueTypeConversionTraitsImp< TypeTo, Sacado::PCE::OrthogPoly< T, S > > | |
| Teuchos::ValueTypeConversionTraits< TypeTo, Sacado::PCE::OrthogPoly< T, S > > | Specializtion of Teuchos::ValueTypeConversionTraits |
| Sacado::MP::Vector< S > | |
| Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > > | |
| Kokkos::Experimental::Impl::MPVectorAllocation< ValueType, false >::VectorConstruct< ExecSpace > | |
| Kokkos::Example::VectorImport< CommMessageType, CommIdentType, VectorType > | |
| Kokkos::Impl::ViewAssignment< ViewDefault, ViewMPVectorInterlaced, void > | |
| Kokkos::Impl::ViewAssignment< ViewMPVectorInterlaced, ViewMPVectorInterlaced, void > | |
| Kokkos::Impl::ViewCtorProp< void, Stokhos::CrsProductTensor< Value, Execution, Memory > > | |
| Kokkos::Impl::ViewDataAnalysis< DataType, ArrayLayout, Sacado::MP::Vector< StorageType > > | |
| Kokkos::Impl::ViewDataAnalysis< DataType, ArrayLayout, Sacado::UQ::PCE< StorageType > > | |
| Kokkos::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 |
| Kokkos::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 |
| Kokkos::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 |
| Kokkos::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 |
| Kokkos::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 |
| Kokkos::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 |
| Kokkos::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 |
| Kokkos::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 > | |
| Kokkos::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 > | |
| Kokkos::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... > | |
| Kokkos::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... > | |
| Kokkos::Impl::ViewMapping< void, ViewTraits< DataType, P...>, Sacado::MP::VectorPartition< Size > > | |
| Kokkos::Experimental::Impl::ViewMPVectorContiguous | |
| Kokkos::Impl::ViewMPVectorInterlaced | |
| Kokkos::Experimental::Impl::ViewPCEContiguous | |
| Stokhos::ViewRank< T > | |
| Stokhos::ViewRank< std::vector< T > > | |
| Kokkos::Impl::ViewSpecialize< ValueType, ViewMPVectorInterlaced, LayoutLeft, MemorySpace, MemoryTraits > | |
| Kokkos::Impl::ViewSpecialize< ValueType, ViewMPVectorInterlaced, LayoutRight, MemorySpace, MemoryTraits > | |
| Stokhos::ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t > | Dynamic storage with view semantics and contiguous access |
| ViewTraits | |
| Kokkos::View< DataType, Arg1Type, Arg2Type, Arg3Type, Impl::ViewMPVectorInterlaced > | View::value_type == Sacado::MP::Vector< Stokhos::StorageType<...> > |
| Stokhos::WeightedVectorSpace< ord_type, val_type > | |
1.8.5
