Stokhos Package Browser (Single Doxygen Collection): Class Index

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

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages

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

A

device_is_cuda (Tpetra::KokkosRefactor::Details)

IsScalarType< MP::Expr< T > > (Sacado)

PackArrayMultiColumnVariableStride< Kokkos::View< Sacado::UQ::PCE< DS > *, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, IdxView, ColView > (Tpetra::KokkosRefactor::Details)

SparseArray (Stokhos)

DeviceConfig (Stokhos)

IsScalarType< MP::Vector< S > > (Sacado)

PackArraySingleColumn< Kokkos::View< Sacado::MP::Vector< DS > *, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, IdxView > (Tpetra::KokkosRefactor::Details)

SparseArrayIterator (Stokhos)

AbstractPreconditionerFactory (Stokhos)

DeviceConfig (Kokkos::Example::FENL)

IsScalarType< PCE::OrthogPoly< T, S > > (Sacado)

PackArraySingleColumn< Kokkos::View< Sacado::UQ::PCE< DS > *, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, IdxView > (Tpetra::KokkosRefactor::Details)

SparseArrayReverseIterator (Stokhos)

QuadOrthogPolyExpansion::acos_quad_func (Stokhos)

DeviceForNode (Stokhos)

IsScalarType< UQ::PCE< S > > (Sacado)

PackTraits< Sacado::UQ::PCE< S >, D > (Tpetra::Details)

SPDDenseDirectDivisionExpansionStrategy (Stokhos)

PseudoSpectralOrthogPolyExpansion::acos_quad_func (Stokhos)

DeviceForNode2 (Stokhos)

IsStaticallySized< ETPCE::OrthogPoly< T, S > > (Sacado)

ParallelData (Stokhos)

QuadOrthogPolyExpansion::sqrt_quad_func (Stokhos)

DerivOrthogPolyExpansion::acos_quad_func (Stokhos)

DeviceForNode2< Kokkos::Compat::KokkosDeviceWrapperNode< Device > > (Stokhos)

IsStaticallySized< MP::Vector< S > > (Sacado)

PCE (Sacado::UQ)

PseudoSpectralOrthogPolyExpansion::sqrt_quad_func (Stokhos)

ACosFunc (QuadExpansionUnitTest)

DeviceProp (Stokhos)

IsStaticallySized< PCE::OrthogPoly< T, S > > (Sacado)

SqrtFunc (DerivExpansionUnitTest)

ACosFunc (PseudoSpectralExpansionUnitTest)

DiagEpetraOp (Stokhos)

IsStaticallySized< UQ::PCE< S > > (Sacado)

PCEAllocation (Kokkos::Experimental::Impl)

SqrtFunc (QuadExpansionUnitTest)

ACosFunc (ForUQTKExpansionUnitTest)

DiagonalOperator (Stokhos)

TensorProductIndexSet::Iterator (Stokhos)

PCEArrayHelper (Teuchos::details)

SqrtFunc (ForUQTKExpansionUnitTest)

ACosFunc (DerivExpansionUnitTest)

DiagPreconditioner (Stokhos)

AnisotropicTotalOrderIndexSet::Iterator (Stokhos)

PCEArrayHelper< Stokhos::DynamicStorage< Ordinal, Value, Device > > (Teuchos::details)

SqrtFunc (PseudoSpectralExpansionUnitTest)

QuadOrthogPolyExpansion::acosh_quad_func (Stokhos)

DeviceConfig::Dim3 (Stokhos)

TotalOrderIndexSet::Iterator (Stokhos)

PCEAtomicFunctor (Test)

StandardStorage (Stokhos)

PseudoSpectralOrthogPolyExpansion::acosh_quad_func (Stokhos)

DeviceConfig::Dim3 (Kokkos::Example::FENL)

J

PCEAllocation::PCEConstruct (Kokkos::Experimental::Impl)

StaticArrayTraits (Stokhos)

DerivOrthogPolyExpansion::acosh_quad_func (Stokhos)

DirichletComputation (Kokkos::Example::FENL)

PCECovarianceOp (Stokhos)

StaticArrayTraits< T, D, false > (Stokhos)

ACoshFunc (QuadExpansionUnitTest)

DirichletComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, Kokkos::Example::FENL::CrsMatrix< ScalarType, ExecutionSpace > > (Kokkos::Example::FENL)

JacobiBasis (Stokhos)

PCEScalarTraitsImp (Sacado::UQ)

StaticArrayTraits< T, D, true > (Stokhos)

ACoshFunc (PseudoSpectralExpansionUnitTest)

DiscretizedStieltjesBasis (Stokhos)

JacobiPreconditioner (Stokhos)

PCESerializationTraitsImp (Sacado::UQ)

StaticFixedStandardStorage (Stokhos)

ACoshFunc (ForUQTKExpansionUnitTest)

QuadOrthogPolyExpansion::div_quad_func (Stokhos)

JacobiTester (Stokhos)

PCESerializerImp (Sacado::UQ)

StaticFixedStorage (Stokhos)

ACoshFunc (DerivExpansionUnitTest)

PseudoSpectralOrthogPolyExpansion::div_quad_func (Stokhos)

K

PCEValueTypeConversionTraitsImp (Sacado::UQ)

StaticSize< MP::Vector< S > > (Sacado)

ACoshFunc (ConstantExpansionUnitTest)

DivideFunc (QuadExpansionUnitTest)

Perf

StaticStandardStorage (Stokhos)

ACoshFunc (AlgebraicExpansionUnitTest)

DivideFunc (PseudoSpectralExpansionUnitTest)

MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > >::Kernel (Stokhos)

performance_test_driver (unit_test)

StaticStorage (Stokhos)

AdaptivityManager (Stokhos)

DivideFunc (ForUQTKExpansionUnitTest)

twoD_diffusion_problem::KL_Diffusion_Func

performance_test_driver< Scalar, Kokkos::Cuda > (unit_test)

StatusTestGenResNorm (Belos)

AddDiagonalValuesAtomicKernel

DivideFunc (DerivExpansionUnitTest)

KLMatrixFreeOperator (Stokhos)

PerformanceDriverOp

StatusTestGenResNorm< Sacado::MP::Vector< Storage >, MV, OP > (Belos)

AddDiagonalValuesKernel

DivideFunc (AlgebraicExpansionUnitTest)

KLReducedMatrixFreeOperator (Stokhos)

PermuteArrayMultiColumn< Kokkos::View< Sacado::MP::Vector< DS > **, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, DstIdxView, SrcIdxView > (Tpetra::KokkosRefactor::Details)

Stieltjes_Cos_Func (StieltjesCosTest)

AlgebraicOrthogPolyExpansion (Stokhos)

DivisionExpansionStrategy (Stokhos)

Kokkos_MV_Multiply_Op

PermuteArrayMultiColumn< Kokkos::View< Sacado::UQ::PCE< DS > **, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, DstIdxView, SrcIdxView > (Tpetra::KokkosRefactor::Details)

Stieltjes_Exp_Func (StieltjesExpTest)

aligned_allocator (Stokhos)

DivisionOp (Sacado::ETPCE)

KroneckerProductPreconditioner (Stokhos)

PermuteArrayMultiColumnVariableStride< Kokkos::View< Sacado::MP::Vector< DS > **, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, DstIdxView, SrcIdxView, DstColView, SrcColView > (Tpetra::KokkosRefactor::Details)

stieltjes_pce_quad_func

aligned_allocator< const T > (Stokhos)

ds_array (Stokhos)

L

PermuteArrayMultiColumnVariableStride< Kokkos::View< Sacado::UQ::PCE< DS > **, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, DstIdxView, SrcIdxView, DstColView, SrcColView > (Tpetra::KokkosRefactor::Details)

Stieltjes_PCE_Setup

amg_container (cusp::precond::aggregation)

ds_array< T, true > (Stokhos)

PlusFunc (QuadExpansionUnitTest)

Stieltjes_Sin_Func (StieltjesSinTest)

amg_container< IndexType, ValueType, cusp::device_memory > (cusp::precond::aggregation)

DynamicStorage (Stokhos)

Lanczos (Stokhos)

PlusFunc (PseudoSpectralExpansionUnitTest)

StieltjesBasis (Stokhos)

amg_container< IndexType, ValueType, cusp::host_memory > (cusp::precond::aggregation)

DynamicStridedStorage (Stokhos)

Lanczos_Cos_Func

PlusFunc (ForUQTKExpansionUnitTest)

StieltjesCoupledSolver

AnalyzeShape< Sacado::MP::Vector< StorageType > > (Kokkos::Impl)

DynamicThreadedStorage (Stokhos)

Lanczos_Exp_Func

PlusFunc (AlgebraicExpansionUnitTest)

StieltjesGramSchmidtBuilder (Stokhos)

AND (MaskLogic)

DynArrayTraits (Stokhos)

lanczos_pce_quad_func

PlusFunc (DerivExpansionUnitTest)

StieltjesPCEBasis (Stokhos)

AnisotropicTotalOrderIndexSet (Stokhos)

DynArrayTraits< T, device_t, false > (Stokhos)

Lanczos_PCE_Setup

QuadOrthogPolyExpansion::pow_quad_func (Stokhos)

StochasticProductTensor (Stokhos)

ViewStorage::apply (Stokhos)

E

Lanczos_Sin_Func

PseudoSpectralOrthogPolyExpansion::pow_quad_func (Stokhos)

Stokhos_MV_Multiply_Op

StaticStorage::apply (Stokhos)

LanczosPCEBasis (Stokhos)

PowFunc (ForUQTKExpansionUnitTest)

StokhosViewFill (Kokkos::Impl)

StaticFixedStorage::apply (Stokhos)

OneDExponentialCovarianceFunction::EigFuncCos (Stokhos::KL)

LanczosProjPCEBasis (Stokhos)

PowFunc (QuadExpansionUnitTest)

StringName< ETPCE::OrthogPoly< T, S > > (Sacado)

DynamicStridedStorage::apply (Stokhos)

OneDExponentialCovarianceFunction::EigFuncSin (Stokhos::KL)

LAPACK< OrdinalType, Sacado::MP::Vector< Storage > > (Teuchos)

PowFunc (PseudoSpectralExpansionUnitTest)

StringName< MP::Vector< S > > (Sacado)

DynamicStorage::apply (Stokhos)

ElementComputation (Kokkos::Example::FENL)

LAPACK< OrdinalType, Sacado::UQ::PCE< Storage > > (Teuchos)

PowFunc (DerivExpansionUnitTest)

StringName< PCE::OrthogPoly< T, S > > (Sacado)

ExponentialKLCoefficient::apply (Kokkos::Example::FENL)

ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, Analytic, CoeffFunctionType > (Kokkos::Example::FENL)

LapackSupportsScalar (Belos::Details)

PreconditionerFactory (Stokhos)

StringName< Stokhos::DynamicStorage< ordinal_t, value_t, device_t > > (Sacado)

StaticStandardStorage::apply (Stokhos)

ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadElement, CoeffFunctionType > (Kokkos::Example::FENL)

LapackSupportsScalar< Sacado::MP::Vector< S > > (Belos::Details)

ProductBasis (Stokhos)

StringName< Stokhos::DynamicStridedStorage< ordinal_t, value_t, device_t > > (Sacado)

StaticFixedStandardStorage::apply (Stokhos)

ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadElementOptimized, CoeffFunctionType > (Kokkos::Example::FENL)

LegendreBasis (Stokhos)

ProductBasisUtils (Stokhos)

StringName< Stokhos::DynamicThreadedStorage< ordinal_t, value_t, device_t > > (Sacado)

StandardStorage::apply (Stokhos)

ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadQuadPoint, CoeffFunctionType > (Kokkos::Example::FENL)

block_multilevel::level (cusp)

ProductContainer (Stokhos)

StringName< Stokhos::StaticFixedStorage< ordinal_t, value_t, Num, device_t > > (Sacado)

StaticFixedStorage::apply_N (Stokhos)

ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, Kokkos::Example::FENL::CrsMatrix< ScalarType, ExecutionSpace >, CoeffFunctionType > (Kokkos::Example::FENL)

LexicographicBlockSparse3Tensor (Stokhos)

ProductContainerTraits (Stokhos)

StringName< Stokhos::StaticStorage< ordinal_t, value_t, Num, device_t > > (Sacado)

DynamicStorage::apply_N (Stokhos)

ElementComputationBase (Kokkos::Example::FENL)

LexicographicTreeBasisNode (Stokhos)

ProductContainerTraits< Epetra_CrsMatrix > (Stokhos)

StringName< Stokhos::ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t > > (Sacado)

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 (Stokhos)

ElementComputationConstantCoefficient (Kokkos::Example::FENL)

LexographicLess (Stokhos)

ProductContainerTraits< Epetra_MultiVector > (Stokhos)

StringName< UQ::PCE< S > > (Sacado)

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 (Stokhos)

EnsembleTraits_m

LinearGrowthRule (Stokhos)

ProductContainerTraits< Epetra_Operator > (Stokhos)

SymmetricDiagonalSpec (Stokhos)

EnsembleTraits_m< Sacado::MP::Vector< S > >

LinearSparse3Tensor (Stokhos)

ProductContainerTraits< Epetra_Vector > (Stokhos)

T

ApplyView< DataType, NoLayout, ExecutionSpace >

EpetraCrsMatrixCloner (Stokhos)

LocalMPVectorView (Kokkos)

ProductEigenPair (Stokhos::KL)

ApproxGaussSeidelPreconditioner (Stokhos)

EpetraMultiVectorCloner (Stokhos)

LocalMPVectorView< View< D, P...>, LocalSize, true > (Kokkos)

ProductEigenPairGreater (Stokhos::KL)

QuadOrthogPolyExpansion::tan_quad_func (Stokhos)

ApproxJacobiPreconditioner (Stokhos)

EpetraMultiVectorOperator (Stokhos)

LocalMPVectorView< ViewType, LocalSize, false > (Kokkos)

ProductEpetraMultiVector (Stokhos)

PseudoSpectralOrthogPolyExpansion::tan_quad_func (Stokhos)

ApproxSchurComplementPreconditioner (Stokhos)

EpetraMultiVectorOperatorOrthogPoly (Stokhos)

LocalReciprocalThreshold (Ifpack2::Details)

ProductEpetraMultiVectorOperator (Stokhos)

TanFunc (DerivExpansionUnitTest)

ArithTraits< Sacado::MP::Vector< S > > (Kokkos::Details)

EpetraMultiVectorOrthogPoly (Stokhos)

LocalReciprocalThreshold< Kokkos::View< Sacado::MP::Vector< S > *, P...>, SizeType > (Ifpack2::Details)

ProductEpetraOperator (Stokhos)

TanFunc (QuadExpansionUnitTest)

ArithTraits< Sacado::UQ::PCE< S > > (Kokkos::Details)

EpetraOperatorCloner (Stokhos)

LocalReciprocalThreshold< Kokkos::View< Sacado::UQ::PCE< S > *, P... >, SizeType > (Ifpack2::Details)

ProductEpetraVector (Stokhos)

TanFunc (ForUQTKExpansionUnitTest)

QuadOrthogPolyExpansion::asin_quad_func (Stokhos)

EpetraOperatorOrthogPoly (Stokhos)

LocalUQPCEView (Kokkos)

ProductLanczosGramSchmidtPCEBasis (Stokhos)

TanFunc (PseudoSpectralExpansionUnitTest)

PseudoSpectralOrthogPolyExpansion::asin_quad_func (Stokhos)

EpetraSparse3Tensor (Stokhos)

LocalUQPCEView< ViewType, LocalSize, 1, false > (Kokkos)

ProductLanczosPCEBasis (Stokhos)

QuadOrthogPolyExpansion::tanh_quad_func (Stokhos)

DerivOrthogPolyExpansion::asin_quad_func (Stokhos)

EpetraVectorCloner (Stokhos)

LocalUQPCEView< ViewType, LocalSize, 1, true > (Kokkos)

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)

PseudoSpectralOrthogPolyExpansion::tanh_quad_func (Stokhos)

ASinFunc (QuadExpansionUnitTest)

EpetraVectorOrthogPoly (Stokhos)

LocalViewTraits (Kokkos::Example::FENL)

Multiply< BlockCrsMatrix< TiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > >::ProductTensorLoop (Stokhos)

TanhFunc (DerivExpansionUnitTest)

ASinFunc (PseudoSpectralExpansionUnitTest)

error_storage_type_is_not_allocateable (Stokhos)

QuadOrthogPolyExpansion::log10_quad_func (Stokhos)

PromotionTraits< L, Sacado::ETPCE::OrthogPoly< T, S > > (Teuchos)

TanhFunc (QuadExpansionUnitTest)

ASinFunc (ForUQTKExpansionUnitTest)

error_storage_type_is_not_resizeable (Stokhos)

PseudoSpectralOrthogPolyExpansion::log10_quad_func (Stokhos)

PromotionTraits< L, Sacado::MP::Vector< S > > (Teuchos)

TanhFunc (PseudoSpectralExpansionUnitTest)

ASinFunc (DerivExpansionUnitTest)

EvenGrowthRule (Stokhos)

Log10Func (QuadExpansionUnitTest)

PromotionTraits< L, Sacado::PCE::OrthogPoly< T, S > > (Teuchos)

TanhFunc (ForUQTKExpansionUnitTest)

QuadOrthogPolyExpansion::asinh_quad_func (Stokhos)

Log10Func (PseudoSpectralExpansionUnitTest)

PromotionTraits< L, Sacado::UQ::PCE< S > > (Teuchos)

PseudoSpectralOrthogPolyExpansion::asinh_quad_func (Stokhos)

QuadOrthogPolyExpansion::exp_quad_func (Stokhos)

Log10Func (ForUQTKExpansionUnitTest)

PromotionTraits< Sacado::ETPCE::OrthogPoly< T, S >, R > (Teuchos)

TensorProductBasis (Stokhos)

DerivOrthogPolyExpansion::asinh_quad_func (Stokhos)

PseudoSpectralOrthogPolyExpansion::exp_quad_func (Stokhos)

Log10Func (DerivExpansionUnitTest)

PromotionTraits< Sacado::ETPCE::OrthogPoly< T, S >, Sacado::ETPCE::OrthogPoly< T, S > > (Teuchos)

TensorProductElement (Stokhos)

ASinhFunc (QuadExpansionUnitTest)

ExpansionFactory (Stokhos)

QuadOrthogPolyExpansion::log_quad_func (Stokhos)

PromotionTraits< Sacado::MP::Vector< S >, R > (Teuchos)

TensorProductIndexSet (Stokhos)

ASinhFunc (PseudoSpectralExpansionUnitTest)

ExpFunc (QuadExpansionUnitTest)

PseudoSpectralOrthogPolyExpansion::log_quad_func (Stokhos)

PromotionTraits< Sacado::MP::Vector< S >, Sacado::MP::Vector< S > > (Teuchos)

TensorProductPredicate (Stokhos)

ASinhFunc (ForUQTKExpansionUnitTest)

ExpFunc (PseudoSpectralExpansionUnitTest)

LogFunc (QuadExpansionUnitTest)

PromotionTraits< Sacado::PCE::OrthogPoly< T, S >, R > (Teuchos)

TensorProductPseudoSpectralOperator (Stokhos)

ASinhFunc (DerivExpansionUnitTest)

ExpFunc (ForUQTKExpansionUnitTest)

LogFunc (PseudoSpectralExpansionUnitTest)

PromotionTraits< Sacado::PCE::OrthogPoly< T, S >, Sacado::PCE::OrthogPoly< T, S > > (Teuchos)

TensorProductQuadrature (Stokhos)

ASinhFunc (ConstantExpansionUnitTest)

ExpFunc (DerivExpansionUnitTest)

LogFunc (DerivExpansionUnitTest)

PromotionTraits< Sacado::UQ::PCE< S >, R > (Teuchos)

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)

ASinhFunc (AlgebraicExpansionUnitTest)

ExponentialKLCoefficient (Kokkos::Example::FENL)

LogFunc (ForUQTKExpansionUnitTest)

PromotionTraits< Sacado::UQ::PCE< S >, Sacado::UQ::PCE< S > > (Teuchos)

SimpleTiledCrsProductTensor::Tile (Stokhos)

QuadOrthogPolyExpansion::atan2_quad_func (Stokhos)

ExponentialOneDEigenFunction (Stokhos::KL)

twoD_diffusion_problem::LogNormal_Diffusion_Func

PseudoBlockCGIter (Belos)

Tile

PseudoSpectralOrthogPolyExpansion::atan2_quad_func (Stokhos)

ExponentialRandomField (Stokhos::KL)

LTBSparse3Tensor (Stokhos)

PseudoBlockCGIter< Sacado::MP::Vector< Storage >, MV, OP > (Belos)

TiledCrsProductTensor (Stokhos)

QuadOrthogPolyExpansion::atan_quad_func (Stokhos)

Expr (Sacado::ETPCE)

M

PseudoSpectralOperator (Stokhos)

NodeNodeGraph::Times (Kokkos::Example::FENL)

PseudoSpectralOrthogPolyExpansion::atan_quad_func (Stokhos)

Expr (Sacado::MP)

PseudoSpectralOperatorFactory (Stokhos)

PseudoSpectralOrthogPolyExpansion::times_quad_func (Stokhos)

DerivOrthogPolyExpansion::atan_quad_func (Stokhos)

Expr< DivisionOp< Expr< T1 >, Expr< T2 > > > (Sacado::ETPCE)

MapGridUnitCube (Kokkos::Example)

PseudoSpectralOrthogPolyExpansion (Stokhos)

QuadOrthogPolyExpansion::times_quad_func (Stokhos)

ATanFunc (QuadExpansionUnitTest)

Expr< DivisionOp< Expr< T1 >, typename Expr< T1 >::value_type > > (Sacado::ETPCE)

Mask

Q

TimesFunc (ForUQTKExpansionUnitTest)

ATanFunc (PseudoSpectralExpansionUnitTest)

Expr< DivisionOp< typename Expr< T2 >::value_type, Expr< T2 > > > (Sacado::ETPCE)

MatrixFreeOperator (Stokhos)

TimesFunc (DerivExpansionUnitTest)

ATanFunc (ForUQTKExpansionUnitTest)

Expr< MultiplicationOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector >

MatrixMarketWriter (Stokhos)

QuadOrthogPolyExpansion (Stokhos)

TimesFunc (QuadExpansionUnitTest)

ATanFunc (DerivExpansionUnitTest)

Expr< MultiplicationOp< Expr< T1 >, Expr< T2 > > > (Sacado::ETPCE)

MatrixMarketWriter< CrsMatrix< MatrixValue, Device, Layout > > (Stokhos)

Quadrature (Stokhos)

TimesFunc (PseudoSpectralExpansionUnitTest)

QuadOrthogPolyExpansion::atanh_quad_func (Stokhos)

Expr< MultiplicationOp< Expr< T1 >, typename Expr< T1 >::value_type > > (Sacado::ETPCE)

MeanBasedDivisionExpansionStrategy (Stokhos)

QuadratureFactory (Stokhos)

TimesFunc (AlgebraicExpansionUnitTest)

PseudoSpectralOrthogPolyExpansion::atanh_quad_func (Stokhos)

Expr< MultiplicationOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector >

MeanBasedPreconditioner (Stokhos)

QuadraturePseudoSpectralOperator (Stokhos)

TinyVec (Stokhos)

DerivOrthogPolyExpansion::atanh_quad_func (Stokhos)

Expr< MultiplicationOp< typename Expr< T2 >::value_type, Expr< T2 > > > (Sacado::ETPCE)

MeanBasedTpetraOperator (Stokhos)

R

TinyVec< ValueType, N, UseIntrinsics, true > (Stokhos)

ATanhFunc (QuadExpansionUnitTest)

Expr< SFadExprTag< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num >, ExprSpecMPVector > (Sacado::Fad)

MeanMultiply (Stokhos)

total_order_predicate (ProductBasisUtilsUnitTest)

ATanhFunc (PseudoSpectralExpansionUnitTest)

ExprAssign< DstType, typename std::enable_if< Sacado::IsStaticallySized< DstType >::value &&std::is_same< typename DstType::expr_spec_type, ExprSpecMPVector >::value >::type > (Sacado::Fad::Exp)

MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > **, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > **, OutputP... > > (Stokhos)

RankTypeSelector

TotalOrderBasis (Stokhos)

ATanhFunc (ForUQTKExpansionUnitTest)

ExprAssign< DstType, typename std::enable_if< std::is_same< typename DstType::expr_spec_type, ExprSpecMPVector >::value >::type > (Sacado::Fad::Exp)

MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > > (Stokhos)

RankTypeSelector< ViewType, OrdinalType, 0 >

TotalOrderIndexSet (Stokhos)

ATanhFunc (DerivExpansionUnitTest)

ExprQuadFuncWrapper (Sacado::ETPCE)

MemoryTraits (Stokhos)

RankTypeSelector< ViewType, OrdinalType, 1 >

TotalOrderLess (Stokhos)

ATanhFunc (ConstantExpansionUnitTest)

ExprSpec< DFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > > > > (Sacado::Fad)

MemoryTraits< Kokkos::HostSpace > (Stokhos)

TotalOrderPredicate (Stokhos)

ATanhFunc (AlgebraicExpansionUnitTest)

ExprSpec< GeneralFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Storage > > (Sacado::Fad)

twoD_diffusion_problem::MeshPoint

aligned_allocator::rebind (Stokhos)

twoD_diffusion_ME

B

ExprSpec< SFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > > (Sacado::Fad)

twoD_diffusion_ME::MeshPoint

aligned_allocator< const T >::rebind (Stokhos)

twoD_diffusion_problem

ExprSpec< SFadExprTag< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > > (Sacado::Fad)

MinusFunc (QuadExpansionUnitTest)

RebindStokhosStorageDevice (Kokkos::Impl)

U

BasisFactory (Stokhos)

ExprSpec< SLFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Num > > (Sacado::Fad)

MinusFunc (PseudoSpectralExpansionUnitTest)

RebindStokhosStorageDevice< const Sacado::MP::Vector< OldStorageType >, Device > (Kokkos::Impl)

BasisInteractionGraph (Stokhos)

ExprSpec< ViewFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, length, stride, BaseFadT > > (Sacado::Fad)

MinusFunc (ForUQTKExpansionUnitTest)

RebindStokhosStorageDevice< const Sacado::UQ::PCE< OldStorageType >, Device > (Kokkos::Impl)

UMinusFunc (DerivExpansionUnitTest)

block_jacobi (cusp::relaxation)

ExprSpecMPVector (Sacado::Fad::Exp)

MinusFunc (DerivExpansionUnitTest)

RebindStokhosStorageDevice< Sacado::MP::Vector< OldStorageType >, Device > (Kokkos::Impl)

UMinusFunc (ForUQTKExpansionUnitTest)

block_lu_solver (cusp::detail)

ExprSpecMPVector (Sacado::Fad)

MinusFunc (AlgebraicExpansionUnitTest)

RebindStokhosStorageDevice< Sacado::UQ::PCE< OldStorageType >, Device > (Kokkos::Impl)

UMinusFunc (AlgebraicExpansionUnitTest)

block_multilevel (cusp)

Extender< T, typename std::enable_if< Sacado::is_mp_vector< typename T::value_type >::value >::type > (Sacado::Fad::Exp)

MirrorType (Kokkos::Impl)

RebindStokhosStorageDevice< T *, Device > (Kokkos::Impl)

UMinusFunc (PseudoSpectralExpansionUnitTest)

block_polynomial (cusp::relaxation)

F

MLPreconditionerFactory (Stokhos)

RebindStokhosStorageDevice< T[], Device > (Kokkos::Impl)

UMinusFunc (QuadExpansionUnitTest)

block_smoothed_aggregation (cusp::precond::aggregation)

MonomialGramSchmidtPCEBasis (Stokhos)

RebindStokhosStorageDevice< T[N], Device > (Kokkos::Impl)

UnitTestSetup (ProductBasisUtilsUnitTest)

BlockCrsMatrix (Stokhos)

FlatArrayType (Kokkos)

MonomialProjGramSchmidtPCEBasis (Stokhos)

RecurrenceBasis (Stokhos)

UnitTestSetup (TotalOrderBasisUnitTest)

BlockDiagonalOperator (Stokhos)

FlatArrayType< View< D, P...>, typename std::enable_if< is_view_mp_vector< View< D, P...> >::value >::type > (Kokkos)

MonomialProjGramSchmidtPCEBasis2 (Stokhos)

ReducedBasisFactory (Stokhos)

UnitTestSetup (HermiteBasisUnitTest)

MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > >::BlockKernel (Stokhos)

FlatArrayType< View< D, P...>, typename std::enable_if< is_view_uq_pce< View< D, P...> >::value >::type > (Kokkos)

MonoProjPCEBasis (Stokhos)

ReducedPCEBasis (Stokhos)

UnitTestSetup (AlgebraicExpansionUnitTest)

BlockMultiply (Stokhos)

FlatLTBSparse3Tensor (Stokhos)

MortonZLess (Stokhos)

ReducedQuadratureFactory (Stokhos)

UnitTestSetup (LegendreBasisUnitTest)

BlockMultiply< CooProductTensor< ValueType, Device, Pack > > (Stokhos)

FlatLTBSparse3TensorNode (Stokhos)

MPBlockDiagonalPreconditioner (Stokhos)

reduction_identity< Sacado::MP::Vector< Storage > > (Kokkos)

UnitTestSetup (Sparse3TensorUnitTest)

BlockMultiply< CrsProductTensor< ValueType, Device > > (Stokhos)

FlatSparse3Tensor (Stokhos)

MPInverseModelEvaluator (Stokhos)

ReplaceDiagonalValuesKernel

UnitTestSetup (ForUQTKExpansionUnitTest)

BlockMultiply< FlatSparse3Tensor< ValueType, Device > > (Stokhos)

FlatSparse3Tensor_kji (Stokhos)

MPMeanBasedPreconditioner (Stokhos)

ResponseComputation (Kokkos::Example::FENL)

UnitTestSetup (TensorProductUnitTest)

BlockMultiply< FlatSparse3Tensor_kji< ValueType, Device > > (Stokhos)

FloatingPointLess (Stokhos)

MPModelEvaluator (Stokhos)

ResponseStatisticModelEvaluator (Stokhos)

UnitTestSetup (QuadExpansionUnitTest)

BlockMultiply< LexicographicBlockSparse3Tensor< ValueType, Device > > (Stokhos)

for_each (Stokhos::mpl)

MPModelEvaluatorAdapter (Stokhos)

RF

UnitTestSetup (SparseGridQuadratureUnitTest)

BlockMultiply< LinearSparse3Tensor< ValueType, Device, BlockSize > > (Stokhos)

for_each< Seq, Iter1, Iter1 > (Stokhos::mpl)

MPMultiply (Stokhos::details)

UnitTestSetup (ConstantExpansionUnitTest)

BlockMultiply< SimpleTiledCrsProductTensor< ValueType, Device > > (Stokhos)

FullyAssembledOperator (Stokhos)

MPMultiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > **, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > **, OutputP... >, Update > (Stokhos::details)

RysBasis (Stokhos)

UnitTestSetup (TensorProductBasisUnitTest)

BlockMultiply< StochasticProductTensor< ValueType, TensorType, Device > > (Stokhos)

FullyAssembledPreconditioner (Stokhos)

MPMultiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > *, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > *, OutputP... >, Update > (Stokhos::details)

S

UnitTestSetup (KokkosKernelsUnitTest)

BlockMultiply< SymmetricDiagonalSpec< Device > > (Stokhos)

G

MPPreconditioner (Stokhos)

UnitTestSetup (PseudoSpectralExpansionUnitTest)

BlockMultiply< SymmetricDiagonalSpec< Kokkos::Cuda > > (Stokhos)

MPPreconditionerFactory (Stokhos)

UnitTestSetup (MatrixFreeOperatorUnitTest)

BlockMultiply< TiledCrsProductTensor< ValueType, Device > > (Stokhos)

MPVectorAllocation (Kokkos::Experimental::Impl)

sa_level (cusp::precond::aggregation)

UnitTestSetup (SmolyakBasisUtilsUnitTest)

BlockPreconditioner (Stokhos)

GaussPattersonExponentialGrowthRule (Stokhos)

MPVectorAllocation< ValueType, false > (Kokkos::Experimental::Impl)

sacado_mp_vector_partition_constructor_requires_unmanaged_view (Kokkos::Impl::ViewError)

UnitTestSetup (SacadoPCEUnitTest)

RCB::Box (Stokhos)

GaussPattersonLegendreBasis (Stokhos)

MPVectorAllocation< ValueType, true > (Kokkos::Experimental::Impl)

BoxElemFixture (Kokkos::Example)

general_predicate (ProductBasisUtilsUnitTest)

MPVectorArrayHelper (Teuchos::details)

ScalarTol< double >

UnitTestSetup (DerivExpansionUnitTest)

BoxElemPart (Kokkos::Example)

GeneralFad< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > >, Storage > (Sacado::Fad)

MPVectorArrayHelper< Stokhos::DynamicStorage< Ordinal, Value, Device > > (Teuchos::details)

ScalarTol< float >

UnitTestSetup (DivisionOperatorUnitTest)

C

GetMeanValsFunc (Stokhos)

MPVectorArrayHelper< Stokhos::StaticFixedStorage< Ordinal, Value, Num, Device > > (Teuchos::details)

ScalarTolerances (unit_test)

UnpackArrayMultiColumn< ExecutionSpace, Kokkos::View< Sacado::MP::Vector< DS > **, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > *, SP...>, IdxView, Op > (Tpetra::KokkosRefactor::Details)

GetMeanValsFunc< Kokkos::View< Sacado::MP::Vector< Storage > *, P... > > (Stokhos)

MPVectorAtomicFunctor (Test)

ScalarTolerances< double > (unit_test)

UnpackArrayMultiColumn< ExecutionSpace, Kokkos::View< Sacado::UQ::PCE< DS > **, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > *, SP...>, IdxView, Op > (Tpetra::KokkosRefactor::Details)

QuadOrthogPolyExpansion::cbrt_quad_func (Stokhos)

GetMeanValsFunc< Kokkos::View< Sacado::UQ::PCE< Storage > *, P... > > (Stokhos)

MPVectorSolverAdapter (Amesos2)

ScalarTolerances< float > (unit_test)

UnpackArrayMultiColumnVariableStride< ExecutionSpace, Kokkos::View< Sacado::MP::Vector< DS > **, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > *, SP...>, IdxView, ColView, Op > (Tpetra::KokkosRefactor::Details)

PseudoSpectralOrthogPolyExpansion::cbrt_quad_func (Stokhos)

GetSacadoSize (Kokkos::Impl)

MPVectorWorkConfig (Kokkos)

ScalarTraits< Sacado::ETPCE::OrthogPoly< T, S > > (Teuchos)

UnpackArrayMultiColumnVariableStride< ExecutionSpace, Kokkos::View< Sacado::UQ::PCE< DS > **, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > *, SP...>, IdxView, ColView, Op > (Tpetra::KokkosRefactor::Details)

CbrtFunc (QuadExpansionUnitTest)

GetSacadoSize< 0 > (Kokkos::Impl)

MultiIndex (Stokhos)

ScalarTraits< Sacado::MP::Vector< S > > (Teuchos)

Update (Stokhos)

CbrtFunc (PseudoSpectralExpansionUnitTest)

GetSacadoSize< 1 > (Kokkos::Impl)

MultiplicationOp (Sacado::ETPCE)

ScalarTraits< Sacado::PCE::OrthogPoly< T, S > > (Teuchos)

UserDefinedQuadrature (Stokhos)

CbrtFunc (ForUQTKExpansionUnitTest)

GetSacadoSize< 2 > (Kokkos::Impl)

Multiply (Stokhos)

ScalarTraits< Sacado::UQ::PCE< S > > (Teuchos)

V

CbrtFunc (DerivExpansionUnitTest)

GetSacadoSize< 3 > (Kokkos::Impl)

Multiply< BlockCrsMatrix< BlockSpec, MatrixValue, Device >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Device >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Device > > (Stokhos)

ScalarTraitsImp (Sacado::PCE)

CGDivisionExpansionStrategy (Stokhos)

GetSacadoSize< 4 > (Kokkos::Impl)

Multiply< BlockCrsMatrix< BlockSpec, MatrixValue, Kokkos::Cuda >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Cuda > > (Stokhos)

ScalarTraitsImp (Sacado::MP)

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)

ProductBasisUtils::Cijk_1D_Iterator (Stokhos)

GetSacadoSize< 5 > (Kokkos::Impl)

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)

ScalarTraitsImp< S, false > (Sacado::MP)

V_Reciprocal_Functor< Kokkos::View< Sacado::UQ::PCE< RS > *, RP...>, Kokkos::View< const Sacado::UQ::PCE< XS > *, XP...>, SizeType > (KokkosBlas::Impl)

GetSacadoSize< 6 > (Kokkos::Impl)

Multiply< BlockCrsMatrix< CrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > (Stokhos)

ScalarTraitsImp< S, true > (Sacado::MP)

V_ReciprocalSelf_Functor< Kokkos::View< Sacado::UQ::PCE< RS > *, RP...>, SizeType > (KokkosBlas::Impl)

CijkData (Stokhos)

GetSacadoSize< 7 > (Kokkos::Impl)

Multiply< BlockCrsMatrix< FlatSparse3Tensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > (Stokhos)

ScalarType< ETPCE::Expr< T > > (Sacado)

V_ReciprocalThresholdSelfFunctor (Ifpack2::Details)

LTBSparse3Tensor::CijkNode (Stokhos)

GetScalarMeanValsFunc (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)

ScalarType< ETPCE::OrthogPoly< T, S > > (Sacado)

V_ReciprocalThresholdSelfFunctor< Kokkos::View< Sacado::UQ::PCE< S > *, P... >, SizeType > (Ifpack2::Details)

GetScalarMeanValsFunc< Kokkos::View< Sacado::MP::Vector< Storage > *, P... > > (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)

ScalarType< MP::Expr< T > > (Sacado)

Value< ETPCE::Expr< T > > (Sacado)

CrsProductTensor::CijkRowCount (Stokhos)

GetScalarMeanValsFunc< Kokkos::View< Sacado::UQ::PCE< Storage > *, P... > > (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)

ScalarType< MP::Vector< S > > (Sacado)

Value< ETPCE::OrthogPoly< T, S > > (Sacado)

CijkType (Kokkos)

GivensRotator< Sacado::MP::Vector< Storage >, false > (Teuchos::details)

Multiply< BlockCrsMatrix< SimpleTiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > (Stokhos)

ScalarType< PCE::OrthogPoly< T, S > > (Sacado)

Value< MP::Expr< T > > (Sacado)

CijkType< ViewType, typename std::enable_if< is_view_uq_pce< ViewType >::value >::type > (Kokkos)

GivensRotator< Sacado::UQ::PCE< Storage >, false > (Teuchos::details)

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)

ScalarType< UQ::PCE< S > > (Sacado)

Value< MP::Vector< S > > (Sacado)

ClenshawCurtisExponentialGrowthRule (Stokhos)

GMRESDivisionExpansionStrategy (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)

ScalarValue< ETPCE::Expr< T > > (Sacado)

Value< PCE::OrthogPoly< T, S > > (Sacado)

ClenshawCurtisLegendreBasis (Stokhos)

gram_schmidt_pce_binary_quad_func

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)

ScalarValue< ETPCE::OrthogPoly< T, S > > (Sacado)

Value< UQ::PCE< S > > (Sacado)

CrsProductTensor::CompareCijkRowCount (Stokhos)

gram_schmidt_pce_unary_quad_func

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)

ScalarValue< MP::Expr< T > > (Sacado)

ValueType< ETPCE::Expr< T > > (Sacado)

CompletePolynomialBasis (Stokhos)

GramSchmidt_PCE_Setup

Multiply< BlockCrsMatrix< TiledCrsProductTensor< TensorScalar, Kokkos::Cuda >, MatrixScalar, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda >, Kokkos::View< VectorScalar **, Kokkos::LayoutLeft, Kokkos::Cuda > > (Stokhos)

ScalarValue< MP::Vector< S > > (Sacado)

ValueType< ETPCE::OrthogPoly< T, S > > (Sacado)

CompletePolynomialBasisUtils (Stokhos)

GramSchmidtBasis (Stokhos)

Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputMultiVectorType, OutputMultiVectorType, std::vector< OrdinalType >, IntegralRank< 2 > > (Stokhos)

ScalarValue< PCE::OrthogPoly< T, S > > (Sacado)

ValueType< MP::Expr< T > > (Sacado)

ConstantOrthogPolyExpansion (Stokhos)

GrowthRule (Stokhos)

Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputMultiVectorType, OutputMultiVectorType, void, IntegralRank< 2 > > (Stokhos)

ScalarValue< UQ::PCE< S > > (Sacado)

ValueType< MP::Vector< S > > (Sacado)

ConstExpr< Sacado::MP::Vector< Stokhos::StaticFixedStorage< Ord, Val, VecNum, Dev > > > (Sacado::Fad)

GSPreconditioner (Stokhos)

Multiply< CrsMatrix< MatrixValue, Device, Layout >, InputVectorType, OutputVectorType, void, IntegralRank< 1 > > (Stokhos)

SchurPreconditioner (Stokhos)

ValueType< PCE::OrthogPoly< T, S > > (Sacado)

PCEAllocation::ConstructDestructFunctor (Kokkos::Experimental::Impl)

GSReducedPCEBasisBase (Stokhos)

Multiply< CrsMatrix< MatrixValue, Device, Layout >, std::vector< InputViewType >, std::vector< OutputViewType >, void, IntegralRank< 1 > > (Stokhos)

SemiIntrusiveCoupledSolver

ValueType< UQ::PCE< S > > (Sacado)

MPVectorAllocation< ValueType, false >::ConstructDestructFunctor (Kokkos::Experimental::Impl)

H

Multiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > **, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > **, OutputP... > > (Stokhos)

SerializationImp (Sacado::MP)

ValueTypeConversionTraits< TypeTo, Sacado::MP::Expr< ExprFrom > > (Teuchos)

MPVectorAllocation< ValueType, true >::ConstructDestructFunctor (Kokkos::Experimental::Impl)

Multiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > *, InputP... >, Kokkos::View< Sacado::MP::Vector< OutputStorage > *, OutputP... > > (Stokhos)

SerializationTraits< Ordinal, Sacado::ETPCE::OrthogPoly< T, S > > (Teuchos)

ValueTypeConversionTraits< TypeTo, Sacado::MP::Vector< StorageFrom > > (Teuchos)

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)

HermiteBasis (Stokhos)

Multiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > **, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > **, OutputP... > > (Stokhos)

SerializationTraits< Ordinal, Sacado::MP::Vector< S > > (Teuchos)

ValueTypeConversionTraits< TypeTo, Sacado::PCE::OrthogPoly< T, S > > (Teuchos)

CooProductTensor (Stokhos)

HexElement_Data (Kokkos::Example)

Multiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, MatrixDevice, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, InputP... >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, OutputP... > > (Stokhos)

SerializationTraits< Ordinal, Sacado::PCE::OrthogPoly< T, S > > (Teuchos)

ValueTypeConversionTraits< TypeTo, Sacado::UQ::PCE< S > > (Teuchos)

CooProductTensor< ValueType, ExecutionSpace, false > (Stokhos)

HexElement_TensorData (Kokkos::Example)

MultiplyAssign (Stokhos::details)

SerializationTraits< Ordinal, Sacado::UQ::PCE< S > > (Teuchos)

ValueTypeConversionTraitsImp (Sacado::PCE)

CooProductTensor< ValueType, ExecutionSpace, true > (Stokhos)

HexElement_TensorData< 27 > (Kokkos::Example)

MultiplyImpl (Stokhos)

SerializationTraitsImp (Sacado::PCE)

ValueTypeSerializer< Ordinal, Sacado::ETPCE::OrthogPoly< T, S > > (Teuchos)

SimpleTiledCrsProductTensor::Coord (Stokhos)

HexElement_TensorData< 8 > (Kokkos::Example)

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)

SerializationTraitsImp (Sacado::MP)

ValueTypeSerializer< Ordinal, Sacado::MP::Vector< S > > (Teuchos)

Coord

HexElement_TensorEval (Kokkos::Example)

MultiplyScaledAssign (Stokhos::details)

SerializationTraitsImp< Ordinal, VecType, true > (Sacado::MP)

ValueTypeSerializer< Ordinal, Sacado::PCE::OrthogPoly< T, S > > (Teuchos)

RCB::CoordCompare (Stokhos)

HouseTriDiagPCEBasis (Stokhos)

MultiplyScaledUpdate (Stokhos::details)

SerializerImp (Sacado::MP)

ValueTypeSerializer< Ordinal, Sacado::UQ::PCE< S > > (Teuchos)

CopyPCE2Scalar (Stokhos::Impl)

I

MultiplyScaledUpdate2 (Stokhos::details)

SerializerImp (Sacado::PCE)

Vector (Sacado::MP)

CopyScalar2PCE (Stokhos::Impl)

MultiplyUpdate (Stokhos::details)

SerialQRDenseSolver< OrdinalType, Sacado::MP::Vector< Storage > > (Teuchos)

MPVectorAllocation< ValueType, false >::VectorConstruct (Kokkos::Experimental::Impl)

QuadOrthogPolyExpansion::cos_quad_func (Stokhos)

IdentityGrowthRule (Stokhos)

MultiVecTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::MP::Vector< Storage >, LO, GO, Node > > (Belos)

SerialQRDenseSolver< OrdinalType, Sacado::UQ::PCE< Storage > > (Teuchos)

VectorImport (Kokkos::Example)

PseudoSpectralOrthogPolyExpansion::cos_quad_func (Stokhos)

IfpackPreconditionerFactory (Stokhos)

MultiVecTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::UQ::PCE< Storage >, LO, GO, Node > > (Belos)

SGInverseModelEvaluator (Stokhos)

VectorOrthogPoly (Stokhos)

CosFunc (QuadExpansionUnitTest)

IfThenElseOp< CondT, T1, T2, false, false, ExprSpecMPVector > (Sacado::Fad::Exp)

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)

SGModelEvaluator (Stokhos)

View< DataType, Arg1Type, Arg2Type, Arg3Type, Impl::ViewMPVectorInterlaced > (Kokkos)

CosFunc (PseudoSpectralExpansionUnitTest)

IfThenElseOp< CondT, T1, T2, false, true, ExprSpecMPVector > (Sacado::Fad::Exp)

MV_Reciprocal_Functor< Kokkos::View< Sacado::UQ::PCE< RS > **, RP...>, Kokkos::View< const Sacado::UQ::PCE< XS > **, XP...>, SizeType > (KokkosBlas::Impl)

SGModelEvaluator_Adaptive (Stokhos)

ViewAssignment< ViewDefault, ViewMPVectorInterlaced, void > (Kokkos::Impl)

CosFunc (ForUQTKExpansionUnitTest)

IfThenElseOp< CondT, T1, T2, true, false, ExprSpecMPVector > (Sacado::Fad::Exp)

MV_ReciprocalSelf_Functor< Kokkos::View< Sacado::UQ::PCE< RS > **, RP...>, SizeType > (KokkosBlas::Impl)

SGModelEvaluator_Interlaced (Stokhos)

ViewAssignment< ViewMPVectorInterlaced, ViewMPVectorInterlaced, void > (Kokkos::Impl)

CosFunc (DerivExpansionUnitTest)

InnerProductSpaceTraits< const Sacado::UQ::PCE< S > > (Kokkos::Details)

SGModelEvaluatorBase (Stokhos)

ViewCtorProp< void, Stokhos::CrsProductTensor< Value, Execution, Memory > > (Kokkos::Impl)

QuadOrthogPolyExpansion::cosh_quad_func (Stokhos)

InnerProductSpaceTraits< Sacado::UQ::PCE< S > > (Kokkos::Details)

SGOperator (Stokhos)

ViewDataAnalysis< DataType, ArrayLayout, Sacado::MP::Vector< StorageType > > (Kokkos::Impl)

PseudoSpectralOrthogPolyExpansion::cosh_quad_func (Stokhos)

IntegralRank (Stokhos)

N

SGOperatorFactory (Stokhos)

ViewDataAnalysis< DataType, ArrayLayout, Sacado::UQ::PCE< StorageType > > (Kokkos::Impl)

CoshFunc (QuadExpansionUnitTest)

InterlacedOperator (Stokhos)

SGPreconditioner (Stokhos)

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 > (Kokkos::Impl)

CoshFunc (PseudoSpectralExpansionUnitTest)

IntrinsicScalarType (Kokkos)

NISPCoupledSolver

SGPreconditionerFactory (Stokhos)

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 > (Kokkos::Impl)

CoshFunc (ForUQTKExpansionUnitTest)

InversePreconditioner (Stokhos)

NodeNodeGraph (Kokkos::Example::FENL)

SGQuadModelEvaluator (Stokhos)

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 > (Kokkos::Impl)

CoshFunc (DerivExpansionUnitTest)

is_view_mp_vector (Kokkos)

SGQuadMPModelEvaluator (Stokhos)

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 > (Kokkos::Impl)

is_view_mp_vector< View< T, P...> > (Kokkos)

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 > (Kokkos::Impl)

create_mp_vector_solver_impl (Amesos2)

is_view_uq_pce (Kokkos)

SimpleTiledCrsProductTensor (Stokhos)

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 > (Kokkos::Impl)

create_solver_with_supported_type< ConcreteSolver, Tpetra::CrsMatrix< Sacado::MP::Vector< ST >, LO, GO, NO >, Tpetra::MultiVector< Sacado::MP::Vector< ST >, LO, GO, NO > > (Amesos2)

is_view_uq_pce< View< T, P...> > (Kokkos)

O

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 > (Kokkos::Impl)

CreateDeviceConfigs (Kokkos::Example::FENL)

is_ViewMPVectorContiguous (Kokkos::Experimental::Impl)

PseudoSpectralOrthogPolyExpansion::sin_quad_func (Stokhos)

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)

CreateDeviceConfigs< Sacado::MP::Vector< StorageType > > (Kokkos::Example::FENL)

is_ViewMPVectorContiguous< Kokkos::View< D, P...>, Args... > (Kokkos::Experimental::Impl)

OneDEigenPair (Stokhos::KL)

QuadOrthogPolyExpansion::sin_quad_func (Stokhos)

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)

CrsMatrix (Stokhos)

is_ViewPCEContiguous (Kokkos::Experimental::Impl)

OneDExponentialCovarianceFunction (Stokhos::KL)

SinFunc (PseudoSpectralExpansionUnitTest)

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)

CrsMatrix (Kokkos::Example::FENL)

is_ViewPCEContiguous< Kokkos::View< D, P...>, Args... > (Kokkos::Experimental::Impl)

OneDOrthogPolyBasis (Stokhos)

SinFunc (ForUQTKExpansionUnitTest)

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)

CrsProductTensor (Stokhos)

is_ViewStorage (Stokhos)

Operator (Stokhos)

SinFunc (QuadExpansionUnitTest)

ViewMapping< void, ViewTraits< DataType, P...>, Sacado::MP::VectorPartition< Size > > (Kokkos::Impl)

ctor_prop_has_cijk (Kokkos::Impl)

is_ViewStorage< ViewStorage< ordinal_t, value_t, static_length, static_stride, device_t > > (Stokhos)

OperatorTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::MP::Vector< Storage >, LO, GO, Node >, Tpetra::Operator< Sacado::MP::Vector< Storage >, LO, GO, Node > > (Belos)

SinFunc (DerivExpansionUnitTest)

ViewMPVectorContiguous (Kokkos::Experimental::Impl)

ctor_prop_has_cijk< ViewCtorProp< Stokhos::CrsProductTensor< Value, Execution, Memory > > > (Kokkos::Impl)

IsADType< ETPCE::Expr< T > > (Sacado)

OperatorTraits< typename Storage::value_type, Tpetra::MultiVector< Sacado::UQ::PCE< Storage >, LO, GO, Node >, Tpetra::Operator< Sacado::UQ::PCE< Storage >, LO, GO, Node > > (Belos)

SingleColumnMultivectorMultiply (Stokhos)

ViewMPVectorInterlaced (Kokkos::Impl)

ctor_prop_has_cijk< ViewCtorProp< T > > (Kokkos::Impl)

IsADType< ETPCE::OrthogPoly< T, S > > (Sacado)

QuadOrthogPolyExpansion::sinh_quad_func (Stokhos)

ViewPCEContiguous (Kokkos::Experimental::Impl)

ctor_prop_has_cijk< ViewCtorProp< T, P...> > (Kokkos::Impl)

IsADType< MP::Expr< T > > (Sacado)

OrthogonalizationFactory (Stokhos)

PseudoSpectralOrthogPolyExpansion::sinh_quad_func (Stokhos)

ViewRank (Stokhos)

D

IsADType< MP::Vector< S > > (Sacado)

OrthogPoly (Sacado::PCE)

SinhFunc (QuadExpansionUnitTest)

ViewRank< std::vector< T > > (Stokhos)

IsADType< PCE::OrthogPoly< T, S > > (Sacado)

OrthogPoly (Sacado::ETPCE)

SinhFunc (ForUQTKExpansionUnitTest)

ViewSpecialize< ValueType, ViewMPVectorInterlaced, LayoutLeft, MemorySpace, MemoryTraits > (Kokkos::Impl)

DeepCopyNonContiguous (Kokkos::Experimental::Impl)

IsADType< UQ::PCE< S > > (Sacado)

OrthogPolyApprox (Stokhos)

SinhFunc (DerivExpansionUnitTest)

ViewSpecialize< ValueType, ViewMPVectorInterlaced, LayoutRight, MemorySpace, MemoryTraits > (Kokkos::Impl)

default_block_monitor (cusp)

IsEqual< ETPCE::OrthogPoly< T, S > > (Sacado)

OrthogPolyBasis (Stokhos)

SinhFunc (PseudoSpectralExpansionUnitTest)

ViewStorage (Stokhos)

DefaultMultiply (Stokhos)

IsEqual< MP::Vector< S > > (Sacado)

OrthogPolyExpansion (Stokhos)

SmolyakBasis (Stokhos)

W

DefaultPointCompare (Stokhos)

IsEqual< PCE::OrthogPoly< T, S > > (Sacado)

OrthogPolyExpansionBase (Stokhos)

SmolyakBasis::SmolyakPredicate (Stokhos)

Dense3Tensor (Stokhos)

IsEqual< UQ::PCE< S > > (Sacado)

P

SmolyakPseudoSpectralOperator (Stokhos)

WeightedVectorSpace (Stokhos)

DenseDirectDivisionExpansionStrategy (Stokhos)

IsScalarType (Stokhos)

SmolyakSparseGridQuadrature (Stokhos)

X

DenseOperator (Stokhos)

IsScalarType2 (Stokhos)

PackArrayMultiColumn< Kokkos::View< Sacado::MP::Vector< DS > *, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, IdxView > (Tpetra::KokkosRefactor::Details)

solver_supports_scalar< ConcreteSolver, Sacado::MP::Vector< Storage > > (Amesos2)

DerivBasis (Stokhos)

IsScalarType< ETPCE::Expr< T > > (Sacado)

PackArrayMultiColumn< Kokkos::View< Sacado::UQ::PCE< DS > *, DP...>, Kokkos::View< const Sacado::UQ::PCE< SS > **, SP...>, IdxView > (Tpetra::KokkosRefactor::Details)

Sparse3Tensor (Stokhos)

XOR (MaskLogic)

DerivOrthogPolyExpansion (Stokhos)

IsScalarType< ETPCE::OrthogPoly< T, S > > (Sacado)

PackArrayMultiColumnVariableStride< Kokkos::View< Sacado::MP::Vector< DS > *, DP...>, Kokkos::View< const Sacado::MP::Vector< SS > **, SP...>, IdxView, ColView > (Tpetra::KokkosRefactor::Details)

AdaptivityManager::Sparse3TensorHash (Stokhos)

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