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

A

Lanczos_Sin_Func

LanczosPCEBasis (Stokhos)

AbsOp (Sacado::MP)

LanczosProjPCEBasis (Stokhos)

AbsOp (Sacado::ETPCE)

LAPACK (Teuchos)

AbsOp (Sacado::ETV)

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

AbstractPreconditionerFactory (Stokhos)

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

ACoshOp (Sacado::MP)

LegendreBasis (Stokhos)

ACoshOp (Sacado::ETPCE)

LexicographicBlockSparse3Tensor (Stokhos)

ACoshOp (Sacado::ETV)

LexicographicTreeBasisNode (Stokhos)

ACosOp (Sacado::ETPCE)

LexographicLess (Stokhos)

ACosOp (Sacado::MP)

LinearGrowthRule (Stokhos)

ACosOp (Sacado::ETV)

LinearSparse3Tensor (Stokhos)

AdaptivityManager (Stokhos)

LocalMPVectorView (Kokkos)

AdditionOp (Sacado::ETPCE)

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

AdditionOp (Sacado::ETV)

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

AdditionOp (Sacado::MP)

LocalMPVectorView< ViewType, LocalSize, 2, false > (Kokkos)

AdditionOp< T1, typename T1::value_type > (Sacado::MP)

LocalMPVectorView< ViewType, LocalSize, 2, true > (Kokkos)

AdditionOp< typename T2::value_type, T2 > (Sacado::MP)

LocalMPVectorView< ViewType, LocalSize, 3, false > (Kokkos)

AlgebraicOrthogPolyExpansion (Stokhos)

LocalMPVectorView< ViewType, LocalSize, 3, true > (Kokkos)

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

LocalReciprocalThreshold (Ifpack2::Details)

AnalyzeShape< Sacado::UQ::PCE< StorageType > > (Kokkos::Impl)

LocalReciprocalThreshold< Kokkos::View< T, L, D, M, Kokkos::Impl::ViewMPVectorContiguous >, SizeType > (Ifpack2::Details)

AnalyzeStokhosShape (Kokkos::Impl)

LocalReciprocalThreshold< Kokkos::View< T, L, D, M, Kokkos::Impl::ViewPCEContiguous >, SizeType > (Ifpack2::Details)

AnalyzeStokhosShape< const T, Layout > (Kokkos::Impl)

LocalUQPCEView (Kokkos)

AnalyzeStokhosShape< const T[], Layout > (Kokkos::Impl)

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

AnalyzeStokhosShape< const T[N], Layout > (Kokkos::Impl)

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

AnalyzeStokhosShape< Sacado::MP::Vector< StorageType >, Layout > (Kokkos::Impl)

Log10Op (Sacado::ETPCE)

AnalyzeStokhosShape< Sacado::UQ::PCE< StorageType >, Layout > (Kokkos::Impl)

Log10Op (Sacado::MP)

AnalyzeStokhosShape< T *, Layout > (Kokkos::Impl)

Log10Op (Sacado::ETV)

AnalyzeStokhosShape< T[], Layout > (Kokkos::Impl)

LogOp (Sacado::ETPCE)

AnalyzeStokhosShape< T[N], Layout > (Kokkos::Impl)

LogOp (Sacado::MP)

AnalyzeStokhosShape< void, Layout > (Kokkos::Impl)

LogOp (Sacado::ETV)

AnisoSparseGridQuadrature (Stokhos)

LTBSparse3Tensor (Stokhos)

AnisotropicTotalOrderIndexSet (Stokhos)

M

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)

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)

MatrixFreeOperator (Stokhos)

ApproxGaussSeidelPreconditioner (Stokhos)

MatrixMarketWriter (Stokhos)

ApproxJacobiPreconditioner (Stokhos)

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

ApproxSchurComplementPreconditioner (Stokhos)

MaxOp (Sacado::MP)

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

MaxOp (Sacado::ETPCE)

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

MaxOp (Sacado::ETV)

ASinhOp (Sacado::ETPCE)

MaxOp< T1, typename T1::value_type > (Sacado::MP)

ASinhOp (Sacado::MP)

MaxOp< typename T2::value_type, T2 > (Sacado::MP)

ASinhOp (Sacado::ETV)

MeanBasedDivisionExpansionStrategy (Stokhos)

ASinOp (Sacado::ETPCE)

MeanBasedPreconditioner (Stokhos)

ASinOp (Sacado::MP)

MeanMultiply (Stokhos)

ASinOp (Sacado::ETV)

MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > **, Kokkos::LayoutLeft, InputDevice, InputMemory >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > **, Kokkos::LayoutLeft, OutputDevice, OutputMemory > > (Stokhos)

Atan2Op (Sacado::MP)

MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, Kokkos::LayoutLeft, ViewDevice, InputMemory >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, Kokkos::LayoutLeft, ViewDevice, OutputMemory > > (Stokhos)

Atan2Op (Sacado::ETPCE)

MemoryTraits (Stokhos)

Atan2Op (Sacado::ETV)

MemoryTraits< Kokkos::HostSpace > (Stokhos)

Atan2Op< T1, typename T1::value_type > (Sacado::MP)

MinOp (Sacado::MP)

Atan2Op< typename T2::value_type, T2 > (Sacado::MP)

MinOp (Sacado::ETPCE)

ATanhOp (Sacado::ETPCE)

MinOp (Sacado::ETV)

ATanhOp (Sacado::MP)

MinOp< T1, typename T1::value_type > (Sacado::MP)

ATanhOp (Sacado::ETV)

MinOp< typename T2::value_type, T2 > (Sacado::MP)

ATanOp (Sacado::ETPCE)

MLPreconditionerFactory (Stokhos)

ATanOp (Sacado::MP)

MonomialGramSchmidtPCEBasis (Stokhos)

ATanOp (Sacado::ETV)

MonomialProjGramSchmidtPCEBasis (Stokhos)

B

MonomialProjGramSchmidtPCEBasis2 (Stokhos)

MonoProjPCEBasis (Stokhos)

BaseExprType< MP::AbsOp< T > > (Sacado)

MortonZLess (Stokhos)

BaseExprType< MP::ACoshOp< T > > (Sacado)

MPBlockDiagonalPreconditioner (Stokhos)

BaseExprType< MP::ACosOp< T > > (Sacado)

MPInverseModelEvaluator (Stokhos)

BaseExprType< MP::AdditionOp< T1, T2 > > (Sacado)

MPMeanBasedPreconditioner (Stokhos)

BaseExprType< MP::ASinhOp< T > > (Sacado)

MPModelEvaluator (Stokhos)

BaseExprType< MP::ASinOp< T > > (Sacado)

MPModelEvaluatorAdapter (Stokhos)

BaseExprType< MP::Atan2Op< T1, T2 > > (Sacado)

MPMultiply (Stokhos::details)

BaseExprType< MP::ATanhOp< T > > (Sacado)

MPMultiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > **, InputLayout, ViewDevice, InputMemory >, Kokkos::View< Sacado::MP::Vector< OutputStorage > **, OutputLayout, ViewDevice, OutputMemory >, Update > (Stokhos::details)

BaseExprType< MP::ATanOp< T > > (Sacado)

MPMultiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > *, InputLayout, ViewDevice, InputMemory >, Kokkos::View< Sacado::MP::Vector< OutputStorage > *, OutputLayout, ViewDevice, OutputMemory >, Update > (Stokhos::details)

BaseExprType< MP::CbrtOp< T > > (Sacado)

MPPreconditioner (Stokhos)

BaseExprType< MP::CoshOp< T > > (Sacado)

MPPreconditionerFactory (Stokhos)

BaseExprType< MP::CosOp< T > > (Sacado)

MPVectorAllocation (Kokkos::Impl)

BaseExprType< MP::DivisionOp< T1, T2 > > (Sacado)

MPVectorAllocation< Storage, false > (Kokkos::Impl)

BaseExprType< MP::ExpOp< T > > (Sacado)

MPVectorAllocation< Storage, true > (Kokkos::Impl)

BaseExprType< MP::FAbsOp< T > > (Sacado)

MPVectorArrayHelper (Teuchos::details)

BaseExprType< MP::Log10Op< T > > (Sacado)

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

BaseExprType< MP::LogOp< T > > (Sacado)

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

BaseExprType< MP::MaxOp< T1, T2 > > (Sacado)

MPVectorSolverAdapter (Amesos2)

BaseExprType< MP::MinOp< T1, T2 > > (Sacado)

MPVectorWorkConfig (Kokkos)

BaseExprType< MP::MultiplicationOp< T1, T2 > > (Sacado)

MultiIndex (Stokhos)

BaseExprType< MP::PowerOp< T1, T2 > > (Sacado)

MultiplicationOp (Sacado::ETV)

BaseExprType< MP::SinhOp< T > > (Sacado)

MultiplicationOp (Sacado::ETPCE)

BaseExprType< MP::SinOp< T > > (Sacado)

MultiplicationOp (Sacado::MP)

BaseExprType< MP::SqrtOp< T > > (Sacado)

MultiplicationOp< T1, typename T1::value_type > (Sacado::MP)

BaseExprType< MP::SubtractionOp< T1, T2 > > (Sacado)

MultiplicationOp< typename T2::value_type, T2 > (Sacado::MP)

BaseExprType< MP::TanhOp< T > > (Sacado)

Multiply (Stokhos)

BaseExprType< MP::TanOp< T > > (Sacado)

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

BaseExprType< MP::UnaryMinusOp< T > > (Sacado)

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

BaseExprType< MP::UnaryPlusOp< T > > (Sacado)

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)

BasisFactory (Stokhos)

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

BasisInteractionGraph (Stokhos)

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

BelosScalarType< Sacado::MP::Vector< S > > (Ifpack2)

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)

BelosScalarType< Sacado::PCE::OrthogPoly< T, S > > (Ifpack2)

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

BelosScalarType< Sacado::UQ::PCE< S > > (Ifpack2)

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)

BlockCrsMatrix (Stokhos)

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

BlockDiagonalOperator (Stokhos)

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

MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, Kokkos::LayoutLeft, ViewDevice, InputMemory >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, Kokkos::LayoutLeft, ViewDevice, OutputMemory > >::BlockKernel (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)

BlockMultiply (Stokhos)

Multiply< BlockCrsMatrix< StochasticProductTensor< ValueType, CrsProductTensor< ValueType, Kokkos::Serial >, Kokkos::Serial >, MatrixValue, Kokkos::Serial >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Serial >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Serial > > (Stokhos)

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

Multiply< BlockCrsMatrix< StochasticProductTensor< ValueType, CrsProductTensor< ValueType, Kokkos::Threads >, Kokkos::Threads >, MatrixValue, Kokkos::Threads >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Threads >, Kokkos::View< VectorValue **, Kokkos::LayoutLeft, Kokkos::Threads > > (Stokhos)

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

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

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

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

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

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

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

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

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

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

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

Multiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > **, InputLayout, Device, InputMemory >, Kokkos::View< Sacado::MP::Vector< OutputStorage > **, OutputLayout, Device, OutputMemory > > (Stokhos)

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

Multiply< KokkosSparse::CrsMatrix< Sacado::MP::Vector< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::MP::Vector< InputStorage > *, InputLayout, Device, InputMemory >, Kokkos::View< Sacado::MP::Vector< OutputStorage > *, OutputLayout, Device, OutputMemory > > (Stokhos)

BlockMultiply< SymmetricDiagonalSpec< Device > > (Stokhos)

Multiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > **, Kokkos::LayoutLeft, ViewDevice, InputMemory >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > **, Kokkos::LayoutLeft, ViewDevice, OutputMemory > > (Stokhos)

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

Multiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, Kokkos::LayoutLeft, ViewDevice, InputMemory >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, Kokkos::LayoutLeft, ViewDevice, OutputMemory > > (Stokhos)

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

MultiplyAssign (Stokhos::details)

BlockPreconditioner (Stokhos)

MultiplyImpl (Stokhos)

RCB::Box (Stokhos)

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

C

MultiplyScaledAssign (Stokhos::details)

MultiplyScaledUpdate (Stokhos::details)

CbrtOp (Sacado::ETPCE)

MultiplyScaledUpdate2 (Stokhos::details)

CbrtOp (Sacado::MP)

MultiplyUpdate (Stokhos::details)

CbrtOp (Sacado::ETV)

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

CGDivisionExpansionStrategy (Stokhos)

MultiVecTraits< BaseScalar, Tpetra::MultiVector< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node > > (Belos)

ProductBasisUtils::Cijk_1D_Iterator (Stokhos)

MV_MultFunctor< Kokkos::View< CT, CL, CD, CM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< AT, AL, AD, AM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< BT, BL, BD, BM, Kokkos::Impl::ViewPCEContiguous >, scalar_ab, scalar_c, SizeType > (KokkosBlas::Impl)

CijkData (Stokhos)

MV_Reciprocal_Functor< Kokkos::View< RT, RL, RD, RM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< XT, XL, XD, XM, Kokkos::Impl::ViewPCEContiguous >, SizeType > (KokkosBlas::Impl)

LTBSparse3Tensor::CijkNode (Stokhos)

MV_ReciprocalSelf_Functor< Kokkos::View< RT, RL, RD, RM, Kokkos::Impl::ViewPCEContiguous >, SizeType > (KokkosBlas::Impl)

ClenshawCurtisExponentialGrowthRule (Stokhos)

O

ClenshawCurtisLegendreBasis (Stokhos)

CompletePolynomialBasis (Stokhos)

OneDEigenPair (Stokhos::KL)

CompletePolynomialBasisUtils (Stokhos)

OneDExponentialCovarianceFunction (Stokhos::KL)

ConstantOrthogPolyExpansion (Stokhos)

OneDOrthogPolyBasis (Stokhos)

ConstExpr (Sacado::ETPCE)

Operator (Stokhos)

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

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

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)

OperatorTraits< BaseScalar, Tpetra::MultiVector< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node >, Tpetra::Operator< Sacado::PCE::OrthogPoly< BaseScalar, Storage >, LO, GO, Node > > (Belos)

CooProductTensor (Stokhos)

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

CooProductTensor< ValueType, ExecutionSpace, false > (Stokhos)

OrthogonalizationFactory (Stokhos)

CooProductTensor< ValueType, ExecutionSpace, true > (Stokhos)

OrthogPoly (Sacado::ETPCE)

RCB::CoordCompare (Stokhos)

OrthogPoly (Sacado::PCE)

CoshOp (Sacado::ETPCE)

OrthogPolyApprox (Stokhos)

CoshOp (Sacado::MP)

OrthogPolyBasis (Stokhos)

CoshOp (Sacado::ETV)

OrthogPolyExpansion (Stokhos)

CosOp (Sacado::ETPCE)

OrthogPolyExpansionBase (Stokhos)

CosOp (Sacado::MP)

P

CosOp (Sacado::ETV)

CrsMatrix (Stokhos)

PackArrayMultiColumn< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewMPVectorContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewMPVectorContiguous >, IdxView > (Tpetra::KokkosRefactor::Details)

CrsProductTensor (Stokhos)

PackArrayMultiColumn< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewPCEContiguous >, IdxView > (Tpetra::KokkosRefactor::Details)

D

PackArrayMultiColumnVariableStride< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewMPVectorContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewMPVectorContiguous >, IdxView, ColView > (Tpetra::KokkosRefactor::Details)

PackArrayMultiColumnVariableStride< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewPCEContiguous >, IdxView, ColView > (Tpetra::KokkosRefactor::Details)

DeepCopyNonContiguous (Kokkos::Impl)

PackArraySingleColumn< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewMPVectorContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewMPVectorContiguous >, IdxView > (Tpetra::KokkosRefactor::Details)

DefaultMultiply (Stokhos)

PackArraySingleColumn< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewPCEContiguous >, IdxView > (Tpetra::KokkosRefactor::Details)

DefaultPointCompare (Stokhos)

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

Dense3Tensor (Stokhos)

ParallelData (Stokhos)

DenseDirectDivisionExpansionStrategy (Stokhos)

PCE (Sacado::UQ)

DenseOperator (Stokhos)

PCEAllocation (Kokkos::Impl)

DerivBasis (Stokhos)

PCEAllocation< const Sacado::UQ::PCE< Storage > > (Kokkos::Impl)

DerivOrthogPolyExpansion (Stokhos)

PCEAllocation< Sacado::UQ::PCE< Storage > > (Kokkos::Impl)

DeviceConfig (Stokhos)

PCEArrayHelper (Teuchos::details)

DeviceForNode (Stokhos)

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

DeviceForNode2 (Stokhos)

PCECovarianceOp (Stokhos)

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

PecosOneDOrthogPolyBasis (Stokhos)

DeviceProp (Stokhos)

PermuteArrayMultiColumn< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewMPVectorContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewMPVectorContiguous >, DstIdxView, SrcIdxView > (Tpetra::KokkosRefactor::Details)

DiagEpetraOp (Stokhos)

PermuteArrayMultiColumn< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewPCEContiguous >, DstIdxView, SrcIdxView > (Tpetra::KokkosRefactor::Details)

DiagonalOperator (Stokhos)

PermuteArrayMultiColumnVariableStride< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewMPVectorContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewMPVectorContiguous >, DstIdxView, SrcIdxView, DstColView, SrcColView > (Tpetra::KokkosRefactor::Details)

DiagPreconditioner (Stokhos)

PermuteArrayMultiColumnVariableStride< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewPCEContiguous >, DstIdxView, SrcIdxView, DstColView, SrcColView > (Tpetra::KokkosRefactor::Details)

DeviceConfig::Dim3 (Stokhos)

PowerOp (Sacado::MP)

Dinv_A (cusp::precond::aggregation::detail)

PowerOp (Sacado::ETPCE)

DiscretizedStieltjesBasis (Stokhos)

PowerOp (Sacado::ETV)

DivisionExpansionStrategy (Stokhos)

PowerOp< T1, typename T1::value_type > (Sacado::MP)

DivisionOp (Sacado::ETPCE)

PowerOp< typename T2::value_type, T2 > (Sacado::MP)

DivisionOp (Sacado::ETV)

PreconditionerFactory (Stokhos)

DivisionOp (Sacado::MP)

ProductBasis (Stokhos)

DivisionOp< T1, typename T1::value_type > (Sacado::MP)

ProductBasisUtils (Stokhos)

DivisionOp< typename T2::value_type, T2 > (Sacado::MP)

ProductContainer (Stokhos)

DotOp1< Sacado::PCE::OrthogPoly< ScalarType, StorageType > > (KokkosClassic)

ProductContainerTraits (Stokhos)

DotOp2< Sacado::PCE::OrthogPoly< ScalarType, StorageType > > (KokkosClassic)

ProductContainerTraits< Epetra_CrsMatrix > (Stokhos)

DynamicStorage (Stokhos)

ProductContainerTraits< Epetra_MultiVector > (Stokhos)

DynamicStridedStorage (Stokhos)

ProductContainerTraits< Epetra_Operator > (Stokhos)

DynamicThreadedStorage (Stokhos)

ProductContainerTraits< Epetra_Vector > (Stokhos)

DynArrayTraits (Stokhos)

ProductEigenPair (Stokhos::KL)

DynArrayTraits< T, device_t, false > (Stokhos)

ProductEigenPairGreater (Stokhos::KL)

E

ProductEpetraMultiVector (Stokhos)

ProductEpetraMultiVectorOperator (Stokhos)

OneDExponentialCovarianceFunction::EigFuncCos (Stokhos::KL)

ProductEpetraOperator (Stokhos)

OneDExponentialCovarianceFunction::EigFuncSin (Stokhos::KL)

ProductEpetraVector (Stokhos)

EpetraCrsMatrixCloner (Stokhos)

ProductLanczosGramSchmidtPCEBasis (Stokhos)

EpetraMultiVectorCloner (Stokhos)

ProductLanczosPCEBasis (Stokhos)

EpetraMultiVectorOperator (Stokhos)

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

EpetraMultiVectorOperatorOrthogPoly (Stokhos)

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

EpetraMultiVectorOrthogPoly (Stokhos)

PseudoSpectralOperator (Stokhos)

EpetraOperatorCloner (Stokhos)

PseudoSpectralOperatorFactory (Stokhos)

EpetraOperatorOrthogPoly (Stokhos)

PseudoSpectralOrthogPolyExpansion (Stokhos)

EpetraSparse3Tensor (Stokhos)

Q

EpetraVectorCloner (Stokhos)

EpetraVectorOrthogPoly (Stokhos)

QuadOrthogPolyExpansion (Stokhos)

EvenGrowthRule (Stokhos)

Quadrature (Stokhos)

ExpansionFactory (Stokhos)

QuadratureFactory (Stokhos)

ExponentialOneDEigenFunction (Stokhos::KL)

QuadraturePseudoSpectralOperator (Stokhos)

ExponentialRandomField (Stokhos::KL)

R

ExpOp (Sacado::ETPCE)

ExpOp (Sacado::MP)

RCB (Stokhos)

ExpOp (Sacado::ETV)

RebindStokhosStorageDevice (Kokkos::Impl)

Expr (Sacado::ETPCE)

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

Expr (Sacado::MP)

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

Expr (Sacado::ETV)

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

Expr< AbsOp< ExprT > > (Sacado::ETPCE)

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

Expr< AbsOp< ExprT > > (Sacado::ETV)

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

Expr< AbsOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

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

Expr< ACoshOp< ExprT > > (Sacado::ETPCE)

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

Expr< ACoshOp< ExprT > > (Sacado::ETV)

RecurrenceBasis (Stokhos)

Expr< ACoshOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

ReducedBasisFactory (Stokhos)

Expr< ACosOp< ExprT > > (Sacado::ETPCE)

ReducedPCEBasis (Stokhos)

Expr< ACosOp< ExprT > > (Sacado::ETV)

ReducedQuadratureFactory (Stokhos)

Expr< ACosOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

ResponseStatisticModelEvaluator (Stokhos)

Expr< AdditionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

RysBasis (Stokhos)

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

S

Expr< AdditionOp< Expr< T1 >, Expr< T2 > > > (Sacado::ETV)

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

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

Expr< AdditionOp< Expr< T1 >, typename Expr< T1 >::value_type > > (Sacado::ETV)

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

Expr< AdditionOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > (Sacado::Fad)

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

Expr< AdditionOp< ExprT1, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

ScalarType< ETV::Vector2< T, S > > (Sacado)

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

ScalarType< ETV::Vector< T, S > > (Sacado)

Expr< AdditionOp< typename Expr< T2 >::value_type, Expr< T2 > > > (Sacado::ETV)

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

Expr< ASinhOp< ExprT > > (Sacado::ETPCE)

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

Expr< ASinhOp< ExprT > > (Sacado::ETV)

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

Expr< ASinhOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

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

Expr< ASinOp< ExprT > > (Sacado::ETPCE)

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

Expr< ASinOp< ExprT > > (Sacado::ETV)

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

Expr< ASinOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

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

Expr< Atan2Op< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

ScalarValue< ETV::Vector2< T, S > > (Sacado)

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

ScalarValue< ETV::Vector< T, S > > (Sacado)

Expr< Atan2Op< Expr< T1 >, Expr< T2 > > > (Sacado::ETV)

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

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

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

Expr< Atan2Op< Expr< T1 >, typename Expr< T1 >::value_type > > (Sacado::ETV)

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

Expr< Atan2Op< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > (Sacado::Fad)

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

Expr< Atan2Op< ExprT1, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

SchurPreconditioner (Stokhos)

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

SerialQRDenseSolver (Teuchos)

Expr< Atan2Op< typename Expr< T2 >::value_type, Expr< T2 > > > (Sacado::ETV)

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

Expr< ATanhOp< ExprT > > (Sacado::ETPCE)

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

Expr< ATanhOp< ExprT > > (Sacado::ETV)

SGInverseModelEvaluator (Stokhos)

Expr< ATanhOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

SGModelEvaluator (Stokhos)

Expr< ATanOp< ExprT > > (Sacado::ETPCE)

SGModelEvaluator_Adaptive (Stokhos)

Expr< ATanOp< ExprT > > (Sacado::ETV)

SGModelEvaluator_Interlaced (Stokhos)

Expr< ATanOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

SGOperator (Stokhos)

Expr< CbrtOp< ExprT > > (Sacado::ETPCE)

SGOperatorFactory (Stokhos)

Expr< CbrtOp< ExprT > > (Sacado::ETV)

SGPreconditioner (Stokhos)

Expr< CoshOp< ExprT > > (Sacado::ETPCE)

SGPreconditionerFactory (Stokhos)

Expr< CoshOp< ExprT > > (Sacado::ETV)

SGQuadModelEvaluator (Stokhos)

Expr< CoshOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

SGQuadMPModelEvaluator (Stokhos)

Expr< CosOp< ExprT > > (Sacado::ETPCE)

SimpleTiledCrsProductTensor (Stokhos)

Expr< CosOp< ExprT > > (Sacado::ETV)

SingleColumnMultivectorMultiply (Stokhos)

Expr< CosOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

SinhOp (Sacado::ETPCE)

Expr< DivisionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

SinhOp (Sacado::MP)

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

SinhOp (Sacado::ETV)

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

SinOp (Sacado::MP)

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

SinOp (Sacado::ETV)

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

SinOp (Sacado::ETPCE)

Expr< DivisionOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > (Sacado::Fad)

SmolyakBasis (Stokhos)

Expr< DivisionOp< ExprT1, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

SmolyakBasis::SmolyakPredicate (Stokhos)

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

SmolyakPseudoSpectralOperator (Stokhos)

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

SmolyakSparseGridQuadrature (Stokhos)

Expr< ExpOp< ExprT > > (Sacado::ETPCE)

Sparse3Tensor (Stokhos)

Expr< ExpOp< ExprT > > (Sacado::ETV)

SparseArray (Stokhos)

Expr< ExpOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

SparseArrayIterator (Stokhos)

Expr< FAbsOp< ExprT > > (Sacado::ETPCE)

SparseArrayReverseIterator (Stokhos)

Expr< FAbsOp< ExprT > > (Sacado::ETV)

SparseGridQuadrature (Stokhos)

Expr< FAbsOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

SPDDenseDirectDivisionExpansionStrategy (Stokhos)

Expr< Log10Op< ExprT > > (Sacado::ETPCE)

SqrtOp (Sacado::MP)

Expr< Log10Op< ExprT > > (Sacado::ETV)

SqrtOp (Sacado::ETPCE)

Expr< Log10Op< ExprT >, ExprSpecMPVector > (Sacado::Fad)

SqrtOp (Sacado::ETV)

Expr< LogOp< ExprT > > (Sacado::ETPCE)

StandardStorage (Stokhos)

Expr< LogOp< ExprT > > (Sacado::ETV)

StaticArrayTraits (Stokhos)

Expr< LogOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

StaticArrayTraits< T, D, false > (Stokhos)

Expr< MaxOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

StaticArrayTraits< T, D, true > (Stokhos)

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

StaticFixedStandardStorage (Stokhos)

Expr< MaxOp< Expr< T1 >, Expr< T2 > > > (Sacado::ETV)

StaticFixedStorage (Stokhos)

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

StaticStandardStorage (Stokhos)

Expr< MaxOp< Expr< T1 >, typename Expr< T1 >::value_type > > (Sacado::ETV)

StaticStorage (Stokhos)

Expr< MaxOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > (Sacado::Fad)

StieltjesBasis (Stokhos)

Expr< MaxOp< ExprT1, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

StieltjesGramSchmidtBuilder (Stokhos)

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

StieltjesPCEBasis (Stokhos)

Expr< MaxOp< typename Expr< T2 >::value_type, Expr< T2 > > > (Sacado::ETV)

StochasticProductTensor (Stokhos)

Expr< MinOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

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

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

StringName< ETV::Vector2< T, S > > (Sacado)

Expr< MinOp< Expr< T1 >, Expr< T2 > > > (Sacado::ETV)

StringName< ETV::Vector< T, S > > (Sacado)

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

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

Expr< MinOp< Expr< T1 >, typename Expr< T1 >::value_type > > (Sacado::ETV)

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

Expr< MinOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > (Sacado::Fad)

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

Expr< MinOp< ExprT1, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

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

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

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

Expr< MinOp< typename Expr< T2 >::value_type, Expr< T2 > > > (Sacado::ETV)

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

Expr< MultiplicationOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

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

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

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

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

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

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

SubtractionOp (Sacado::MP)

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

SubtractionOp (Sacado::ETPCE)

Expr< MultiplicationOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > (Sacado::Fad)

SubtractionOp (Sacado::ETV)

Expr< MultiplicationOp< ExprT1, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

SubtractionOp< T1, typename T1::value_type > (Sacado::MP)

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

SubtractionOp< typename T2::value_type, T2 > (Sacado::MP)

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

SymmetricDiagonalSpec (Stokhos)

Expr< PowerOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

T

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

Expr< PowerOp< Expr< T1 >, Expr< T2 > > > (Sacado::ETV)

TanhOp (Sacado::ETV)

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

TanhOp (Sacado::ETPCE)

Expr< PowerOp< Expr< T1 >, typename Expr< T1 >::value_type > > (Sacado::ETV)

TanhOp (Sacado::MP)

Expr< PowerOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > (Sacado::Fad)

TanOp (Sacado::MP)

Expr< PowerOp< ExprT1, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

TanOp (Sacado::ETPCE)

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

TanOp (Sacado::ETV)

Expr< PowerOp< typename Expr< T2 >::value_type, Expr< T2 > > > (Sacado::ETV)

TensorProductBasis (Stokhos)

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

TensorProductElement (Stokhos)

Expr< SinhOp< ExprT > > (Sacado::ETPCE)

TensorProductIndexSet (Stokhos)

Expr< SinhOp< ExprT > > (Sacado::ETV)

TensorProductPredicate (Stokhos)

Expr< SinhOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

TensorProductPseudoSpectralOperator (Stokhos)

Expr< SinOp< ExprT > > (Sacado::ETPCE)

TensorProductQuadrature (Stokhos)

Expr< SinOp< ExprT > > (Sacado::ETV)

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)

Expr< SinOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

TiledCrsProductTensor (Stokhos)

Expr< SqrtOp< ExprT > > (Sacado::ETPCE)

TinyVec (Stokhos)

Expr< SqrtOp< ExprT > > (Sacado::ETV)

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

Expr< SqrtOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

TotalOrderBasis (Stokhos)

Expr< SubtractionOp< ConstExpr< T1 >, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

TotalOrderIndexSet (Stokhos)

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

TotalOrderLess (Stokhos)

Expr< SubtractionOp< Expr< T1 >, Expr< T2 > > > (Sacado::ETV)

TotalOrderPredicate (Stokhos)

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

U

Expr< SubtractionOp< Expr< T1 >, typename Expr< T1 >::value_type > > (Sacado::ETV)

Expr< SubtractionOp< ExprT1, ConstExpr< T2 > >, ExprSpecMPVector > (Sacado::Fad)

UnaryMinusOp (Sacado::ETPCE)

Expr< SubtractionOp< ExprT1, ExprT2 >, ExprSpecMPVector > (Sacado::Fad)

UnaryMinusOp (Sacado::ETV)

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

UnaryMinusOp (Sacado::MP)

Expr< SubtractionOp< typename Expr< T2 >::value_type, Expr< T2 > > > (Sacado::ETV)

UnaryPlusOp (Sacado::ETV)

Expr< TanhOp< ExprT > > (Sacado::ETPCE)

UnaryPlusOp (Sacado::ETPCE)

Expr< TanhOp< ExprT > > (Sacado::ETV)

UnaryPlusOp (Sacado::MP)

Expr< TanhOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

UnpackArrayMultiColumn< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewMPVectorContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewMPVectorContiguous >, IdxView, Op > (Tpetra::KokkosRefactor::Details)

Expr< TanOp< ExprT > > (Sacado::ETPCE)

UnpackArrayMultiColumn< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewPCEContiguous >, IdxView, Op > (Tpetra::KokkosRefactor::Details)

Expr< TanOp< ExprT > > (Sacado::ETV)

UnpackArrayMultiColumnVariableStride< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewMPVectorContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewMPVectorContiguous >, IdxView, ColView, Op > (Tpetra::KokkosRefactor::Details)

Expr< TanOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

UnpackArrayMultiColumnVariableStride< Kokkos::View< DT, DL, DD, DM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< ST, SL, SD, SM, Kokkos::Impl::ViewPCEContiguous >, IdxView, ColView, Op > (Tpetra::KokkosRefactor::Details)

Expr< UnaryMinusOp< ExprT > > (Sacado::ETPCE)

Update (Stokhos)

Expr< UnaryMinusOp< ExprT > > (Sacado::ETV)

UserDefinedQuadrature (Stokhos)

Expr< UnaryMinusOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

V

Expr< UnaryPlusOp< ExprT > > (Sacado::ETPCE)

Expr< UnaryPlusOp< ExprT > > (Sacado::ETV)

V_MultFunctor< Kokkos::View< CT, CL, CD, CM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< AT, AL, AD, AM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< BT, BL, BD, BM, Kokkos::Impl::ViewPCEContiguous >, scalar_ab, scalar_c, SizeType > (KokkosBlas::Impl)

Expr< UnaryPlusOp< ExprT >, ExprSpecMPVector > (Sacado::Fad)

V_Reciprocal_Functor< Kokkos::View< RT, RL, RD, RM, Kokkos::Impl::ViewPCEContiguous >, Kokkos::View< XT, XL, XD, XM, Kokkos::Impl::ViewPCEContiguous >, SizeType > (KokkosBlas::Impl)

ExprQuadFuncWrapper (Sacado::ETPCE)

V_ReciprocalSelf_Functor< Kokkos::View< RT, RL, RD, RM, Kokkos::Impl::ViewPCEContiguous >, SizeType > (KokkosBlas::Impl)

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

V_ReciprocalThresholdSelfFunctor (Ifpack2::Details)

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

V_ReciprocalThresholdSelfFunctor< Kokkos::View< T, L, D, M, Kokkos::Impl::ViewPCEContiguous >, SizeType > (Ifpack2::Details)

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

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

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

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

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

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

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

Value< ETV::Vector2< T, S > > (Sacado)

ExprSpecMPVector (Sacado::Fad)

Value< ETV::Vector< T, S > > (Sacado)

F

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

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

FAbsOp (Sacado::ETPCE)

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

FAbsOp (Sacado::MP)

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

FAbsOp (Sacado::ETV)

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

FlatLTBSparse3Tensor (Stokhos)

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

FlatLTBSparse3TensorNode (Stokhos)

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

FlatSparse3Tensor (Stokhos)

ValueType< ETV::Vector2< T, S > > (Sacado)

FlatSparse3Tensor_kji (Stokhos)

ValueType< ETV::Vector< T, S > > (Sacado)

FloatingPointLess (Stokhos)

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

ForUQTKOrthogPolyExpansion (Stokhos)

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

FullyAssembledOperator (Stokhos)

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

FullyAssembledPreconditioner (Stokhos)

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

G

Vector (Sacado::MP)

Vector (Sacado::ETV)

GaussPattersonExponentialGrowthRule (Stokhos)

Vector2 (Sacado::ETV)

GaussPattersonLegendreBasis (Stokhos)

PCEAllocation< Sacado::UQ::PCE< Storage > >::VectorInit (Kokkos::Impl)

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

MPVectorAllocation< Storage, false >::VectorInit (Kokkos::Impl)

GetMeanValsFunc (Stokhos)

VectorOrthogPoly (Stokhos)

GetMeanValsFunc< Kokkos::View< Sacado::MP::Vector< Storage > *, Layout, Memory, Device > > (Stokhos)

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

GetMeanValsFunc< Kokkos::View< Sacado::UQ::PCE< Storage > *, Layout, Memory, Device > > (Stokhos)

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

GetSacadoSize (Kokkos::Impl)

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

GetSacadoSize< 0 > (Kokkos::Impl)

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

GetSacadoSize< 1 > (Kokkos::Impl)

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

GetSacadoSize< 2 > (Kokkos::Impl)

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

GetSacadoSize< 3 > (Kokkos::Impl)

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

GetSacadoSize< 4 > (Kokkos::Impl)

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

GetSacadoSize< 5 > (Kokkos::Impl)

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

GetSacadoSize< 6 > (Kokkos::Impl)

ViewMPVectorContiguous (Kokkos::Impl)

GetSacadoSize< 7 > (Kokkos::Impl)

ViewMPVectorInterlaced (Kokkos::Impl)

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

ViewPCEContiguous (Kokkos::Impl)

GMRESDivisionExpansionStrategy (Stokhos)

ViewRank (Stokhos)

GramSchmidtBasis (Stokhos)

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

GrowthRule (Stokhos)

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

GSPreconditioner (Stokhos)

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

GSReducedPCEBasisBase (Stokhos)

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

H

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

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

HermiteBasis (Stokhos)

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

HouseTriDiagPCEBasis (Stokhos)

ViewStorage (Stokhos)

I

ViewSubview< View< SrcDataType, SrcArg1Type, SrcArg2Type, SrcArg3Type, Impl::ViewMPVectorContiguous >, SubArg0_type, SubArg1_type, SubArg2_type, SubArg3_type, SubArg4_type, SubArg5_type, SubArg6_type, SubArg7_type > (Kokkos::Impl)

ViewSubview< View< SrcDataType, SrcArg1Type, SrcArg2Type, SrcArg3Type, Impl::ViewPCEContiguous >, SubArg0_type, SubArg1_type, SubArg2_type, SubArg3_type, SubArg4_type, SubArg5_type, SubArg6_type, SubArg7_type > (Kokkos::Impl)

IdentityGrowthRule (Stokhos)

W

IfpackPreconditionerFactory (Stokhos)

InnerProductSpaceTraits< const Sacado::MP::Vector< S > > (Kokkos::Details)

WeightedVectorSpace (Stokhos)

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

WeightNormOp< Sacado::PCE::OrthogPoly< ScalarType, StorageType > > (KokkosClassic)

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

a

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

IntegralRank (Stokhos)

DerivOrthogPolyExpansion::acos_quad_func (Stokhos)

InterlacedOperator (Stokhos)

PseudoSpectralOrthogPolyExpansion::acos_quad_func (Stokhos)

InversePreconditioner (Stokhos)

QuadOrthogPolyExpansion::acos_quad_func (Stokhos)

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

DerivOrthogPolyExpansion::acosh_quad_func (Stokhos)

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

PseudoSpectralOrthogPolyExpansion::acosh_quad_func (Stokhos)

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

QuadOrthogPolyExpansion::acosh_quad_func (Stokhos)

IsADType< ETV::Vector2< T, S > > (Sacado)

aligned_allocator (Stokhos)

IsADType< ETV::Vector< T, S > > (Sacado)

aligned_allocator< const T > (Stokhos)

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

amg_container (cusp::precond::aggregation)

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

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

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

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

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

StaticFixedStorage::apply (Stokhos)

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

StaticStorage::apply (Stokhos)

IsEqual< ETV::Vector2< T, S > > (Sacado)

ViewStorage::apply (Stokhos)

IsEqual< ETV::Vector< T, S > > (Sacado)

StandardStorage::apply (Stokhos)

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

StaticFixedStandardStorage::apply (Stokhos)

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

StaticStandardStorage::apply (Stokhos)

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

DynamicStorage::apply (Stokhos)

IsExpr< MP::AbsOp< T > > (Sacado)

DynamicStridedStorage::apply (Stokhos)

IsExpr< MP::ACoshOp< T > > (Sacado)

StaticFixedStorage::apply_N (Stokhos)

IsExpr< MP::ACosOp< T > > (Sacado)

DynamicStorage::apply_N (Stokhos)

IsExpr< MP::AdditionOp< T1, T2 > > (Sacado)

DerivOrthogPolyExpansion::asin_quad_func (Stokhos)

IsExpr< MP::ASinhOp< T > > (Sacado)

PseudoSpectralOrthogPolyExpansion::asin_quad_func (Stokhos)

IsExpr< MP::ASinOp< T > > (Sacado)

QuadOrthogPolyExpansion::asin_quad_func (Stokhos)

IsExpr< MP::Atan2Op< T1, T2 > > (Sacado)

DerivOrthogPolyExpansion::asinh_quad_func (Stokhos)

IsExpr< MP::ATanhOp< T > > (Sacado)

PseudoSpectralOrthogPolyExpansion::asinh_quad_func (Stokhos)

IsExpr< MP::ATanOp< T > > (Sacado)

QuadOrthogPolyExpansion::asinh_quad_func (Stokhos)

IsExpr< MP::CbrtOp< T > > (Sacado)

PseudoSpectralOrthogPolyExpansion::atan2_quad_func (Stokhos)

IsExpr< MP::CoshOp< T > > (Sacado)

QuadOrthogPolyExpansion::atan2_quad_func (Stokhos)

IsExpr< MP::CosOp< T > > (Sacado)

DerivOrthogPolyExpansion::atan_quad_func (Stokhos)

IsExpr< MP::DivisionOp< T1, T2 > > (Sacado)

PseudoSpectralOrthogPolyExpansion::atan_quad_func (Stokhos)

IsExpr< MP::ExpOp< T > > (Sacado)

QuadOrthogPolyExpansion::atan_quad_func (Stokhos)

IsExpr< MP::FAbsOp< T > > (Sacado)

DerivOrthogPolyExpansion::atanh_quad_func (Stokhos)

IsExpr< MP::Log10Op< T > > (Sacado)

PseudoSpectralOrthogPolyExpansion::atanh_quad_func (Stokhos)

IsExpr< MP::LogOp< T > > (Sacado)

QuadOrthogPolyExpansion::atanh_quad_func (Stokhos)

IsExpr< MP::MaxOp< T1, T2 > > (Sacado)

b

IsExpr< MP::MinOp< T1, T2 > > (Sacado)

IsExpr< MP::MultiplicationOp< T1, T2 > > (Sacado)

block_jacobi (cusp::relaxation)

IsExpr< MP::PowerOp< T1, T2 > > (Sacado)

block_jacobi_postsmooth_functor (cusp::relaxation::detail)

IsExpr< MP::SinhOp< T > > (Sacado)

block_jacobi_presmooth_functor (cusp::relaxation::detail)

IsExpr< MP::SinOp< T > > (Sacado)

block_lu_solver (cusp::detail)

IsExpr< MP::SqrtOp< T > > (Sacado)

block_multilevel (cusp)

IsExpr< MP::SubtractionOp< T1, T2 > > (Sacado)

block_polynomial (cusp::relaxation)

IsExpr< MP::TanhOp< T > > (Sacado)

block_smoothed_aggregation (cusp::precond::aggregation)

IsExpr< MP::TanOp< T > > (Sacado)

c

IsExpr< MP::UnaryMinusOp< T > > (Sacado)

IsExpr< MP::UnaryPlusOp< T > > (Sacado)

PseudoSpectralOrthogPolyExpansion::cbrt_quad_func (Stokhos)

IsScalarType (Stokhos)

QuadOrthogPolyExpansion::cbrt_quad_func (Stokhos)

IsScalarType2 (Stokhos)

PseudoSpectralOrthogPolyExpansion::cos_quad_func (Stokhos)

IsScalarType2< double > (Stokhos)

QuadOrthogPolyExpansion::cos_quad_func (Stokhos)

IsScalarType2< float > (Stokhos)

PseudoSpectralOrthogPolyExpansion::cosh_quad_func (Stokhos)

IsScalarType2< int > (Stokhos)

QuadOrthogPolyExpansion::cosh_quad_func (Stokhos)

IsScalarType2< long > (Stokhos)

create_mp_vector_solver_impl (Amesos2)

IsScalarType< double > (Stokhos)

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)

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

d

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

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

default_block_monitor (cusp)

IsScalarType< ETV::Vector2< T, S > > (Sacado)

device_is_cuda (Tpetra::KokkosRefactor::Details)

IsScalarType< ETV::Vector< T, S > > (Sacado)

PseudoSpectralOrthogPolyExpansion::div_quad_func (Stokhos)

IsScalarType< float > (Stokhos)

QuadOrthogPolyExpansion::div_quad_func (Stokhos)

IsScalarType< int > (Stokhos)

ds_array (Stokhos)

IsScalarType< long > (Stokhos)

ds_array< T, true > (Stokhos)

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

e

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

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

error_storage_type_is_not_allocateable (Stokhos)

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

error_storage_type_is_not_resizeable (Stokhos)

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

PseudoSpectralOrthogPolyExpansion::exp_quad_func (Stokhos)

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

QuadOrthogPolyExpansion::exp_quad_func (Stokhos)

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

f

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

TotalOrderIndexSet::Iterator (Stokhos)

for_each (Stokhos::mpl)

AnisotropicTotalOrderIndexSet::Iterator (Stokhos)

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

TensorProductIndexSet::Iterator (Stokhos)

i

J

is_ViewStorage (Stokhos)

JacobiBasis (Stokhos)

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

JacobiPreconditioner (Stokhos)

l

K

lanczos_pce_quad_func

MeanMultiply< KokkosSparse::CrsMatrix< Sacado::UQ::PCE< MatrixStorage >, MatrixOrdinal, Device, MatrixMemory, MatrixSize >, Kokkos::View< Sacado::UQ::PCE< InputStorage > *, Kokkos::LayoutLeft, ViewDevice, InputMemory >, Kokkos::View< Sacado::UQ::PCE< OutputStorage > *, Kokkos::LayoutLeft, ViewDevice, OutputMemory > >::Kernel (Stokhos)

block_multilevel::level (cusp)

KLMatrixFreeOperator (Stokhos)

PseudoSpectralOrthogPolyExpansion::log10_quad_func (Stokhos)

KLReducedMatrixFreeOperator (Stokhos)

QuadOrthogPolyExpansion::log10_quad_func (Stokhos)

KroneckerProductPreconditioner (Stokhos)

PseudoSpectralOrthogPolyExpansion::log_quad_func (Stokhos)

L

QuadOrthogPolyExpansion::log_quad_func (Stokhos)

p

Lanczos (Stokhos)

Lanczos_Cos_Func

QuadOrthogPolyExpansion::pow_quad_func (Stokhos)

Lanczos_Exp_Func

PseudoSpectralOrthogPolyExpansion::pow_quad_func (Stokhos)

Lanczos_PCE_Setup

r

aligned_allocator::rebind (Stokhos)

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