Stokhos Development
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
Sacado::MP::AbsOp< T >
Sacado::ETV::AbsOp< ExprT >
Sacado::ETPCE::AbsOp< ExprT >
Stokhos::AbstractPreconditionerFactoryAn abstract class to represent a generic preconditioner factory
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
Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::acos_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
Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::acosh_quad_func
Sacado::ETV::ACoshOp< ExprT >
Sacado::MP::ACoshOp< T >
Sacado::ETPCE::ACoshOp< ExprT >
Sacado::ETV::ACosOp< ExprT >
Sacado::ETPCE::ACosOp< ExprT >
Sacado::MP::ACosOp< T >
Stokhos::AdaptivityManager
Sacado::ETV::AdditionOp< ExprT1, ExprT2 >
Sacado::MP::AdditionOp< T1, T2 >
Sacado::ETPCE::AdditionOp< ExprT1, ExprT2 >
Sacado::MP::AdditionOp< T1, typename T1::value_type >
Sacado::MP::AdditionOp< typename T2::value_type, T2 >
Stokhos::AlgebraicOrthogPolyExpansion< ordinal_type, value_type >Orthogonal polynomial expansions limited to algebraic operations
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::AnisoSparseGridQuadrature< ordinal_type, value_type >Defines quadrature for a tensor product basis by anisotropic Smolyak sparse grids
Stokhos::AnisotropicTotalOrderIndexSet< ordinal_t >An anisotropic total order index set
Stokhos::DynamicStridedStorage< ordinal_t, value_t, device_t >::apply< ord_t, val_t >Turn DynamicStridedStorage into a meta-function class usable with mpl::apply
Stokhos::DynamicThreadedStorage< ordinal_t, value_t, device_t >::apply< ord_t, val_t >Turn DynamicThreadedStorage into a meta-function class usable with mpl::apply
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
Stokhos::LocalStorage< ordinal_t, value_t, Num, device_t >::apply< ord_t, val_t >Turn LocalStorage into a meta-function class usable with mpl::apply
Stokhos::DynamicStorage< ordinal_t, value_t, device_t >::apply< ord_t, val_t >Turn DynamicStorage into a meta-function class usable with mpl::apply
Stokhos::LocalStorage< ordinal_t, value_t, 1, device_t >::apply< ord_t, val_t >Turn LocalStorage into a meta-function class usable with mpl::apply
Stokhos::LocalStorage< ordinal_t, value_t, 2, device_t >::apply< ord_t, val_t >Turn LocalStorage into a meta-function class usable with mpl::apply
Stokhos::LocalStorage< ordinal_t, value_t, 4, device_t >::apply< ord_t, val_t >Turn LocalStorage into a meta-function class usable with mpl::apply
Stokhos::LocalStorage< ordinal_t, value_t, 8, device_t >::apply< ord_t, val_t >Turn LocalStorage into a meta-function class usable with mpl::apply
Stokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t >::apply< ord_t, val_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 >Turn StaticStorage into a meta-function class usable with mpl::apply
Stokhos::ViewStridedStorage< ordinal_t, value_t, device_t >::apply< ord_t, val_t >Turn ViewStridedStorage into a meta-function class usable with mpl::apply
Stokhos::ViewStorage< ordinal_t, value_t, device_t >::apply< ord_t, val_t >Turn ViewStorage into a meta-function class usable with mpl::apply
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 >, DefaultSparseMatOps >::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 >, DefaultSparseMatOps >::ApplyKernelSymmetric< MAX_COL >
Stokhos::ApproxGaussSeidelPreconditionerA stochastic preconditioner based on applying one iteration of approximate Gauss-Seidel
Stokhos::ApproxJacobiPreconditionerA stochastic preconditioner based on applying two iterations of approximate Jacobi
Stokhos::ApproxSchurComplementPreconditionerA stochastic preconditioner based on applying the approximate Schur complement preconditioner as defined by Sousedik, Ghanem, and Phipps, Numerical Linear Algebra and Applications, 2012
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
Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::asin_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
Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::asinh_quad_func
Sacado::ETV::ASinhOp< ExprT >
Sacado::MP::ASinhOp< T >
Sacado::ETPCE::ASinhOp< ExprT >
Sacado::ETV::ASinOp< ExprT >
Sacado::MP::ASinOp< T >
Sacado::ETPCE::ASinOp< ExprT >
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
Sacado::ETV::Atan2Op< ExprT1, ExprT2 >
Sacado::MP::Atan2Op< T1, T2 >
Sacado::ETPCE::Atan2Op< ExprT1, ExprT2 >
Sacado::MP::Atan2Op< T1, typename T1::value_type >
Sacado::MP::Atan2Op< typename T2::value_type, T2 >
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
Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::atan_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
Stokhos::DerivOrthogPolyExpansion< ordinal_type, value_type >::atanh_quad_func
Sacado::ETV::ATanhOp< ExprT >
Sacado::MP::ATanhOp< T >
Sacado::ETPCE::ATanhOp< ExprT >
Sacado::ETV::ATanOp< ExprT >
Sacado::MP::ATanOp< T >
Sacado::ETPCE::ATanOp< ExprT >
Stokhos::BasisFactory< ordinal_type, value_type >Factory for building multivariate orthogonal polynomial bases
Stokhos::BasisInteractionGraph
Ifpack2::BelosScalarType< Sacado::PCE::OrthogPoly< T, S > >Specialization of BelosScalarType to PCE types
cusp::relaxation::block_jacobi< ValueType, MemorySpace >
cusp::relaxation::detail::block_jacobi_postsmooth_functor< ValueType >
cusp::relaxation::detail::block_jacobi_presmooth_functor< ValueType >
cusp::detail::block_lu_solver< ValueType, MemorySpace >
cusp::block_multilevel< MatrixType, SmootherType, SolverType >
cusp::relaxation::block_polynomial< ValueType, MemorySpace >
cusp::precond::aggregation::block_smoothed_aggregation< IndexType, ValueType, MemorySpace, SmootherType, SolverType >
Stokhos::BlockCrsMatrix< BlockSpec, ValueType, Device >CRS matrix of dense blocks
Stokhos::BlockDiagonalOperatorAn Epetra operator representing the block stochastic Galerkin operator
Stokhos::BlockPreconditioner< ordinal_type, value_type >
Stokhos::RCB< TupleType >::Box
Stokhos::CGDivisionExpansionStrategy< ordinal_type, value_type, node_type >Strategy interface for computing PCE of a/b using only b[0]
Stokhos::ProductBasisUtils::Cijk_1D_Iterator< ordinal_type >
Stokhos::CijkData< ordinal_type, scalar_type >
Stokhos::LTBSparse3Tensor< ordinal_type, value_type >::CijkNodeNode type used in constructing the tree
Stokhos::ClenshawCurtisExponentialGrowthRule< value_type >An exponential growth rule for Clenshaw-Curtis
Stokhos::ClenshawCurtisLegendreBasis< ordinal_type, value_type >Legendre polynomial basis using Clenshaw-Curtis quadrature points
Stokhos::CompletePolynomialBasis< ordinal_type, value_type >Multivariate orthogonal polynomial basis generated from a total-order complete-polynomial tensor product of univariate polynomials
Stokhos::CompletePolynomialBasisUtils< ordinal_type, value_type >Utilities for indexing a multi-variate complete polynomial basis
Stokhos::ConstantOrthogPolyExpansion< ordinal_type, value_type >Orthogonal polynomial expansion class for constant (size 1) expansions
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 >, DefaultSparseMatOps >::CooKernel
Stokhos::CooProductTensor< ValueType, DeviceType, PackIndex >Sparse product tensor using 'COO'-like storage format
Stokhos::CooProductTensor< ValueType, DeviceType, false >Specialization of CooProductTensor for unpacked (i,j,k)
Stokhos::CooProductTensor< ValueType, DeviceType, true >Specialization of CooProductTensor for packed (i,j,k)
Stokhos::RCB< TupleType >::CoordCompare
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
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
Sacado::ETV::CoshOp< ExprT >
Sacado::MP::CoshOp< T >
Sacado::ETPCE::CoshOp< ExprT >
Sacado::ETV::CosOp< ExprT >
Sacado::MP::CosOp< T >
Sacado::ETPCE::CosOp< ExprT >
Stokhos::CrsMatrix< ValueType, Device >CRS matrix
Stokhos::CrsProductTensor< ValueType, DeviceType >Sparse product tensor with replicated entries to provide subsets with a given coordinate
Stokhos::CudaSparseSingleton
cusp::default_block_monitor< ValueType >
Stokhos::DefaultPointCompare< ordinal_type, value_type >Struct defining default point compare type
Stokhos::DefaultSparseMatOps
Stokhos::Dense3Tensor< ordinal_type, value_type >Data structure storing a dense 3-tensor C(i,j,k)
Stokhos::DenseDirectDivisionExpansionStrategy< ordinal_type, value_type, node_type >Strategy interface for computing PCE of a/b using only b[0]
Stokhos::DenseOperator< ord_type, val_type >
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::DerivOrthogPolyExpansion< ordinal_type, value_type >Othogonal polynomial expansions based on derivative calculations
Stokhos::DiagEpetraOpAn Epetra operator representing the block stochastic Galerkin operator
Stokhos::DiagonalOperator< ord_type, val_type >
Stokhos::DiagPreconditioner< ordinal_type, value_type >
cusp::precond::aggregation::detail::Dinv_A< MatrixType >
Stokhos::DiscretizedStieltjesBasis< ordinal_type, value_type >Generates three-term recurrence using the Discretized Stieltjes procedure
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
Stokhos::DivisionExpansionStrategy< ordinal_type, value_type, node_type >Strategy interface for computing PCE of a/b
Sacado::ETV::DivisionOp< ExprT1, ExprT2 >
Sacado::MP::DivisionOp< T1, T2 >
Sacado::ETPCE::DivisionOp< ExprT1, ExprT2 >
Sacado::MP::DivisionOp< T1, typename T1::value_type >
Sacado::MP::DivisionOp< typename T2::value_type, T2 >
KokkosClassic::DotOp1< Sacado::PCE::OrthogPoly< ScalarType, StorageType > >
KokkosClassic::DotOp2< Sacado::PCE::OrthogPoly< ScalarType, StorageType > >
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 >::EigFuncCosNonlinear function whose roots define eigenvalues for cos() eigenfunction
Stokhos::KL::OneDExponentialCovarianceFunction< value_type >::EigFuncSinNonlinear function whose roots define eigenvalues for sin() eigenfunction
Stokhos::EpetraCrsMatrixClonerCloner for Epetra_CrsMatrix coefficients
Stokhos::EpetraMultiVectorClonerCloner for Epetra_MultiVector coefficients
Stokhos::EpetraMultiVectorOperatorAn adaptor that supplies the operator interface to a multi-vector
Stokhos::EpetraMultiVectorOperatorOrthogPolyA container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor
Stokhos::EpetraMultiVectorOrthogPolyA container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor
Stokhos::EpetraOperatorClonerCloner for Epetra_Operator coefficients
Stokhos::EpetraOperatorOrthogPolyA container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor
Stokhos::EpetraSparse3Tensor
Stokhos::EpetraVectorClonerCloner for Epetra_Vector coefficients
Stokhos::EpetraVectorOrthogPolyA container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor
Stokhos::EvenGrowthRule< value_type >A growth rule that always makes the supplied order even
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
Stokhos::KL::ExponentialOneDEigenFunction< value_type >One-dimensional eigenfunction for exponential covariance function
Stokhos::KL::ExponentialRandomField< value_type >Class representing a KL expansion of an exponential random field
Sacado::ETV::ExpOp< ExprT >
Sacado::MP::ExpOp< T >
Sacado::ETPCE::ExpOp< ExprT >
Sacado::ETV::Expr< AbsOp< ExprT > >
Sacado::ETPCE::Expr< AbsOp< ExprT > >
Sacado::ETV::Expr< ACoshOp< ExprT > >
Sacado::ETPCE::Expr< ACoshOp< ExprT > >
Sacado::ETV::Expr< ACosOp< ExprT > >
Sacado::ETPCE::Expr< ACosOp< ExprT > >
Sacado::ETV::Expr< AdditionOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< AdditionOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETV::Expr< AdditionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETPCE::Expr< AdditionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETV::Expr< AdditionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETPCE::Expr< AdditionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< ASinhOp< ExprT > >
Sacado::ETPCE::Expr< ASinhOp< ExprT > >
Sacado::ETV::Expr< ASinOp< ExprT > >
Sacado::ETPCE::Expr< ASinOp< ExprT > >
Sacado::ETV::Expr< Atan2Op< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< Atan2Op< Expr< T1 >, Expr< T2 > > >
Sacado::ETV::Expr< Atan2Op< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETPCE::Expr< Atan2Op< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETV::Expr< Atan2Op< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETPCE::Expr< Atan2Op< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< ATanhOp< ExprT > >
Sacado::ETPCE::Expr< ATanhOp< ExprT > >
Sacado::ETV::Expr< ATanOp< ExprT > >
Sacado::ETPCE::Expr< ATanOp< ExprT > >
Sacado::ETV::Expr< CoshOp< ExprT > >
Sacado::ETPCE::Expr< CoshOp< ExprT > >
Sacado::ETV::Expr< CosOp< ExprT > >
Sacado::ETPCE::Expr< CosOp< ExprT > >
Sacado::ETV::Expr< DivisionOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< DivisionOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< DivisionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETV::Expr< DivisionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETPCE::Expr< DivisionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< DivisionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< ExpOp< ExprT > >
Sacado::ETPCE::Expr< ExpOp< ExprT > >
Sacado::ETV::Expr< FAbsOp< ExprT > >
Sacado::ETPCE::Expr< FAbsOp< ExprT > >
Sacado::ETV::Expr< Log10Op< ExprT > >
Sacado::ETPCE::Expr< Log10Op< ExprT > >
Sacado::ETV::Expr< LogOp< ExprT > >
Sacado::ETPCE::Expr< LogOp< ExprT > >
Sacado::ETV::Expr< MaxOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< MaxOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETV::Expr< MaxOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETPCE::Expr< MaxOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETV::Expr< MaxOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETPCE::Expr< MaxOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< MinOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< MinOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETV::Expr< MinOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETPCE::Expr< MinOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETV::Expr< MinOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETPCE::Expr< MinOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< MultiplicationOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< MultiplicationOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETV::Expr< MultiplicationOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETPCE::Expr< MultiplicationOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETV::Expr< MultiplicationOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETPCE::Expr< MultiplicationOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< PowerOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< PowerOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETV::Expr< PowerOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETPCE::Expr< PowerOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETV::Expr< PowerOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETPCE::Expr< PowerOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< SinhOp< ExprT > >
Sacado::ETPCE::Expr< SinhOp< ExprT > >
Sacado::ETV::Expr< SinOp< ExprT > >
Sacado::ETPCE::Expr< SinOp< ExprT > >
Sacado::ETV::Expr< SqrtOp< ExprT > >
Sacado::ETPCE::Expr< SqrtOp< ExprT > >
Sacado::ETV::Expr< SubtractionOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETPCE::Expr< SubtractionOp< Expr< T1 >, Expr< T2 > > >
Sacado::ETV::Expr< SubtractionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETPCE::Expr< SubtractionOp< Expr< T1 >, typename Expr< T1 >::value_type > >
Sacado::ETV::Expr< SubtractionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETPCE::Expr< SubtractionOp< typename Expr< T2 >::value_type, Expr< T2 > > >
Sacado::ETV::Expr< TanhOp< ExprT > >
Sacado::ETPCE::Expr< TanhOp< ExprT > >
Sacado::ETV::Expr< TanOp< ExprT > >
Sacado::ETPCE::Expr< TanOp< ExprT > >
Sacado::ETV::Expr< UnaryMinusOp< ExprT > >
Sacado::ETPCE::Expr< UnaryMinusOp< ExprT > >
Sacado::ETV::Expr< UnaryPlusOp< ExprT > >
Sacado::ETPCE::Expr< UnaryPlusOp< ExprT > >
Sacado::ETPCE::ExprQuadFuncWrapper< NN, ExprT >
Sacado::ETV::FAbsOp< ExprT >
Sacado::MP::FAbsOp< T >
Sacado::ETPCE::FAbsOp< ExprT >
Stokhos::FlatLTBSparse3Tensor< ordinal_type, value_type >
Stokhos::FlatLTBSparse3TensorNode< ordinal_type >
Stokhos::FlatSparse3Tensor< ValueType, DeviceType >Sparse product tensor with replicated entries to provide subsets with a given coordinate
Stokhos::FlatSparse3Tensor_kji< ValueType, DeviceType >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 >
Stokhos::ForUQTKOrthogPolyExpansion< ordinal_type, value_type >
Stokhos::FullyAssembledOperatorAn Epetra operator representing the block stochastic Galerkin operator generated by fully assembling the matrix
Stokhos::FullyAssembledPreconditionerA stochastic preconditioner based on applying a preconditioner to the fully assembled operator
Stokhos::GaussPattersonExponentialGrowthRule< value_type >An exponential growth rule for Gauss-Patterson
Stokhos::GaussPattersonLegendreBasis< ordinal_type, value_type >Legendre polynomial basis using Gauss-Patterson quadrature points
Stokhos::GMRESDivisionExpansionStrategy< ordinal_type, value_type, node_type >Strategy interface for computing PCE of a/b using only b[0]
Stokhos::GramSchmidtBasis< ordinal_type, value_type >Transforms a non-orthogonal multivariate basis to an orthogonal one using the Gram-Schmit procedure
Stokhos::GrowthRule< value_type >Interface for abstract growth rules
Stokhos::GSPreconditioner< ordinal_type, value_type >
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::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::IdentityGrowthRule< value_type >A growth rule that is the identity
Stokhos::IfpackPreconditionerFactoryA factory for building Ifpack preconditioners
Stokhos::InterlacedOperatorAn 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::InversePreconditioner< ordinal_type, value_type >
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< ETV::Expr< T > >Specialization of IsADType to Expr types
Sacado::IsADType< ETV::Vector2< T, S > >Specialization of IsADType to Vector2 types
Sacado::IsADType< ETV::Vector< T, S > >Specialization of IsADType to Vector 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::IsEqual< ETPCE::OrthogPoly< T, S > >Specialization of IsEqual to OrthogPoly types
Sacado::IsEqual< ETV::Vector2< T, S > >Specialization of IsEqual to Vector2 types
Sacado::IsEqual< ETV::Vector< T, S > >Specialization of IsEqual to Vector types
Sacado::IsEqual< MP::Vector< S > >Specialization of IsEqual to Vector types
Sacado::IsEqual< PCE::OrthogPoly< T, S > >Specialization of IsEqual to OrthogPoly types
Stokhos::IsScalarType< T >Base template specification for IsScalarType
Stokhos::IsScalarType2< T >Base template specification for IsScalarType
Stokhos::IsScalarType2< double >
Stokhos::IsScalarType2< float >
Stokhos::IsScalarType2< int >
Stokhos::IsScalarType2< long >
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< ETV::Expr< T > >Specialization of IsADType to Expr types
Sacado::IsScalarType< ETV::Vector2< T, S > >Specialization of IsADType to Vector2 types
Sacado::IsScalarType< ETV::Vector< T, S > >Specialization of IsADType to Vector 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::IsStaticallySized< ETPCE::OrthogPoly< T, S > >Specialization of IsStaticallySized to OrthogPoly types
Sacado::IsStaticallySized< PCE::OrthogPoly< T, S > >Specialization of IsStaticallySized to OrthogPoly types
Stokhos::TotalOrderIndexSet< ordinal_t >::IteratorIterator class for iterating over elements of the index set
Stokhos::AnisotropicTotalOrderIndexSet< ordinal_t >::IteratorIterator class for iterating over elements of the index set
Stokhos::TensorProductIndexSet< ordinal_t >::IteratorIterator class for iterating over elements of the index set
Stokhos::JacobiBasis< ordinal_type, value_type >Jacobi polynomial basis
Stokhos::JacobiPreconditioner< ordinal_type, value_type >
Stokhos::KLMatrixFreeOperatorAn Epetra operator representing the block stochastic Galerkin operator
Stokhos::KLReducedMatrixFreeOperatorAn Epetra operator representing the block stochastic Galerkin operator
Stokhos::KroneckerProductPreconditionerAn Epetra operator representing applying the mean in a block stochastic Galerkin expansion
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 >
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
cusp::block_multilevel< MatrixType, SmootherType, SolverType >::level
Stokhos::LexicographicBlockSparse3Tensor< ValueType, DeviceType >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
Stokhos::LinearGrowthRule< value_type >A linear growth rule
Stokhos::LinearSparse3Tensor< ValueType, DeviceType, BlockSize >Sparse product tensor with replicated entries to provide subsets with a given coordinate
Stokhos::LocalStorage< ordinal_t, value_t, Num, device_t >Statically allocated storage class
Stokhos::LocalStorage< ordinal_t, value_t, 1, device_t >Statically allocated storage class
Stokhos::LocalStorage< ordinal_t, value_t, 2, device_t >Statically allocated storage class
Stokhos::LocalStorage< ordinal_t, value_t, 4, device_t >Statically allocated storage class
Stokhos::LocalStorage< ordinal_t, value_t, 8, device_t >Statically allocated storage class
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
Sacado::ETV::Log10Op< ExprT >
Sacado::MP::Log10Op< T >
Sacado::ETPCE::Log10Op< ExprT >
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
Sacado::ETV::LogOp< ExprT >
Sacado::MP::LogOp< T >
Sacado::ETPCE::LogOp< ExprT >
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
Stokhos::make_tuple_N< N, array_type >
Stokhos::make_tuple_N< 1, array_type >
Stokhos::make_tuple_N< 2, array_type >
Stokhos::make_tuple_N< 3, array_type >
Stokhos::make_tuple_N< 4, array_type >
Stokhos::MatrixFreeOperatorAn Epetra operator representing the block stochastic Galerkin operator
Stokhos::MatrixMarketWriter< MatrixValue, Kokkos::Cuda >
Stokhos::MatrixMarketWriter< MatrixValue, Kokkos::Threads >
Sacado::ETV::MaxOp< ExprT1, ExprT2 >
Sacado::ETPCE::MaxOp< ExprT1, ExprT2 >
Sacado::MP::MaxOp< T1, T2 >
Sacado::MP::MaxOp< T1, typename T1::value_type >
Sacado::MP::MaxOp< typename T2::value_type, T2 >
Stokhos::MeanBasedDivisionExpansionStrategy< ordinal_type, value_type, node_type >Strategy interface for computing PCE of a/b using only b[0]
Stokhos::MeanBasedPreconditionerA stochastic preconditioner based on applying the inverse of the mean
Sacado::MP::MinOp< T1, T2 >
Sacado::ETV::MinOp< ExprT1, ExprT2 >
Sacado::ETPCE::MinOp< ExprT1, ExprT2 >
Sacado::MP::MinOp< T1, typename T1::value_type >
Sacado::MP::MinOp< typename T2::value_type, T2 >
Stokhos::MLPreconditionerFactoryA factory for building ML preconditioners
Stokhos::MMultiply< CrsMatrix< double, Kokkos::Cuda >, Kokkos::View< double **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< double **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::MMultiply< CrsMatrix< double, Kokkos::Cuda >, Kokkos::View< double[], Kokkos::Cuda >, Kokkos::View< double[], Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::MMultiply< CrsMatrix< float, Kokkos::Cuda >, Kokkos::View< float **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< float **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::MMultiply< CrsMatrix< float, Kokkos::Cuda >, Kokkos::View< float[], Kokkos::Cuda >, Kokkos::View< float[], Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::MMultiply< CrsMatrix< MatrixValue, Kokkos::Threads >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Threads >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Threads >, DefaultSparseMatOps >
Stokhos::MMultiply< CrsMatrix< MatrixValue, Kokkos::Threads >, Kokkos::View< VectorValue[], Kokkos::Threads >, Kokkos::View< VectorValue[], Kokkos::Threads >, DefaultSparseMatOps >
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::MonoProjPCEBasis< ordinal_type, value_type >Generates three-term recurrence using the Lanczos procedure applied to a polynomial chaos expansion in another basis
Stokhos::MortonZLess< term_type >A comparison functor implementing a strict weak ordering based Morton Z-ordering
Stokhos::MPBlockDiagonalPreconditionerA multi-point preconditioner based on applying the inverse of the diagonal
Stokhos::MPInverseModelEvaluatorNonlinear, inverse multi-point ModelEvaluator
Stokhos::MPMeanBasedPreconditionerA multi-point preconditioner based on applying the inverse of the mean
Stokhos::MPModelEvaluatorMulti-point model evaluator
Stokhos::MPModelEvaluatorAdapterModelEvaluator adapter that implements the multi-point evaluations through sampling
Stokhos::MPPreconditionerAn abstract class to represent a generic stochastic Galerkin preconditioner as an Epetra_Operator
Stokhos::MPPreconditionerFactoryFactory for generating stochastic Galerkin preconditioners
Stokhos::MultiIndex< ordinal_t >A multidimensional index
Sacado::ETPCE::MultiplicationOp< ExprT1, ExprT2 >
Sacado::ETV::MultiplicationOp< ExprT1, ExprT2 >
Sacado::MP::MultiplicationOp< T1, T2 >
Sacado::MP::MultiplicationOp< T1, typename T1::value_type >
Sacado::MP::MultiplicationOp< typename T2::value_type, T2 >
Stokhos::Multiply< BlockCrsMatrix< BlockSpec, MatrixValue, Kokkos::Cuda >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::Multiply< BlockCrsMatrix< BlockSpec, MatrixValue, Kokkos::Threads >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Threads >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Threads >, DefaultSparseMatOps >
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 >, DefaultSparseMatOps >
Stokhos::Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::Multiply< BlockCrsMatrix< FlatSparse3Tensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >
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 >, DefaultSparseMatOps >
Stokhos::Multiply< BlockCrsMatrix< LexicographicBlockSparse3Tensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >
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 >, DefaultSparseMatOps >
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 >, DefaultSparseMatOps >
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 >, DefaultSparseMatOps >
Stokhos::Multiply< BlockCrsMatrix< TiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::Multiply< CooProductTensor< ValueType, Kokkos::Threads, Pack >, void, void, DefaultSparseMatOps >
Stokhos::Multiply< CrsMatrix< double, Kokkos::Cuda >, Kokkos::View< double[], Kokkos::Cuda >, Kokkos::View< double[], Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::Multiply< CrsMatrix< float, Kokkos::Cuda >, Kokkos::View< float[], Kokkos::Cuda >, Kokkos::View< float[], Kokkos::Cuda >, DefaultSparseMatOps >
Stokhos::Multiply< CrsMatrix< MatrixValue, Kokkos::Threads >, Kokkos::View< VectorValue[], Kokkos::Threads >, Kokkos::View< VectorValue[], Kokkos::Threads >, DefaultSparseMatOps >
Stokhos::Multiply< CrsProductTensor< ValueType, Kokkos::Threads >, void, void, DefaultSparseMatOps >
Stokhos::Multiply< FlatSparse3Tensor< ValueType, Kokkos::Threads >, void, void, DefaultSparseMatOps >
Stokhos::Multiply< FlatSparse3Tensor_kji< ValueType, Kokkos::Threads >, void, void, DefaultSparseMatOps >
Stokhos::Multiply< LexicographicBlockSparse3Tensor< ValueType, Kokkos::Threads >, void, void, DefaultSparseMatOps >
Stokhos::Multiply< LinearSparse3Tensor< ValueType, Kokkos::Threads, BlockSize >, void, void, DefaultSparseMatOps >
Stokhos::Multiply< StochasticProductTensor< ValueType, TensorType, Kokkos::Threads > >
Stokhos::Multiply< SymmetricDiagonalSpec< Kokkos::Cuda >, void, void, DefaultSparseMatOps >
Stokhos::Multiply< SymmetricDiagonalSpec< Kokkos::Threads >, void, void, DefaultSparseMatOps >
Stokhos::Multiply< TiledCrsProductTensor< ValueType, Kokkos::Threads >, void, void, DefaultSparseMatOps >
Belos::MultiVecTraits< BaseScalar, Tpetra::MultiVector< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node > >Specialization of Tpetra MultiVecTraits for PCE scalar types
Stokhos::KL::OneDEigenFunction< value_type >Abstract base class for one-dimensional eigenfunctions
Stokhos::KL::OneDEigenPair< value_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::Operator< ordinal_type, value_type >
Belos::OperatorTraits< BaseScalar, Tpetra::MultiVector< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node >, Tpetra::Operator< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node > >Partial specialization of OperatorTraits for Tpetra::Operator
Stokhos::OrthogonalizationFactory< ordinal_type, value_type >Encapsulate various orthogonalization (ie QR) methods
Stokhos::OrthogPolyApprox< ordinal_type, value_type, storage_type >Class to store coefficients of a projection onto an orthogonal polynomial basis
Stokhos::OrthogPolyBasis< ordinal_type, value_type >Abstract base class for multivariate orthogonal polynomials
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::ParallelData
Stokhos::PCECovarianceOpAn Epetra operator representing the covariance operator of a polynomial chaos expansion
Stokhos::PecosOneDOrthogPolyBasis< ordinal_type, value_type >Implementation of OneDOrthogPolyBasis via Pecos
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
Sacado::ETV::PowerOp< ExprT1, ExprT2 >
Sacado::MP::PowerOp< T1, T2 >
Sacado::ETPCE::PowerOp< ExprT1, ExprT2 >
Sacado::MP::PowerOp< T1, typename T1::value_type >
Sacado::MP::PowerOp< typename T2::value_type, T2 >
Stokhos::PreconditionerFactoryAn class for building preconditioners
Stokhos::ProductBasis< ordinal_type, value_type >Abstract base class for multivariate orthogonal polynomials generated from tensor products of univariate polynomials
Stokhos::ProductBasisUtilsUtilities 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::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< value_type >Container for multi-dimensional product of 1-D eigenfunctions/values
Stokhos::KL::ProductEigenPairGreater< value_type >Predicate class for sorting product eigenfunctions based on eigenvalue
Stokhos::ProductEpetraMultiVectorA container class storing products of Epetra_MultiVector's
Stokhos::ProductEpetraMultiVectorOperatorA container class for products of Epetra_Vector's
Stokhos::ProductEpetraOperatorA container class for products of Epetra_Vector's
Stokhos::ProductEpetraVectorA container class for products of Epetra_Vector's
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::Multiply< BlockCrsMatrix< TiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >::ProductTensorLoop
Stokhos::Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, DefaultSparseMatOps >::ProductTensorLoop
Sacado::Promote< ETPCE::OrthogPoly< L, S >, R >Specialization of Promote to OrthogPoly types
Sacado::Promote< ETPCE::OrthogPoly< T, S >, ETPCE::OrthogPoly< T, S > >Specialization of Promote to Taylor types
Sacado::Promote< ETV::Vector2< L, S >, R >Specialization of Promote to Vector2 types
Sacado::Promote< ETV::Vector2< T, S >, ETV::Vector2< T, S > >Specialization of Promote to Taylor types
Sacado::Promote< ETV::Vector< L, S >, R >Specialization of Promote to Vector types
Sacado::Promote< ETV::Vector< T, S >, ETV::Vector< T, S > >Specialization of Promote to Taylor types
Sacado::Promote< L, ETPCE::OrthogPoly< R, S > >Specialization of Promote to OrthogPoly types
Sacado::Promote< L, ETV::Vector2< R, S > >Specialization of Promote to Vector2 types
Sacado::Promote< L, ETV::Vector< R, S > >Specialization of Promote to Vector types
Sacado::Promote< L, MP::Vector< S > >Specialization of Promote to Vector types
Sacado::Promote< L, PCE::OrthogPoly< R, S > >Specialization of Promote to OrthogPoly types
Sacado::Promote< MP::Vector< S >, MP::Vector< S > >Specialization of Promote to Taylor types
Sacado::Promote< MP::Vector< S >, R >Specialization of Promote to Vector types
Sacado::Promote< PCE::OrthogPoly< L, S >, R >Specialization of Promote to OrthogPoly types
Sacado::Promote< PCE::OrthogPoly< T, S >, PCE::OrthogPoly< T, S > >Specialization of Promote to OrthogPoly types
Stokhos::PseudoSpectralOperator< ordinal_t, value_t, point_compare_type >An operator interface for building pseudo-spectral approximations
Stokhos::PseudoSpectralOperatorFactory< ordinal_type, value_type >Factory for building multivariate quadrature strategies
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::Quadrature< ordinal_type, value_type >Abstract base class for quadrature methods
Stokhos::QuadratureFactory< ordinal_type, value_type >Factory for building multivariate quadrature strategies
Stokhos::QuadraturePseudoSpectralOperator< ordinal_t, value_t, point_compare_type >An operator for building pseudo-spectral coefficients using an arbitrary quadrature rule
Stokhos::RCB< TupleType >
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) \]

for $k=0,\dots,P$ where $\psi_{-1}(x) = 0$, $\psi_{0}(x) = 1/\gamma_0$, and $\beta_{0} = (1,1) = \int d\lambda$

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::ReducedPCEBasis< ordinal_type, value_type >Abstract base class for reduced basis strategies built from polynomial chaos expansions in some other basis
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
Stokhos::ResponseStatisticModelEvaluatorModelEvaluator providing statistic response functions
Stokhos::RysBasis< ordinal_type, value_type >Rys polynomial basis
cusp::precond::aggregation::sa_level< MatrixType >
Sacado::ScalarType< ETPCE::Expr< T > >Specialization of ScalarType to Expr types
Sacado::ScalarType< ETPCE::OrthogPoly< T, S > >Specialization of ScalarType to OrthogPoly types
Sacado::ScalarType< ETV::Expr< T > >Specialization of ScalarType to Expr types
Sacado::ScalarType< ETV::Vector2< T, S > >Specialization of ScalarType to Vector2 types
Sacado::ScalarType< ETV::Vector< T, S > >Specialization of ScalarType to Vector types
Sacado::ScalarType< MP::Expr< T > >Specialization of ScalarType to Expr types
Sacado::ScalarType< MP::Vector< S > >Specialization of ScalarType to Vector types
Sacado::ScalarType< PCE::OrthogPoly< T, S > >Specialization of ScalarType to OrthogPoly 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< ETV::Expr< T > >Specialization of ScalarValue to Expr types
Sacado::ScalarValue< ETV::Vector2< T, S > >Specialization of ScalarValue to Vector2 types
Sacado::ScalarValue< ETV::Vector< T, S > >Specialization of ScalarValue to Vector 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
Stokhos::SchurPreconditioner< ordinal_type, value_type >
Stokhos::SGInverseModelEvaluatorNonlinear, inverse stochastic Galerkin ModelEvaluator
Stokhos::SGModelEvaluatorNonlinear, stochastic Galerkin ModelEvaluator
Stokhos::SGModelEvaluator_AdaptiveNonlinear, stochastic Galerkin ModelEvaluator that constructs an adapted Jacobian
Stokhos::SGModelEvaluator_InterlacedNonlinear, stochastic Galerkin ModelEvaluator that constructs a interlaced Jacobian
Stokhos::SGOperatorAn abstract class to represent a generic stochastic Galerkin operator as an Epetra_Operator
Stokhos::SGOperatorFactoryFactory for generating stochastic Galerkin preconditioners
Stokhos::SGPreconditionerAn abstract class to represent a generic stochastic Galerkin preconditioner as an Epetra_Operator
Stokhos::SGPreconditionerFactoryFactory for generating stochastic Galerkin preconditioners
Stokhos::SGQuadModelEvaluatorModelEvaluator adaptor that implements the stochastic Galerkin residual and Jacobian computations using quadrature
Stokhos::SGQuadMPModelEvaluatorModelEvaluator adaptor that implements the stochastic Galerkin residual and Jacobian computations using quadrature
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
Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::sinh_quad_func
Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::sinh_quad_func
Sacado::ETV::SinhOp< ExprT >
Sacado::ETPCE::SinhOp< ExprT >
Sacado::MP::SinhOp< T >
Sacado::ETPCE::SinOp< ExprT >
Sacado::MP::SinOp< T >
Sacado::ETV::SinOp< ExprT >
Stokhos::SmolyakBasis< ordinal_type, value_type, coeff_compare_type >Multivariate orthogonal polynomial basis generated from a Smolyak sparse grid
Stokhos::SmolyakBasis< ordinal_type, value_type, coeff_compare_type >::SmolyakPredicate< tp_predicate_type >Predicate functor for building sparse triple products
Stokhos::SmolyakPseudoSpectralOperator< ordinal_t, value_t, point_compare_type >An operator for building pseudo-spectral coefficients using a sparse Smolyak construction
Stokhos::Sparse3Tensor< ordinal_type, value_type >Data structure storing a sparse 3-tensor C(i,j,k) in a a compressed format
Stokhos::SparseArray< ordinal_type, val_type >Container for a "sparse" array
Stokhos::SparseArrayIterator< index_iterator_type, value_iterator_type >Bi-directional iterator for traversing a sparse array
Stokhos::SparseArrayReverseIterator< index_iterator_type, value_iterator_type >Bi-directional reverse iterator for traversing a sparse array
Stokhos::SparseGridQuadrature< ordinal_type, value_type >Defines quadrature for a tensor product basis by Smolyak sparse grids
Stokhos::SPDDenseDirectDivisionExpansionStrategy< ordinal_type, value_type, node_type >Strategy interface for computing PCE of a/b using only b[0]
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
Sacado::ETPCE::SqrtOp< ExprT >
Sacado::MP::SqrtOp< T >
Sacado::ETV::SqrtOp< ExprT >
Stokhos::StandardStorage< ordinal_type, value_type >
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
Stokhos::StaticStandardStorage< ordinal_type, value_type, Num >Statically allocated storage class
Stokhos::StaticStorage< ordinal_t, value_t, Num, device_t >Statically allocated storage class
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::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::StieltjesPCEBasis< ordinal_type, value_type >Generates three-term recurrence using the Discretized Stieltjes procedure applied to a polynomial chaos expansion in another basis
Stokhos::StochasticProductTensor< ValueType, TensorType, Device >Bases defined by combinatorial product of polynomial bases
Sacado::StringName< ETPCE::OrthogPoly< T, S > >Specialization of StringName to OrthogPoly types
Sacado::StringName< ETV::Vector2< T, S > >Specialization of StringName to Vector2 types
Sacado::StringName< ETV::Vector< T, S > >Specialization of StringName to Vector 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::MP::SubtractionOp< T1, T2 >
Sacado::ETV::SubtractionOp< ExprT1, ExprT2 >
Sacado::ETPCE::SubtractionOp< ExprT1, ExprT2 >
Sacado::MP::SubtractionOp< T1, typename T1::value_type >
Sacado::MP::SubtractionOp< typename T2::value_type, T2 >
Stokhos::SymmetricDiagonalSpec< DeviceType >Symmetric diagonal storage for a dense matrix
Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::tan_quad_func
Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::tan_quad_func
Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::tanh_quad_func
Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::tanh_quad_func
Sacado::MP::TanhOp< T >
Sacado::ETV::TanhOp< ExprT >
Sacado::ETPCE::TanhOp< ExprT >
Sacado::ETPCE::TanOp< ExprT >
Sacado::MP::TanOp< T >
Sacado::ETV::TanOp< ExprT >
Stokhos::TensorProductBasis< ordinal_type, value_type, coeff_compare_type >Multivariate orthogonal polynomial basis generated from a tensor product of univariate polynomials
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::TensorProductPseudoSpectralOperator< ordinal_t, value_t, point_compare_type >An operator for building pseudo-spectral coefficients using tensor-product quadrature
Stokhos::TensorProductQuadrature< ordinal_type, value_type >Defines quadrature for a tensor product basis by tensor products of 1-D quadrature rules
Stokhos::TiledCrsProductTensor< ValueType, DeviceType >
Stokhos::QuadOrthogPolyExpansion< ordinal_type, value_type, node_type >::times_quad_func
Stokhos::PseudoSpectralOrthogPolyExpansion< ordinal_type, value_type, point_compare_type, node_type >::times_quad_func
Stokhos::TinyVec< ValueType, N, UseIntrinsics, Mask >
Stokhos::TinyVec< ValueType, N, UseIntrinsics, true >
Stokhos::TotalOrderBasis< ordinal_type, value_type, coeff_compare_type >Multivariate orthogonal polynomial basis generated from a total order tensor product of univariate polynomials
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
Sacado::MP::UnaryMinusOp< T >
Sacado::ETV::UnaryMinusOp< ExprT >
Sacado::ETPCE::UnaryMinusOp< ExprT >
Sacado::MP::UnaryPlusOp< T >
Sacado::ETPCE::UnaryPlusOp< ExprT >
Sacado::ETV::UnaryPlusOp< ExprT >
Stokhos::Update< ValueType, VectorValue >
Stokhos::UserDefinedQuadrature< ordinal_type, value_type >
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< ETV::Expr< T > >Specialization of Value to Expr types
Sacado::Value< ETV::Vector2< T, S > >Specialization of Value to Vector2 types
Sacado::Value< ETV::Vector< T, S > >Specialization of Value to Vector 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::ValueType< ETPCE::Expr< T > >Specialization of ValueType to Expr types
Sacado::ValueType< ETPCE::OrthogPoly< T, S > >Specialization of ValueType to OrthogPoly types
Sacado::ValueType< ETV::Expr< T > >Specialization of ValueType to Expr types
Sacado::ValueType< ETV::Vector2< T, S > >Specialization of ValueType to Vector2 types
Sacado::ValueType< ETV::Vector< T, S > >Specialization of ValueType to Vector 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
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::ViewStorage< ordinal_t, value_t, device_t >Dynamic storage with view semantics and contiguous access
Stokhos::ViewStridedStorage< ordinal_t, value_t, device_t >Dynamic storage with view semantics and strided access
Stokhos::WeightedVectorSpace< ord_type, val_type >
KokkosClassic::WeightNormOp< Sacado::PCE::OrthogPoly< ScalarType, StorageType > >
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator