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

A: A; AbsOp (Sacado::CacheFad); AbsOp (Sacado::Fad::Exp); AbsOp (Sacado::ELRCacheFad); AbsOp (Sacado::Fad); AbstractScalarParameterEntry (Sacado); ACosExprType (Sacado::Tay); ACoshOp (Sacado::Fad); ACoshOp (Sacado::Fad::Exp); ACosOp (Sacado::Fad); ACosOp (Sacado::Fad::Exp); ACosQuadOp (Sacado::Tay); ADcontext (Sacado::Radnt); ADcontext (Sacado::RadVec); ADcontext (Sacado::Rad); ADcontext (Sacado::Rad2d); ADcontext (Sacado::Rad2); ExprFuncs::add; ExprFuncs::add< T, 1 >; ExprFuncs::add< T, 10 >; ExprFuncs::add< T, 15 >; ExprFuncs::add< T, 2 >; ExprFuncs::add< T, 20 >; ExprFuncs::add< T, 3 >; ExprFuncs::add< T, 4 >; ExprFuncs::add< T, 5 >; ExprFuncs::add_base; add_type (Sacado::mpl); AdditionOp (Sacado::Fad); AdditionOp (Sacado::Fad::Exp); AdditionOp (Sacado::Tay); AdditionOp< ConstExpr< typename ExprT2::value_type >, ExprT2 > (Sacado::Tay); AdditionOp< ExprT1, ConstExpr< typename ExprT1::value_type > > (Sacado::Tay); ADmemblock (Sacado::Rad2); ADmemblock (Sacado::Rad2d); ADmemblock (Sacado::Rad); ADmemblock (Sacado::Radnt); ADmemblock (Sacado::RadVec); ADvar (Sacado::Rad); ADvar (Sacado::RadVec); ADvar (Sacado::Radnt); ADvar (Sacado::Rad2d); ADvar (Sacado::Rad2); ADvar1 (Sacado::Rad2); ADvar1 (Sacado::Rad2d); ADvar1 (Sacado::Rad); ADvar1 (Sacado::Radnt); ADvar1 (Sacado::RadVec); ADvar1g (Sacado::Rad2); ADvar1g (Sacado::Rad2d); ADvar1s (Sacado::Rad2); ADvar1s (Sacado::RadVec); ADvar1s (Sacado::Radnt); ADvar1s (Sacado::Rad2d); ADvar1s (Sacado::Rad); ADvar2 (Sacado::Rad2d); ADvar2 (Sacado::Rad); ADvar2 (Sacado::Radnt); ADvar2 (Sacado::RadVec); ADvar2 (Sacado::Rad2); ADvar2g (Sacado::Rad2); ADvar2g (Sacado::Rad2d); ADvar2q (Sacado::RadVec); ADvar2q (Sacado::Radnt); ADvar2q (Sacado::Rad); ADvar2q (Sacado::Rad2d); ADvar2q (Sacado::Rad2); ADvari (Sacado::Rad2); ADvari (Sacado::Rad2d); ADvari (Sacado::Rad); ADvari (Sacado::Radnt); ADvari (Sacado::RadVec); ADvari_block (Sacado::Rad2); ADvari_block (Sacado::Rad2d); ADvari_head; ADvarn (Sacado::RadVec); ADvarn (Sacado::Radnt); ADvarn (Sacado::Rad); ADvarn (Sacado::Rad2); ADvarn (Sacado::Rad2d); at_impl< range_c_tag, Pos >::apply (Sacado::mpl); begin_impl< range_c_tag >::apply (Sacado::mpl); bind1::apply (Sacado::mpl); bind2::apply (Sacado::mpl); bind3::apply (Sacado::mpl); bind4::apply (Sacado::mpl); bind5::apply (Sacado::mpl); end_impl< range_c_tag >::apply (Sacado::mpl); quote0::apply (Sacado::mpl); quote1::apply (Sacado::mpl); quote2::apply (Sacado::mpl); quote3::apply (Sacado::mpl); quote4::apply (Sacado::mpl); ViewStorage::apply (Sacado::Fad::Exp); quote5::apply (Sacado::mpl); size_impl< range_c_tag >::apply (Sacado::mpl); ADvar::apply (Sacado::Rad2); ADvar::apply (Sacado::Rad); ADvar::apply (Sacado::RadVec); CacheTaylor::apply (Sacado::Tay); Taylor::apply (Sacado::Tay); DefaultEvalTypeTraits::apply (Sacado); arg< 5 >::apply (Sacado::mpl); DVFad::apply (Sacado::Fad); DynamicStorage::apply (Sacado::Fad::Exp); GeneralFad::apply (Sacado::Fad::Exp); StaticFixedStorage::apply (Sacado::Fad::Exp); StaticStorage::apply (Sacado::Fad::Exp); VectorDynamicStorage::apply (Sacado::Fad::Exp); SimpleFad::apply (Sacado::Fad); DFad::apply (Sacado::FAD_NS); SLFad::apply (Sacado::FAD_NS); arg< 4 >::apply (Sacado::mpl); arg< 3 >::apply (Sacado::mpl); arg< 2 >::apply (Sacado::mpl); arg< 1 >::apply (Sacado::mpl); LogicalSparse::apply (Sacado::LFad); SFad::apply (Sacado::FAD_NS); ViewFad::apply (Sacado::FAD_NS); apply (Sacado::mpl); ScalarFlopCounter::apply (Sacado::FlopCounterPack); apply0 (Sacado::mpl); apply1 (Sacado::mpl); apply2 (Sacado::mpl); apply3 (Sacado::mpl); apply4 (Sacado::mpl); apply5 (Sacado::mpl); StaticFixedStorage::apply_N (Sacado::Fad::Exp); SLFad::apply_N (Sacado::FAD_NS); SFad::apply_N (Sacado::FAD_NS); DFad::apply_N (Sacado::FAD_NS); ViewStorage::apply_N (Sacado::Fad::Exp); VectorDynamicStorage::apply_N (Sacado::Fad::Exp); StaticStorage::apply_N (Sacado::Fad::Exp); GeneralFad::apply_N (Sacado::Fad::Exp); DynamicStorage::apply_N (Sacado::Fad::Exp); apply_wrap (Sacado::mpl); apply_wrap0 (Sacado::mpl); apply_wrap1 (Sacado::mpl); apply_wrap2 (Sacado::mpl); apply_wrap3 (Sacado::mpl); apply_wrap4 (Sacado::mpl); apply_wrap5 (Sacado::mpl); apply_wrap< F, A1, A2, A3, A4, mpl::none > (Sacado::mpl); apply_wrap< F, A1, A2, A3, mpl::none, mpl::none > (Sacado::mpl); apply_wrap< F, A1, A2, mpl::none, mpl::none, mpl::none > (Sacado::mpl); apply_wrap< F, A1, mpl::none, mpl::none, mpl::none, mpl::none > (Sacado::mpl); apply_wrap< F, mpl::none, mpl::none, mpl::none, mpl::none, mpl::none > (Sacado::mpl); arg (Sacado::mpl); arg< 1 > (Sacado::mpl); arg< 2 > (Sacado::mpl); arg< 3 > (Sacado::mpl); arg< 4 > (Sacado::mpl); arg< 5 > (Sacado::mpl); ArrayTraits (Sacado::Fad); ArrayValueType (Sacado::Fad); ASinExprType (Sacado::Tay); ASinhOp (Sacado::Fad); ASinhOp (Sacado::Fad::Exp); ASinOp (Sacado::Fad); ASinOp (Sacado::Fad::Exp); ASinQuadOp (Sacado::Tay); AssignRank2Rank1Kernel; at (Sacado::mpl); at_impl (Sacado::mpl); at_impl< range_c_tag, Pos > (Sacado::mpl); Atan2Op (Sacado::Fad); Atan2Op (Sacado::Fad::Exp); ATanExprType (Sacado::Tay); ATanhOp (Sacado::Fad); ATanhOp (Sacado::Fad::Exp); ATanOp (Sacado::Fad); ATanOp (Sacado::Fad::Exp); ATanQuadOp (Sacado::Tay); AtomicAddKernel

B: B; Base (Sacado); BaseExpr (Sacado::ELRCacheFad); BaseExpr (Sacado::ELRFad); BaseExpr (Sacado::Fad); BaseExpr (Sacado::CacheFad); BaseExpr< GeneralFad< T, Fad::DynamicStorage< T > > > (Sacado::FAD_NS); BaseExpr< GeneralFad< T, Fad::StaticStorage< T, N > > > (Sacado::FAD_NS); BaseExpr< GeneralFad< T, Fad::VectorDynamicStorage< T > > > (Sacado::Fad); BaseExpr< GeneralFad< T, Fad::ViewStorage< T, l, s, U > > > (Sacado::FAD_NS); BaseExprType (Sacado); BaseExprType< CacheFad::Expr< T > > (Sacado); BaseExprType< ELRCacheFad::Expr< T > > (Sacado); BaseExprType< ELRFad::Expr< T > > (Sacado); BaseExprType< Fad::DVFad< T > > (Sacado); BaseExprType< Fad::Exp::Expr< T > > (Sacado); BaseExprType< Fad::Exp::GeneralFad< Fad::Exp::ViewStorage< T, static_length, static_stride, U > > > (Sacado); BaseExprType< Fad::Exp::GeneralFad< S > > (Sacado); BaseExprType< Fad::Exp::IfThenElseOp< CondT, T1, T2, c1, c2, E > > (Sacado); BaseExprType< Fad::Expr< T > > (Sacado); BaseExprType< FAD_NS::DFad< T > > (Sacado); BaseExprType< FAD_NS::SFad< T, N > > (Sacado); BaseExprType< FAD_NS::SLFad< T, N > > (Sacado); BaseExprType< FAD_NS::ViewFad< T, l, s, U > > (Sacado); BaseExprType< LFad::Expr< T > > (Sacado); BaseExprType< LFad::LogicalSparse< T, L > > (Sacado); BaseExprType< Tay::Expr< T > > (Sacado); begin (Sacado::mpl); begin_impl (Sacado::mpl); begin_impl< range_c_tag > (Sacado::mpl); BinaryExpr (Sacado::Tay); BinaryExpr< ConstExpr< typename ExprT2::value_type >, ExprT2, Op > (Sacado::Tay); BinaryExpr< ExprT1, ConstExpr< typename ExprT1::value_type >, Op > (Sacado::Tay); bind1 (Sacado::mpl); bind2 (Sacado::mpl); bind3 (Sacado::mpl); bind4 (Sacado::mpl); bind5 (Sacado::mpl); BLAS (Sacado::Fad); BoxElemFixture (Kokkos::Example); BoxElemPart (Kokkos::Example); TemplateManager::BuildObject (Sacado)

C: C; CacheTaylor (Sacado::Tay); CacheTaylorImplementation (Sacado::Tay); CacheTaylorOpsUnitTest; CADcontext (Sacado::Rad2); CADcontext (Sacado::Rad2d); CADcontext (Sacado::Rad); CADcontext (Sacado::Radnt); CADcontext (Sacado::RadVec); CbrtOp (Sacado::Fad::Exp); convertible_impl::checker (Sacado::mpl); ConditionalReturnType (Sacado::Fad::Exp::Impl); ConditionalReturnType< T1, T2, true > (Sacado::Fad::Exp::Impl); ConstADvar (Sacado::Rad2); ConstADvar (Sacado::Rad2d); ConstADvar (Sacado::Rad); ConstADvar (Sacado::Radnt); ConstADvar (Sacado::RadVec); ConstADvari (Sacado::RadVec); ConstADvari (Sacado::Rad2d); ConstADvari (Sacado::Radnt); ConstADvari (Sacado::Rad2); ConstADvari (Sacado::Rad); ConstExpr (Sacado::CacheFad); ConstExpr (Sacado::ELRCacheFad); ConstExpr (Sacado::ELRFad); ConstExpr (Sacado::Fad); ConstExpr (Sacado::Tay); ConstTemplateIterator (Sacado); container; convertible_impl (Sacado::mpl); CoshOp (Sacado::Fad); CoshOp (Sacado::Fad::Exp); CoshOp (Sacado::Tay); CosOp (Sacado::Fad); CosOp (Sacado::Fad::Exp); CosOp (Sacado::Tay); CrsMatrix (Kokkos::Example::FENL)

D: TemplateManager::DefaultBuilderOp (Sacado); DefaultEvalTypeTraits (Sacado); deref (Sacado::mpl); deref< range_c_iterator< Range, Pos > > (Sacado::mpl); DERIV_TYPE; Derp (Sacado::Rad2); Derp (Sacado::Rad2d); Derp (Sacado::Rad); Derp (Sacado::Radnt); Derp (Sacado::RadVec); DFad (Sacado::ELRCacheFad); DFad (Sacado::FAD_NS); DFad (Sacado::Fad); DFad (Sacado::ELRFad); DFad (Sacado::CacheFad); disable_if (Sacado::mpl); disable_if_c (Sacado::mpl); disable_if_c< false, T > (Sacado::mpl); DivisionOp (Sacado::Tay); DivisionOp (Sacado::Fad::Exp); DivisionOp (Sacado::Fad); DivisionOp< ConstExpr< typename ExprT2::value_type >, ExprT2 > (Sacado::Tay); DivisionOp< ExprT1, ConstExpr< typename ExprT1::value_type > > (Sacado::Tay); DoubleAvoid (Sacado::Rad2); DoubleAvoid (Sacado::Rad); DoubleAvoid (Sacado::RadVec); DoubleAvoid< double > (Sacado::Rad2); DoubleAvoid< double > (Sacado::Rad); DoubleAvoid< double > (Sacado::RadVec); DoubleAvoid< int > (Sacado::Rad); DoubleAvoid< long > (Sacado::Rad); ds_array (Sacado); ds_array< T, true > (Sacado); dummy (Sacado); dummy< T, T > (Sacado); dummy_arg (Sacado); DVFad (Sacado::Fad); DynamicStorage (Sacado::Fad); DynamicStorage (Sacado::Fad::Exp)

E: ElemData; ElementComputation (Kokkos::Example::FENL); ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, Analytic > (Kokkos::Example::FENL); ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadElement > (Kokkos::Example::FENL); ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadElementOptimized > (Kokkos::Example::FENL); ElementComputation< Kokkos::Example::BoxElemFixture< ExecutionSpace, Order, CoordinateMap >, CrsMatrix< ScalarType, ExecutionSpace >, FadQuadPoint > (Kokkos::Example::FENL); ElementComputationBase (Kokkos::Example::FENL); enable_if (Sacado::mpl); enable_if_c (Sacado::mpl); enable_if_c< true, T > (Sacado::mpl); end (Sacado::mpl); end_impl (Sacado::mpl); end_impl< range_c_tag > (Sacado::mpl); ParameterVectorBase::Entry (Sacado); ExpectedAnswer; ExpOp (Sacado::Fad::Exp); ExpOp (Sacado::Fad); ExpOp (Sacado::Tay); Expr (Sacado::Tay); Expr (Sacado::LFad); Expr (Sacado::Fad); Expr (Sacado::ELRFad); Expr (Sacado::ELRCacheFad); Expr (Sacado::CacheFad); Expr (Sacado::Fad::Exp); Expr< AbsOp< ExprT > > (Sacado::CacheFad); Expr< AbsOp< ExprT > > (Sacado::ELRCacheFad); Expr< CacheTaylorImplementation< T > > (Sacado::Tay); Expr< FAbsOp< ExprT > > (Sacado::CacheFad); Expr< FAbsOp< ExprT > > (Sacado::ELRCacheFad); Expr< GeneralFad< T, Storage > > (Sacado::ELRFad); Expr< GeneralFad< T, Storage > > (Sacado::Fad); Expr< GeneralFad< T, Storage > > (Sacado::ELRCacheFad); Expr< GeneralFad< T, Storage > > (Sacado::CacheFad); Expr< LogicalSparseImp< ValT, LogT > > (Sacado::LFad); Expr< PowerOp< ConstExpr< T1 >, ExprT2, false >, ExprSpecDefault > (Sacado::Fad); Expr< PowerOp< ConstExpr< T1 >, ExprT2, true >, ExprSpecDefault > (Sacado::Fad); Expr< PowerOp< ExprT1, ConstExpr< T2 >, false >, ExprSpecDefault > (Sacado::Fad); Expr< PowerOp< ExprT1, ConstExpr< T2 >, true >, ExprSpecDefault > (Sacado::Fad); Expr< PowerOp< ExprT1, ExprT2, false >, ExprSpecDefault > (Sacado::Fad); Expr< PowerOp< ExprT1, ExprT2, true >, ExprSpecDefault > (Sacado::Fad); Expr< SFadExprTag< T, Num > > (Sacado::ELRFad); Expr< SFadExprTag< T, Num > > (Sacado::ELRCacheFad); Expr< SFadExprTag< T, Num > > (Sacado::CacheFad); Expr< SFadExprTag< T, Num >, ExprSpecDefault > (Sacado::Fad); Expr< UnaryMinusOp< ExprT > > (Sacado::ELRCacheFad); Expr< UnaryMinusOp< ExprT > > (Sacado::CacheFad); Expr< UnaryPlusOp< ExprT > > (Sacado::CacheFad); Expr< UnaryPlusOp< ExprT > > (Sacado::ELRCacheFad); ExprAssign (Sacado::Fad::Exp); ExprAssign< DstType, typename std::enable_if< Sacado::IsStaticallySized< DstType >::value >::type > (Sacado::Fad::Exp); ExprConstRef (Sacado::ELRCacheFad); ExprConstRef (Sacado::ELRFad); ExprConstRef< ConstExpr< T > > (Sacado::ELRFad); ExprConstRef< ConstExpr< T > > (Sacado::ELRCacheFad); ExprFuncs; ExprLevel (Sacado::CacheFad); ExprLevel (Sacado::ELRCacheFad); ExprLevel (Sacado::ELRFad); ExprLevel (Sacado::Fad::Exp); ExprLevel (Sacado::Fad); ExprLevel (Sacado::LFad); ExprLevel< DFad< T > > (Sacado::FAD_NS); ExprLevel< DVFad< T > > (Sacado::Fad); ExprLevel< Expr< T > > (Sacado::ELRCacheFad); ExprLevel< Expr< T > > (Sacado::ELRFad); ExprLevel< Expr< T > > (Sacado::Fad::Exp); ExprLevel< Expr< T > > (Sacado::Fad); ExprLevel< Expr< T > > (Sacado::LFad); ExprLevel< Expr< T > > (Sacado::CacheFad); ExprLevel< GeneralFad< S > > (Sacado::Fad::Exp); ExprLevel< IfThenElseOp< CondT, T1, T2, c1, c2, E > > (Sacado::Fad::Exp); ExprLevel< LogicalSparse< T, L > > (Sacado::LFad); ExprLevel< SFad< T, N > > (Sacado::FAD_NS); ExprLevel< SLFad< T, N > > (Sacado::FAD_NS); ExprLevel< ViewFad< T, l, s, U > > (Sacado::FAD_NS); ExprSpec (Sacado::Fad); ExprSpec< Expr< ExprT, Spec > > (Sacado::Fad); ExprSpec< PowerOp< ConstExpr< T1 >, ExprT2 > > (Sacado::Fad); ExprSpec< PowerOp< ExprT1, ConstExpr< T2 > > > (Sacado::Fad); ExprSpec< PowerOp< ExprT1, ExprT2 > > (Sacado::Fad); ExprSpecDefault (Sacado::Fad::Exp); ExprSpecDefault (Sacado::Fad); Extender (Sacado::Fad::Exp)

G: GeneralFad (Sacado::CacheFad); GeneralFad (Sacado::ELRCacheFad); GeneralFad (Sacado::ELRFad); GeneralFad (Sacado::Fad::Exp); GeneralFad (Sacado::Fad)

I: IfThenElseOp (Sacado::Fad::Exp); IfThenElseOp< CondT, T1, T2, false, false, ExprSpecDefault > (Sacado::Fad::Exp); IfThenElseOp< CondT, T1, T2, false, true, ExprSpecDefault > (Sacado::Fad::Exp); IfThenElseOp< CondT, T1, T2, true, false, ExprSpecDefault > (Sacado::Fad::Exp); IndepADvar (Sacado::Rad2d); IndepADvar (Sacado::Rad2); IndepADvar (Sacado::RadVec); IndepADvar (Sacado::Rad); IndepADvar (Sacado::Radnt); IndepADvar_base (Sacado::Rad); IndepADvar_base0 (Sacado::Rad); inner_layout (Kokkos); inner_layout< LayoutContiguous< Layout > > (Kokkos); inner_layout< LayoutContiguous< Layout, Stride > > (Kokkos); inner_layout< LayoutNatural< Layout > > (Kokkos); integral_c (Sacado::mpl); integral_nonzero (Sacado); integral_nonzero< T, zero, false > (Sacado); integral_nonzero_constant (Sacado::mpl); integral_nonzero_constant< T, zero, false > (Sacado::mpl); is_convertible (Sacado::mpl); is_cuda_space; is_dfad; is_dfad< Sacado::Fad::DFad< T > >; is_layout_contiguous (Kokkos); is_layout_contiguous< LayoutContiguous< Layout > > (Kokkos); is_layout_natural (Kokkos); is_layout_natural< LayoutNatural< Layout > > (Kokkos); is_placeholder (Sacado::mpl); is_placeholder< arg< N > > (Sacado::mpl); is_placeholder< F< T1 > > (Sacado::mpl); is_placeholder< F< T1, T2 > > (Sacado::mpl); is_placeholder< F< T1, T2, T3 > > (Sacado::mpl); is_placeholder< F< T1, T2, T3, T4 > > (Sacado::mpl); is_placeholder< F< T1, T2, T3, T4, T5 > > (Sacado::mpl); is_same (Sacado::mpl); is_same< Kokkos::LayoutContiguous< Layout, Stride >, Layout > (std); is_same< Kokkos::LayoutNatural< Layout >, Layout > (std); is_same< Layout, Kokkos::LayoutContiguous< Layout, Stride > > (std); is_same< Layout, Kokkos::LayoutNatural< Layout > > (std); is_same< T, T > (Sacado::mpl); is_sfad; is_sfad< Sacado::Fad::SFad< T, N > >; IsADType (Sacado); IsADType< CacheFad::DFad< ValueT > > (Sacado); IsADType< CacheFad::Expr< T > > (Sacado); IsADType< CacheFad::SFad< ValueT, Num > > (Sacado); IsADType< CacheFad::SLFad< ValueT, Num > > (Sacado); IsADType< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsADType< ELRCacheFad::DFad< ValueT > > (Sacado); IsADType< ELRCacheFad::Expr< T > > (Sacado); IsADType< ELRCacheFad::SFad< ValueT, Num > > (Sacado); IsADType< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); IsADType< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsADType< ELRFad::DFad< ValueT > > (Sacado); IsADType< ELRFad::Expr< T > > (Sacado); IsADType< ELRFad::SFad< ValueT, Num > > (Sacado); IsADType< ELRFad::SLFad< ValueT, Num > > (Sacado); IsADType< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsADType< Fad::DFad< ValueT > > (Sacado); IsADType< Fad::DVFad< ValueT > > (Sacado); IsADType< Fad::Exp::Expr< T > > (Sacado); IsADType< Fad::Exp::GeneralFad< Storage > > (Sacado); IsADType< Fad::Expr< T > > (Sacado); IsADType< Fad::SFad< ValueT, Num > > (Sacado); IsADType< Fad::SimpleFad< ValueT > > (Sacado); IsADType< Fad::SLFad< ValueT, Num > > (Sacado); IsADType< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsADType< FlopCounterPack::ScalarFlopCounter< ScalarT > > (Sacado); IsADType< LFad::Expr< T > > (Sacado); IsADType< LFad::LogicalSparse< ValT, LogT > > (Sacado); IsADType< Rad2::ADvar< T > > (Sacado); IsADType< Rad2::ADvari< T > > (Sacado); IsADType< Rad::ADvar< T > > (Sacado); IsADType< Rad::ADvari< T > > (Sacado); IsADType< RadVec::ADvar< T > > (Sacado); IsADType< RadVec::ADvari< T > > (Sacado); IsADType< Tay::CacheTaylor< T > > (Sacado); IsADType< Tay::Taylor< T > > (Sacado); IsEqual (Sacado); IsEqual< CacheFad::DFad< ValueT > > (Sacado); IsEqual< CacheFad::SFad< ValueT, Num > > (Sacado); IsEqual< CacheFad::SLFad< ValueT, Num > > (Sacado); IsEqual< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsEqual< ELRCacheFad::DFad< ValueT > > (Sacado); IsEqual< ELRCacheFad::SFad< ValueT, Num > > (Sacado); IsEqual< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); IsEqual< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsEqual< ELRFad::DFad< ValueT > > (Sacado); IsEqual< ELRFad::SFad< ValueT, Num > > (Sacado); IsEqual< ELRFad::SLFad< ValueT, Num > > (Sacado); IsEqual< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsEqual< Fad::DFad< ValueT > > (Sacado); IsEqual< Fad::DVFad< ValueT > > (Sacado); IsEqual< Fad::Exp::GeneralFad< Storage > > (Sacado); IsEqual< Fad::SFad< ValueT, Num > > (Sacado); IsEqual< Fad::SimpleFad< ValueT > > (Sacado); IsEqual< Fad::SLFad< ValueT, Num > > (Sacado); IsEqual< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsEqual< LFad::LogicalSparse< ValT, LogT > > (Sacado); IsEqual< Tay::CacheTaylor< T > > (Sacado); IsEqual< Tay::Taylor< T > > (Sacado); IsExpr (Sacado); IsExpr< CacheFad::Expr< T > > (Sacado); IsExpr< ELRCacheFad::Expr< T > > (Sacado); IsExpr< ELRFad::Expr< T > > (Sacado); IsExpr< Fad::DVFad< T > > (Sacado); IsExpr< Fad::Exp::Expr< T > > (Sacado); IsExpr< Fad::Exp::GeneralFad< S > > (Sacado); IsExpr< Fad::Exp::IfThenElseOp< CondT, T1, T2, c1, c2, E > > (Sacado); IsExpr< Fad::Expr< T > > (Sacado); IsExpr< FAD_NS::DFad< T > > (Sacado); IsExpr< FAD_NS::SFad< T, N > > (Sacado); IsExpr< FAD_NS::SLFad< T, N > > (Sacado); IsExpr< FAD_NS::ViewFad< T, l, s, U > > (Sacado); IsExpr< LFad::Expr< T > > (Sacado); IsExpr< LFad::LogicalSparse< T, L > > (Sacado); IsExpr< Tay::Expr< T > > (Sacado); IsFad (Sacado); IsFad< const T > (Sacado); IsFad< Fad::DVFad< T > > (Sacado); IsFad< Fad::Exp::GeneralFad< S > > (Sacado); IsFad< Fad::SimpleFad< ValueT > > (Sacado); IsFad< FAD_NS::DFad< T > > (Sacado); IsFad< FAD_NS::SFad< T, N > > (Sacado); IsFad< FAD_NS::SLFad< T, N > > (Sacado); IsFad< FAD_NS::ViewFad< T, l, s, U > > (Sacado); IsFadExpr (Sacado::CacheFad); IsFadExpr (Sacado::ELRCacheFad); IsFadExpr (Sacado::ELRFad); IsFadExpr (Sacado::Fad::Exp); IsFadExpr (Sacado::Fad); IsFadExpr (Sacado::LFad); IsFadExpr< DFad< T > > (Sacado::FAD_NS); IsFadExpr< DVFad< T > > (Sacado::Fad); IsFadExpr< Expr< T > > (Sacado::CacheFad); IsFadExpr< Expr< T > > (Sacado::ELRCacheFad); IsFadExpr< Expr< T > > (Sacado::ELRFad); IsFadExpr< Expr< T > > (Sacado::Fad::Exp); IsFadExpr< Expr< T > > (Sacado::Fad); IsFadExpr< Expr< T > > (Sacado::LFad); IsFadExpr< GeneralFad< S > > (Sacado::Fad::Exp); IsFadExpr< IfThenElseOp< CondT, T1, T2, c1, c2, E > > (Sacado::Fad::Exp); IsFadExpr< SFad< T, N > > (Sacado::FAD_NS); IsFadExpr< SLFad< T, N > > (Sacado::FAD_NS); IsFadExpr< ViewFad< T, l, s, U > > (Sacado::FAD_NS); IsScalarType (Sacado); IsScalarType< CacheFad::DFad< ValueT > > (Sacado); IsScalarType< CacheFad::Expr< T > > (Sacado); IsScalarType< CacheFad::SFad< ValueT, Num > > (Sacado); IsScalarType< CacheFad::SLFad< ValueT, Num > > (Sacado); IsScalarType< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsScalarType< ELRCacheFad::DFad< ValueT > > (Sacado); IsScalarType< ELRCacheFad::Expr< T > > (Sacado); IsScalarType< ELRCacheFad::SFad< ValueT, Num > > (Sacado); IsScalarType< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); IsScalarType< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsScalarType< ELRFad::DFad< ValueT > > (Sacado); IsScalarType< ELRFad::Expr< T > > (Sacado); IsScalarType< ELRFad::SFad< ValueT, Num > > (Sacado); IsScalarType< ELRFad::SLFad< ValueT, Num > > (Sacado); IsScalarType< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsScalarType< Fad::DFad< ValueT > > (Sacado); IsScalarType< Fad::DVFad< ValueT > > (Sacado); IsScalarType< Fad::Exp::Expr< T > > (Sacado); IsScalarType< Fad::Exp::GeneralFad< Storage > > (Sacado); IsScalarType< Fad::Expr< T > > (Sacado); IsScalarType< Fad::SFad< ValueT, Num > > (Sacado); IsScalarType< Fad::SimpleFad< ValueT > > (Sacado); IsScalarType< Fad::SLFad< ValueT, Num > > (Sacado); IsScalarType< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsScalarType< FlopCounterPack::ScalarFlopCounter< ScalarT > > (Sacado); IsScalarType< LFad::Expr< T > > (Sacado); IsScalarType< LFad::LogicalSparse< ValT, LogT > > (Sacado); IsScalarType< Rad2::ADvar< T > > (Sacado); IsScalarType< Rad2::ADvari< T > > (Sacado); IsScalarType< Rad::ADvar< T > > (Sacado); IsScalarType< Rad::ADvari< T > > (Sacado); IsScalarType< RadVec::ADvar< T > > (Sacado); IsScalarType< RadVec::ADvari< T > > (Sacado); IsScalarType< Tay::CacheTaylor< T > > (Sacado); IsScalarType< Tay::Taylor< T > > (Sacado); IsSimdType (Sacado); IsSimdType< Fad::DFad< ValueT > > (Sacado); IsSimdType< Fad::DVFad< ValueT > > (Sacado); IsSimdType< Fad::Exp::Expr< T > > (Sacado); IsSimdType< Fad::Exp::GeneralFad< Storage > > (Sacado); IsSimdType< Fad::Expr< T > > (Sacado); IsSimdType< Fad::SFad< ValueT, Num > > (Sacado); IsSimdType< Fad::SimpleFad< ValueT > > (Sacado); IsSimdType< Fad::SLFad< ValueT, Num > > (Sacado); IsSimdType< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsStaticallySized (Sacado); IsStaticallySized< CacheFad::DFad< ValueT > > (Sacado); IsStaticallySized< CacheFad::SFad< ValueT, Num > > (Sacado); IsStaticallySized< CacheFad::SLFad< ValueT, Num > > (Sacado); IsStaticallySized< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsStaticallySized< const CacheFad::DFad< ValueT > > (Sacado); IsStaticallySized< const CacheFad::SFad< ValueT, Num > > (Sacado); IsStaticallySized< const CacheFad::SLFad< ValueT, Num > > (Sacado); IsStaticallySized< const ELRCacheFad::DFad< ValueT > > (Sacado); IsStaticallySized< const ELRCacheFad::SFad< ValueT, Num > > (Sacado); IsStaticallySized< const ELRCacheFad::SLFad< ValueT, Num > > (Sacado); IsStaticallySized< const ELRFad::DFad< ValueT > > (Sacado); IsStaticallySized< const ELRFad::SFad< ValueT, Num > > (Sacado); IsStaticallySized< const ELRFad::SLFad< ValueT, Num > > (Sacado); IsStaticallySized< const Fad::DFad< ValueT > > (Sacado); IsStaticallySized< const Fad::Exp::GeneralFad< Storage > > (Sacado); IsStaticallySized< const Fad::SFad< ValueT, Num > > (Sacado); IsStaticallySized< const Fad::SLFad< ValueT, Num > > (Sacado); IsStaticallySized< const T > (Sacado); IsStaticallySized< ELRCacheFad::DFad< ValueT > > (Sacado); IsStaticallySized< ELRCacheFad::SFad< ValueT, Num > > (Sacado); IsStaticallySized< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); IsStaticallySized< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsStaticallySized< ELRFad::DFad< ValueT > > (Sacado); IsStaticallySized< ELRFad::SFad< ValueT, Num > > (Sacado); IsStaticallySized< ELRFad::SLFad< ValueT, Num > > (Sacado); IsStaticallySized< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsStaticallySized< Fad::DFad< ValueT > > (Sacado); IsStaticallySized< Fad::DVFad< ValueT > > (Sacado); IsStaticallySized< Fad::Exp::GeneralFad< Storage > > (Sacado); IsStaticallySized< Fad::SFad< ValueT, Num > > (Sacado); IsStaticallySized< Fad::SimpleFad< ValueT > > (Sacado); IsStaticallySized< Fad::SLFad< ValueT, Num > > (Sacado); IsStaticallySized< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); IsStaticallySized< FlopCounterPack::ScalarFlopCounter< ScalarT > > (Sacado); IsStaticallySized< LFad::LogicalSparse< ValT, LogT > > (Sacado); IsStaticallySized< Tay::CacheTaylor< T > > (Sacado); IsStaticallySized< Tay::Taylor< T > > (Sacado); IsView (Sacado); IsView< Fad::Exp::GeneralFad< S > > (Sacado); IsView< Sacado::FAD_NS::ViewFad< T, l, s, U > > (Sacado)

L: lambda (Sacado::mpl); lambda< F< T1 > > (Sacado::mpl); lambda< F< T1, T2 > > (Sacado::mpl); lambda< F< T1, T2, T3 > > (Sacado::mpl); lambda< F< T1, T2, T3, T4 > > (Sacado::mpl); lambda< F< T1, T2, T3, T4, T5 > > (Sacado::mpl); LAPACK< OrdinalType, Sacado::Fad::DFad< ScalarType > > (Teuchos); LayoutContiguous (Kokkos); LayoutNatural (Kokkos); LayoutScalarStride (Kokkos::Impl); LayoutScalarStride< LayoutContiguous< Layout, Stride > > (Kokkos::Impl); lazy_disable_if (Sacado::mpl); lazy_disable_if_c (Sacado::mpl); lazy_disable_if_c< false, T > (Sacado::mpl); lazy_enable_if (Sacado::mpl); lazy_enable_if_c (Sacado::mpl); lazy_enable_if_c< true, T > (Sacado::mpl); Expr< SFadExprTag< T, Num > >::LocalAccumOp (Sacado::ELRCacheFad); Expr< SFadExprTag< T, Num > >::LocalAccumOp (Sacado::ELRFad); Log10ExprType (Sacado::Tay); Log10Op (Sacado::Fad::Exp); Log10Op (Sacado::Fad); LogicalSparse (Sacado::LFad); LogicalSparseImp (Sacado::LFad); LogicalSparseOpsUnitTest; LogOp (Sacado::Fad::Exp); LogOp (Sacado::Fad); LogOp (Sacado::Tay)

M: make_void (Sacado::mpl); MakeFad; MakeFad< 1 >; MapGridUnitCube (Kokkos::Example); MarkConstant (Sacado); MarkConstant< Rad2::ADvar< T > > (Sacado); MarkConstant< Rad2::ADvari< T > > (Sacado); MarkConstant< Rad::ADvar< T > > (Sacado); MarkConstant< Rad::ADvari< T > > (Sacado); MarkConstant< RadVec::ADvar< T > > (Sacado); MarkConstant< RadVec::ADvari< T > > (Sacado); MaxOp (Sacado::Fad); MaxOp (Sacado::Tay); MaxOp (Sacado::Fad::Exp); MaxOp< ConstExpr< typename ExprT2::value_type >, ExprT2 > (Sacado::Tay); MaxOp< ExprT1, ConstExpr< typename ExprT1::value_type > > (Sacado::Tay); MinOp (Sacado::Fad::Exp); MinOp (Sacado::Fad); MinOp (Sacado::Tay); MinOp< ConstExpr< typename ExprT2::value_type >, ExprT2 > (Sacado::Tay); MinOp< ExprT1, ConstExpr< typename ExprT1::value_type > > (Sacado::Tay); mpl_if (Sacado::mpl); mpl_if_c (Sacado::mpl); mpl_if_c< false, T1, T2 > (Sacado::mpl); mpl_if_c< true, T1, T2 > (Sacado::mpl); ExprFuncs::mult; ExprFuncs::mult< T, 1 >; ExprFuncs::mult< T, 10 >; ExprFuncs::mult< T, 15 >; ExprFuncs::mult< T, 2 >; ExprFuncs::mult< T, 20 >; ExprFuncs::mult< T, 3 >; ExprFuncs::mult< T, 4 >; ExprFuncs::mult< T, 5 >; ExprFuncs::mult_base; MultiplicationOp (Sacado::Tay); MultiplicationOp< ConstExpr< typename ExprT2::value_type >, ExprT2 > (Sacado::Tay); MultiplicationOp< ExprT1, ConstExpr< typename ExprT1::value_type > > (Sacado::Tay); Multiplicationp (Sacado::Fad::Exp); Multiplicationp (Sacado::Fad); MultiplyKernel; MyClass

N: ExprFuncs::nest; ExprFuncs::nest< T, 1 >; ExprFuncs::nest< T, 10 >; ExprFuncs::nest< T, 15 >; ExprFuncs::nest< T, 2 >; ExprFuncs::nest< T, 20 >; ExprFuncs::nest< T, 3 >; ExprFuncs::nest< T, 4 >; ExprFuncs::nest< T, 5 >; ExprFuncs::nest_base; next (Sacado::mpl); next< range_c_iterator< Range, Pos > > (Sacado::mpl); NodeNodeGraph (Kokkos::Example::FENL); none (Sacado::mpl)

O: OverrideDefaultPromote (Sacado)

P: ParameterAccessor (Sacado); ParameterFamilyBase (Sacado); ParameterLibraryBase (Sacado); ParameterRegistration (Sacado); ParameterVectorBase (Sacado); Perf; PowerOp (Sacado::Fad::Exp); PowerOp (Sacado::Fad); PowExprType (Sacado::Tay); PowExprType< ExprT1, typename ExprT1::value_type > (Sacado::Tay); PowExprType< typename ExprT2::value_type, ExprT2 > (Sacado::Tay); Promote (Sacado); Promote< A, A, typename mpl::enable_if_c< !OverrideDefaultPromote< A >::value >::type > (Sacado); Promote< A, B, typename mpl::enable_if_c< !mpl::is_convertible< A, B >::value &&!mpl::is_convertible< B, A >::value &&IsExpr< A >::value &&IsExpr::value &&mpl::is_same< typename BaseExprType< typename A::value_type >::type, typename BaseExprType< typename B::value_type >::type >::value >::type > (Sacado); Promote< A, B, typename mpl::enable_if_c< !mpl::is_convertible< A, B >::value &&!mpl::is_convertible< B, A >::value &&IsExpr< A >::value &&mpl::is_convertible< B, typename BaseExprType< typename A::value_type >::type >::value >::type > (Sacado); Promote< A, B, typename mpl::enable_if_c< !mpl::is_convertible< A, B >::value &&!mpl::is_convertible< B, A >::value &&IsExpr::value &&mpl::is_convertible< A, typename BaseExprType< typename B::value_type >::type >::value >::type > (Sacado); Promote< A, B, typename mpl::enable_if_c< mpl::is_convertible< A, B >::value &&!mpl::is_convertible< B, A >::value &&!OverrideDefaultPromote< A >::value &&!OverrideDefaultPromote::value >::type > (Sacado); Promote< A, B, typename mpl::enable_if_c< mpl::is_convertible< A, B >::value &&mpl::is_convertible< B, A >::value &&!mpl::is_same< A, B >::value &&(IsExpr< A >::value||IsExpr::value) >::type > (Sacado); Promote< A, B, typename mpl::enable_if_c< mpl::is_convertible< B, A >::value &&!mpl::is_convertible< A, B >::value &&!OverrideDefaultPromote< A >::value &&!OverrideDefaultPromote::value >::type > (Sacado); push_back (Sacado::mpl); push_back_impl (Sacado::mpl)

S: SafeSqrtOp (Sacado::ELRCacheFad); SafeSqrtOp (Sacado::CacheFad); SafeSqrtOp (Sacado::Fad); SafeSqrtOp (Sacado::ELRFad); SafeSqrtOp (Sacado::Fad::Exp); ScalarAssignKernel; ScalarFlopCounter (Sacado::FlopCounterPack); ScalarParameterEntry (Sacado); ScalarParameterFamily (Sacado); ScalarParameterLibrary (Sacado); ScalarParameterVector (Sacado); ScalarType (Sacado); ScalarType< CacheFad::DFad< ValueT > > (Sacado); ScalarType< CacheFad::Expr< T > > (Sacado); ScalarType< CacheFad::SFad< ValueT, Num > > (Sacado); ScalarType< CacheFad::SLFad< ValueT, Num > > (Sacado); ScalarType< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarType< const T > (Sacado); ScalarType< ELRCacheFad::DFad< ValueT > > (Sacado); ScalarType< ELRCacheFad::Expr< T > > (Sacado); ScalarType< ELRCacheFad::SFad< ValueT, Num > > (Sacado); ScalarType< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); ScalarType< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarType< ELRFad::DFad< ValueT > > (Sacado); ScalarType< ELRFad::Expr< T > > (Sacado); ScalarType< ELRFad::SFad< ValueT, Num > > (Sacado); ScalarType< ELRFad::SLFad< ValueT, Num > > (Sacado); ScalarType< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarType< Fad::DFad< ValueT > > (Sacado); ScalarType< Fad::DVFad< ValueT > > (Sacado); ScalarType< Fad::Exp::Expr< T > > (Sacado); ScalarType< Fad::Exp::GeneralFad< Storage > > (Sacado); ScalarType< Fad::Exp::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarType< Fad::Expr< T > > (Sacado); ScalarType< Fad::SFad< ValueT, Num > > (Sacado); ScalarType< Fad::SimpleFad< ValueT > > (Sacado); ScalarType< Fad::SLFad< ValueT, Num > > (Sacado); ScalarType< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarType< FlopCounterPack::ScalarFlopCounter< ScalarT > > (Sacado); ScalarType< LFad::Expr< T > > (Sacado); ScalarType< LFad::LogicalSparse< ValT, LogT > > (Sacado); ScalarType< Rad2::ADvar< T > > (Sacado); ScalarType< Rad2::ADvari< T > > (Sacado); ScalarType< Rad::ADvar< T > > (Sacado); ScalarType< Rad::ADvari< T > > (Sacado); ScalarType< RadVec::ADvar< T > > (Sacado); ScalarType< RadVec::ADvari< T > > (Sacado); ScalarType< Tay::CacheTaylor< T > > (Sacado); ScalarType< Tay::Taylor< T > > (Sacado); ScalarValue (Sacado); ScalarValue< CacheFad::DFad< ValueT > > (Sacado); ScalarValue< CacheFad::Expr< T > > (Sacado); ScalarValue< CacheFad::SFad< ValueT, Num > > (Sacado); ScalarValue< CacheFad::SLFad< ValueT, Num > > (Sacado); ScalarValue< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarValue< const T > (Sacado); ScalarValue< ELRCacheFad::DFad< ValueT > > (Sacado); ScalarValue< ELRCacheFad::Expr< T > > (Sacado); ScalarValue< ELRCacheFad::SFad< ValueT, Num > > (Sacado); ScalarValue< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); ScalarValue< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarValue< ELRFad::DFad< ValueT > > (Sacado); ScalarValue< ELRFad::Expr< T > > (Sacado); ScalarValue< ELRFad::SFad< ValueT, Num > > (Sacado); ScalarValue< ELRFad::SLFad< ValueT, Num > > (Sacado); ScalarValue< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarValue< Fad::DFad< ValueT > > (Sacado); ScalarValue< Fad::DVFad< ValueT > > (Sacado); ScalarValue< Fad::Exp::Expr< T > > (Sacado); ScalarValue< Fad::Exp::GeneralFad< Storage > > (Sacado); ScalarValue< Fad::Expr< T > > (Sacado); ScalarValue< Fad::SFad< ValueT, Num > > (Sacado); ScalarValue< Fad::SimpleFad< ValueT > > (Sacado); ScalarValue< Fad::SLFad< ValueT, Num > > (Sacado); ScalarValue< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ScalarValue< FlopCounterPack::ScalarFlopCounter< ScalarT > > (Sacado); ScalarValue< LFad::Expr< T > > (Sacado); ScalarValue< LFad::LogicalSparse< ValT, LogT > > (Sacado); ScalarValue< Rad2::ADvar< T > > (Sacado); ScalarValue< Rad::ADvar< T > > (Sacado); ScalarValue< RadVec::ADvar< T > > (Sacado); ScalarValue< Tay::CacheTaylor< T > > (Sacado); ScalarValue< Tay::Taylor< T > > (Sacado); SetFunctor; SFad (Sacado::ELRCacheFad); SFad (Sacado::ELRFad); SFad (Sacado::Fad); SFad (Sacado::FAD_NS); SFad (Sacado::CacheFad); SFadExprTag (Sacado::CacheFad); SFadExprTag (Sacado::ELRCacheFad); SFadExprTag (Sacado::ELRFad); SFadExprTag (Sacado::Fad); SimpleFad (Sacado::Fad); SinhOp (Sacado::Fad); SinhOp (Sacado::Tay); SinhOp (Sacado::Fad::Exp); SinOp (Sacado::Fad::Exp); SinOp (Sacado::Fad); SinOp (Sacado::Tay); size (Sacado::mpl); size_impl (Sacado::mpl); size_impl< range_c_tag > (Sacado::mpl); SLFad (Sacado::CacheFad); SLFad (Sacado::FAD_NS); SLFad (Sacado::Fad); SLFad (Sacado::ELRCacheFad); SLFad (Sacado::ELRFad); GeneralFad::SlowLocalAccumOp (Sacado::ELRCacheFad); GeneralFad::SlowLocalAccumOp (Sacado::ELRFad); SqrtOp (Sacado::Fad::Exp); SqrtOp (Sacado::Fad); SqrtOp (Sacado::Tay); ss_array (Sacado); ss_array< T, true > (Sacado); StaticFixedStorage (Sacado::Fad::Exp); StaticSize (Sacado); StaticSize< CacheFad::SFad< ValueT, Num > > (Sacado); StaticSize< const CacheFad::SFad< ValueT, Num > > (Sacado); StaticSize< const ELRCacheFad::SFad< ValueT, Num > > (Sacado); StaticSize< const ELRFad::SFad< ValueT, Num > > (Sacado); StaticSize< const Fad::Exp::GeneralFad< Storage > > (Sacado); StaticSize< const Fad::SFad< ValueT, Num > > (Sacado); StaticSize< ELRCacheFad::SFad< ValueT, Num > > (Sacado); StaticSize< ELRFad::SFad< ValueT, Num > > (Sacado); StaticSize< Fad::Exp::GeneralFad< Storage > > (Sacado); StaticSize< Fad::SFad< ValueT, Num > > (Sacado); StaticStorage (Sacado::Fad::Exp); StaticStorage (Sacado::Fad); StaticStorage (Sacado::FAD_NS); StringName (Sacado); StringName< CacheFad::DFad< ValueT > > (Sacado); StringName< CacheFad::SFad< ValueT, Num > > (Sacado); StringName< CacheFad::SLFad< ValueT, Num > > (Sacado); StringName< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); StringName< ELRCacheFad::DFad< ValueT > > (Sacado); StringName< ELRCacheFad::SFad< ValueT, Num > > (Sacado); StringName< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); StringName< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); StringName< ELRFad::DFad< ValueT > > (Sacado); StringName< ELRFad::SFad< ValueT, Num > > (Sacado); StringName< ELRFad::SLFad< ValueT, Num > > (Sacado); StringName< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); StringName< Fad::DFad< ValueT > > (Sacado); StringName< Fad::DVFad< ValueT > > (Sacado); StringName< Fad::Exp::GeneralFad< Storage > > (Sacado); StringName< Fad::SFad< ValueT, Num > > (Sacado); StringName< Fad::SimpleFad< ValueT > > (Sacado); StringName< Fad::SLFad< ValueT, Num > > (Sacado); StringName< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); StringName< FlopCounterPack::ScalarFlopCounter< ScalarT > > (Sacado); StringName< LFad::LogicalSparse< ValT, LogT > > (Sacado); StringName< Rad2::ADvar< T > > (Sacado); StringName< Rad::ADvar< T > > (Sacado); StringName< RadVec::ADvar< T > > (Sacado); StringName< Tay::CacheTaylor< T > > (Sacado); StringName< Tay::Taylor< T > > (Sacado); SubtractionOp (Sacado::Fad::Exp); SubtractionOp (Sacado::Fad); SubtractionOp (Sacado::Tay); SubtractionOp< ConstExpr< typename ExprT2::value_type >, ExprT2 > (Sacado::Tay); SubtractionOp< ExprT1, ConstExpr< typename ExprT1::value_type > > (Sacado::Tay)

V: Value (Sacado); Value< CacheFad::DFad< ValueT > > (Sacado); Value< CacheFad::Expr< T > > (Sacado); Value< CacheFad::SFad< ValueT, Num > > (Sacado); Value< CacheFad::SLFad< ValueT, Num > > (Sacado); Value< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); Value< const T > (Sacado); Value< ELRCacheFad::DFad< ValueT > > (Sacado); Value< ELRCacheFad::Expr< T > > (Sacado); Value< ELRCacheFad::SFad< ValueT, Num > > (Sacado); Value< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); Value< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); Value< ELRFad::DFad< ValueT > > (Sacado); Value< ELRFad::Expr< T > > (Sacado); Value< ELRFad::SFad< ValueT, Num > > (Sacado); Value< ELRFad::SLFad< ValueT, Num > > (Sacado); Value< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); Value< Fad::DFad< ValueT > > (Sacado); Value< Fad::DVFad< ValueT > > (Sacado); Value< Fad::Exp::Expr< T > > (Sacado); Value< Fad::Exp::GeneralFad< Storage > > (Sacado); Value< Fad::Expr< T > > (Sacado); Value< Fad::SFad< ValueT, Num > > (Sacado); Value< Fad::SimpleFad< ValueT > > (Sacado); Value< Fad::SLFad< ValueT, Num > > (Sacado); Value< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); Value< FlopCounterPack::ScalarFlopCounter< ScalarT > > (Sacado); Value< LFad::Expr< T > > (Sacado); Value< LFad::LogicalSparse< ValT, LogT > > (Sacado); Value< Rad2::ADvar< T > > (Sacado); Value< Rad::ADvar< T > > (Sacado); Value< RadVec::ADvar< T > > (Sacado); Value< Tay::CacheTaylor< T > > (Sacado); Value< Tay::Taylor< T > > (Sacado); ValueAssignKernel; ValueType (Sacado); ValueType< CacheFad::DFad< ValueT > > (Sacado); ValueType< CacheFad::Expr< T > > (Sacado); ValueType< CacheFad::SFad< ValueT, Num > > (Sacado); ValueType< CacheFad::SLFad< ValueT, Num > > (Sacado); ValueType< CacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ValueType< const T > (Sacado); ValueType< ELRCacheFad::DFad< ValueT > > (Sacado); ValueType< ELRCacheFad::Expr< T > > (Sacado); ValueType< ELRCacheFad::SFad< ValueT, Num > > (Sacado); ValueType< ELRCacheFad::SLFad< ValueT, Num > > (Sacado); ValueType< ELRCacheFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ValueType< ELRFad::DFad< ValueT > > (Sacado); ValueType< ELRFad::Expr< T > > (Sacado); ValueType< ELRFad::SFad< ValueT, Num > > (Sacado); ValueType< ELRFad::SLFad< ValueT, Num > > (Sacado); ValueType< ELRFad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ValueType< Fad::ConstExpr< T > > (Sacado); ValueType< Fad::DFad< ValueT > > (Sacado); ValueType< Fad::DVFad< ValueT > > (Sacado); ValueType< Fad::Exp::Expr< T > > (Sacado); ValueType< Fad::Exp::GeneralFad< Storage > > (Sacado); ValueType< Fad::Exp::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ValueType< Fad::Expr< T > > (Sacado); ValueType< Fad::SFad< ValueT, Num > > (Sacado); ValueType< Fad::SimpleFad< ValueT > > (Sacado); ValueType< Fad::SLFad< ValueT, Num > > (Sacado); ValueType< Fad::ViewFad< ValueT, Size, Stride, Base > > (Sacado); ValueType< FlopCounterPack::ScalarFlopCounter< ScalarT > > (Sacado); ValueType< LFad::Expr< T > > (Sacado); ValueType< LFad::LogicalSparse< ValT, LogT > > (Sacado); ValueType< Rad2::ADvar< T > > (Sacado); ValueType< Rad2::ADvari< T > > (Sacado); ValueType< Rad::ADvar< T > > (Sacado); ValueType< Rad::ADvari< T > > (Sacado); ValueType< RadVec::ADvar< T > > (Sacado); ValueType< RadVec::ADvari< T > > (Sacado); ValueType< Tay::CacheTaylor< T > > (Sacado); ValueType< Tay::Taylor< T > > (Sacado); Vector (Sacado::Fad); Vector< OrdinalType, Sacado::Fad::DVFad< ValueType > > (Sacado::Fad); vector_at (Sacado::mpl); vector_at< mpl::vector< T, Args... >, 0 > (Sacado::mpl); vector_at< mpl::vector< T, Args... >, Pos > (Sacado::mpl); vector_push_back (Sacado::mpl); vector_push_back< mpl::vector< Args... >, T > (Sacado::mpl); vector_size (Sacado::mpl); VectorDynamicStorage (Sacado::Fad); VectorDynamicStorage (Sacado::Fad::Exp); ViewFactory (Kokkos); ViewFactoryType (Kokkos::Impl); ViewFactoryType< View > (Kokkos::Impl); ViewFactoryType< View, ViewPack... > (Kokkos::Impl); ViewFad (Sacado::CacheFad); ViewFad (Sacado::ELRCacheFad); ViewFad (Sacado::ELRFad); ViewFad (Sacado::Fad); ViewFad (Sacado::FAD_NS); ViewFadPtr (Sacado::Fad::Exp); ViewFadPtr (Sacado::FAD_NS); ViewFadType (Sacado); ViewFadType< const Fad::Exp::GeneralFad< S >, length, stride > (Sacado); ViewFadType< const Sacado::Fad::DVFad< ValueType >, length, stride > (Sacado); ViewFadType< const Sacado::FAD_NS::DFad< ValueType >, length, stride > (Sacado); ViewFadType< const Sacado::FAD_NS::SFad< ValueType, N >, length, stride > (Sacado); ViewFadType< const Sacado::FAD_NS::SLFad< ValueType, N >, length, stride > (Sacado); ViewFadType< Fad::Exp::GeneralFad< S >, length, stride > (Sacado); ViewFadType< Sacado::Fad::DVFad< ValueType >, length, stride > (Sacado); ViewFadType< Sacado::FAD_NS::DFad< ValueType >, length, stride > (Sacado); ViewFadType< Sacado::FAD_NS::SFad< ValueType, N >, length, stride > (Sacado); ViewFadType< Sacado::FAD_NS::SLFad< ValueType, N >, length, stride > (Sacado); ViewOffset< Dimension, LayoutContiguous< Layout, Stride >, void > (Kokkos::Impl); ViewOffset< Dimension, LayoutNatural< Layout >, void > (Kokkos::Impl); ViewStorage (Sacado::Fad::Exp); ViewStorage (Sacado::Fad)