Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

Ccodi::ActiveArgumentPointerStore< T_Real, T_Identifier, T_Gradient >	Declares all variables that may be needed to store/restore an active argument which has a pointer type
Ccodi::ActiveArgumentStoreInterface< T_Real, T_Identifier, T_Gradient >	Interface for restored data for an argument. The functions should return a compatible type that can be forwarded to the primal evaluation and the gradient computation
Ccodi::ActiveArgumentStoreTraits< T_T, typename >	Traits for storing active arguments in byte streams
Ccodi::ActiveArgumentValueStore< T_PointerStore >	Declares all variables that may be needed to store/restore an active argument which has a value type
Ccodi::ComputationTraits::AdjointConversionImpl< T_Outer, T_Inner, typename >	Perform the conversion of Outer(Inner) in the adjoint context. Default implementation for Outer == Inner
Ccodi::AggregatedTypeVectorAccessWrapperFactory< T_Type, typename >	Factory for the creation of AggregatedTypeVectorAccessWrapper instances
Ccodi::Algorithms< T_Type, T_ActiveChecks >	Basic algorithms for tape evaluation in CoDiPack
►Ccodi::ArrayPosition< T_NestedPosition >	Position with one index for e.g. array access
Ccodi::ChunkPosition< T_NestedPosition >	Position with two indices for e.g. chunked data access
►Ccodi::AssignmentOperators< T_Tape, T_Impl >	Implementation of assignment operators for LhsExpressionInterface implementations
►Ccodi::ActiveTypeBase< T_Tape, ActiveType< T_Tape > >
Ccodi::ActiveType< T_Tape >	Represents a concrete lvalue in the CoDiPack expression tree
►Ccodi::ActiveTypeBase< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > >
Ccodi::ParallelActiveType< T_Tape, T_ParallelToolbox >	Represents a concrete lvalue in the CoDiPack expression tree
Ccodi::ActiveTypeBase< T_Tape, T_Impl >	Represents the base implementation concrete lvalue in the CoDiPack expression tree
►Ccodi::AssignmentOperators< T_ActiveType::Tape, ActiveTypeWrapper< T_ActiveType > >
Ccodi::ActiveTypeWrapper< T_ActiveType >	Creates a pseudo active type from data references. Can be used to overlay existing data with active types
►Ccodi::AssignmentOperators< T_ActiveType::Tape, ImmutableActiveType< T_ActiveType > >
Ccodi::ImmutableActiveType< T_ActiveType >	Creates a pseudo active type from a data value. Can be used to overlay existing data with immutable active types
Ccodi::AssignmentOperators< T_Tape, ActiveType< T_Tape > >
►Ccodi::AssignmentOperators< T_Tape, ActiveTypeStatelessTape< T_Tape > >
Ccodi::ActiveTypeStatelessTape< T_Tape >	Represents a concrete lvalue in the CoDiPack expression tree
Ccodi::AssignmentOperators< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > >
►Ccodi::AssignmentOperators< T_Type, ReferenceActiveType< T_Type > >
Ccodi::ReferenceActiveType< T_Type >	Holds a reference to an ActiveType for manual optimization of common arguments
►Ccodi::AtomicInterface< T_Type, T_Impl >	Provides a data type on which operations are performed atomically
Ccodi::OpenMPAtomicImpl< T_Type, T_Sfinae >	Atomic implementation for OpenMP
Ccodi::AtomicInterface< T_Type, OpenMPAtomicImpl< T_Type, void > >
►Ccodi::BinaryOperation< T_Real >	Interface for implementing the logic for a BinaryExpression
Ccodi::OperationAdd< T_Real >	BinaryOperation implementation for operator +
Ccodi::OperationAtan2< T_Real >	BinaryOperation implementation for atan2
Ccodi::OperationCopysign< T_Real >	BinaryOperation implementation for copysign
Ccodi::OperationDivide< T_Real >	BinaryOperation implementation for operator /
Ccodi::OperationFmod< T_Real >	BinaryOperation implementation for fmod
Ccodi::OperationFrexp< T_Real >	BinaryOperation implementation for frexp
Ccodi::OperationHypot< T_Real >	BinaryOperation implementation for hypot
Ccodi::OperationLdexp< T_Real >	BinaryOperation implementation for ldexp
Ccodi::OperationMax< T_Real >	BinaryOperation implementation for max
Ccodi::OperationMin< T_Real >	BinaryOperation implementation for min
Ccodi::OperationMultiply< T_Real >	BinaryOperation implementation for operator *
Ccodi::OperationPow< T_Real >	BinaryOperation implementation for pow
Ccodi::OperationRemainder< T_Real >
Ccodi::OperationSubstract< T_Real >	BinaryOperation implementation for operator -
Ccodi::ByteDataView
►Ccodi::ChunkBase	A chunk stores a contiguous block of data in CoDiPack
Ccodi::Chunk1< Data1 >
Ccodi::Chunk2< Data1, Data2 >
Ccodi::Chunk3< Data1, Data2, Data3 >
Ccodi::Chunk4< Data1, Data2, Data3, Data4 >
Cstd::codi_numeric_limits< Type >	Specialization of std::numeric_limits for the default CoDiPack active types
►Cstd::codi_numeric_limits< codi::ActiveType< Tape > >
Cstd::numeric_limits< codi::ActiveType< Tape > >	Specialization of std::numeric_limits for CoDiPack active types
►Cstd::codi_numeric_limits< codi::ActiveTypeStatelessTape< Tape > >
Cstd::numeric_limits< codi::ActiveTypeStatelessTape< Tape > >	Specialization of std::numeric_limits for no tape CoDiPack active types
►Cstd::codi_numeric_limits< codi::ParallelActiveType< Tape, ParallelToolbox > >
Cstd::numeric_limits< codi::ParallelActiveType< Tape, ParallelToolbox > >	Specialization of std::numeric_limits for parallel CoDiPack active types
Ccodi::CoDiMpiTypes< T_Type, T_Tool >	MPI datatype implementation for CoDipack types in the type wrapper of MeDiPack
Ccodi::CommonTapeTypes< T_TapeTypes >	Declares all types used in the CommonTapeImplementation
Ccodi::CommonTapeTypes< ImplTapeTypes >
Ccodi::CompileTimeLoop< T_pos >	Compile time loop evaluation
Ccodi::CompileTimeLoop< 0 >	Termination of loop evaluation
Ccodi::CompileTimeTraversalLogic< T_ResultType, T_Impl >	Traversal of CoDiPack expressions during compile time
►Ccodi::CompileTimeTraversalLogic< size_t, NumberOfActiveTypeArguments< Expr > >
Ccodi::ExpressionTraits::NumberOfActiveTypeArguments< Expr >	Counts the number of nodes that inherit from LhsExpressionInterface in the expression
►Ccodi::CompileTimeTraversalLogic< size_t, NumberOfConstantTypeArguments< Expr > >
Ccodi::ExpressionTraits::NumberOfConstantTypeArguments< Expr >	Counts the number of types that inherit from ConstantExpression in the expression
►Ccodi::CompileTimeTraversalLogic< size_t, NumberOfOperations< Expr > >
Ccodi::ExpressionTraits::NumberOfOperations< Expr >	Counts the number of nodes in the expression
Ccodi::ConstantDataConversion< T_StoreData >
Ccodi::ConstructStaticContextLogic< T_Rhs, T_Tape, T_primalValueOffset, T_constantValueOffset, typename >	Helper class for the construction of an expression in a different context
Ccodi::ConstructVectorImpl< T_V, typename >
Ccodi::ConstructVectorImpl< std::array< T_T, T_n > >
►Ccodi::CustomAdjointVectorInterface< T_Type >	General interface for an arbitrary adjoint evaluation
Ccodi::CustomAdjointVectorHelper< T_Type, T_Gradient >	Allows for an arbitrary adjoint evaluation of a recorded tape
Ccodi::RealTraits::DataExtraction< T_Type, typename >	Data handling methods for aggregated types that contain CoDiPack active types
►Ccodi::DataInterface< T_NestedData, T_InternalPosHandle >	Data stream interface for tape data. Encapsulates data that is written e.g. for each statement or argument
Ccodi::BlockData< T_Chunk, T_NestedData, T_PointerInserter >	Data is stored in one contiguous block in this DataInterface implementation
Ccodi::ChunkedData< T_Chunk, T_NestedData, T_PointerInserter >	Data is stored chunk-wise in this DataInterface implementation. If a chunk runs out of space, a new chunk is allocated
►Ccodi::EmptyData	No data is stored in this DataInterface implementation. It is used to terminate the recursive nature of the DataInterface design
►Ccodi::ReuseIndexManagerBase< T_Index, ParallelReuseIndexManager< T_Index, T_ParallelToolbox > >
Ccodi::ParallelReuseIndexManager< T_Index, T_ParallelToolbox >	Reuse index manager with a one-to-one relation between tapes and index manager
►Ccodi::ReuseIndexManagerBase< T_Index, ReuseIndexManager< T_Index > >
►Ccodi::ReuseIndexManager< T_Index >	Reuse index manager with a many-to-one relation between tapes and index manager
Ccodi::MultiUseIndexManager< T_Index >	Extends the ReuseIndexManager with a copy optimization
Ccodi::ReuseIndexManagerBase< T_Index, T_Impl >	Identifiers are reused. Freed identifiers are assigned to new variables. Variables keep their indices as long as they are active
Ccodi::LinearIndexManager< T_Index >	Identifiers are created in a linear fashion. Each assign creates a new index which is counted up
Ccodi::DataInterface< EmptyData >
►Ccodi::DataManagementTapeInterface< T_Real, T_Identifier >	Provides file IO, information about internal tape vectors and allows to clear tape data
►Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
►Ccodi::CommonTapeImplementation< T_ImplTapeTypes, T_Impl >	Implementation of all common tape functionality
►Ccodi::JacobianBaseTape< T_TapeTypes, JacobianLinearTape< T_TapeTypes > >
Ccodi::JacobianLinearTape< T_TapeTypes >	Final implementation for a Jacobian tape with a linear index management
►Ccodi::JacobianBaseTape< T_TapeTypes, JacobianReuseTape< T_TapeTypes > >
Ccodi::JacobianReuseTape< T_TapeTypes >	Final implementation for a Jacobian tape with a reuse index management
►Ccodi::PrimalValueBaseTape< T_TapeTypes, PrimalValueLinearTape< T_TapeTypes > >
Ccodi::PrimalValueLinearTape< T_TapeTypes >	Final implementation for a primal value tape with a linear index management
►Ccodi::PrimalValueBaseTape< T_TapeTypes, PrimalValueReuseTape< T_TapeTypes > >
Ccodi::PrimalValueReuseTape< T_TapeTypes >	Final implementation for a primal value tape with a reuse index management
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
►Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::TagTapeReverse< T_Real, T_Tag >	Tape for tagging variables and find errors in the AD workflow
►Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
►Ccodi::CommonTapeImplementation< T_TapeTypes, T_Impl >
Ccodi::JacobianBaseTape< T_TapeTypes, T_Impl >	Base class for all standard Jacobian tape implementations
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >	Base class for all standard Primal value tape implementations
Ccodi::CommonTapeImplementation< T_TapeTypes, JacobianLinearTape< T_TapeTypes > >
Ccodi::CommonTapeImplementation< T_TapeTypes, JacobianReuseTape< T_TapeTypes > >
Ccodi::CommonTapeImplementation< T_TapeTypes, PrimalValueLinearTape< T_TapeTypes > >
Ccodi::CommonTapeImplementation< T_TapeTypes, PrimalValueReuseTape< T_TapeTypes > >
Ccodi::DataManagementTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Identifier >
Ccodi::DataManagementTapeInterface< T_Real, TagData< T_Tag > >
Ccodi::DerivativeAccess< T_Type >	A helper class for the access of the various derivatives in higher order AD types
Ccodi::Direction< T_Real, T_dim >	Fixed size vector mode implementation
Ccodi::DirectStatementEvaluatorStaticStore< Generator, Expr >
Ccodi::DummyValue	Dummy value that can be assigned
Ccodi::DummyVector	Dummy vector that provides a dummy element access and size function
Ccodi::DuplicateJacobianRemover< T_Real, T_Identifier >	Combines entries of Jacobians with the same identifier
Ccodi::EditingTapeInterface< T_Position >	Edit tapes after they have been recorded
►Ccodi::EditingTapeInterface< JacobianBaseTape< T_TapeTypes, JacobianReuseTape< T_TapeTypes > >::Position >
Ccodi::JacobianReuseTape< T_TapeTypes >	Final implementation for a Jacobian tape with a reuse index management
Ccodi::EigenLinearSystemTypes< T_Type, T_Matrix, T_Vector >	Eigen definition for the LinearSystemInterfaceTypes
Ccodi::EmptyPosition	Empty Position with no nested data
Ccodi::EnumBitset< T_Enum >	A bitset with enum items as flags
Ccodi::EnumBitset< LinearSystemSolverFlags >
Ccodi::EnumBitset< TagFlags >
►Ccodi::EvaluationHandleBase< T_Func, T_Type, T_InputStore, T_OutputStore >	Basic interface and data storage for all EvaluationHandle implementations
Ccodi::EvaluationHandleReverseBase< T_Func, T_Type, std::vector< T_Type >, std::vector< T_Type > >
Ccodi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, typename >	See EvaluationHandleBase
Ccodi::EvaluationHandleForward< T_Func, T_Type, T_InputStore, T_OutputStore >
►Ccodi::EvaluationHandleReverseBase< T_Func, T_Type, T_InputStore, T_OutputStore >	Implementation for reverse mode CoDiPack types of EvaluationHandleBase
Ccodi::EvaluationHandleReverseJacobianTapes< T_Func, T_Type, T_InputStore, T_OutputStore >	Implementation for Jacobian reverse mode CoDiPack types of EvaluationHandleBase
Ccodi::EvaluationHandleReversePrimalValueTapes< T_Func, T_Type, T_InputStore, T_OutputStore >	Implementation of EvaluationHandleBase for primal value reverse mode CoDiPack types
Ccodi::EvaluationHandleBase< T_Func, T_Type, std::vector< T_Type >, std::vector< T_Type > >
►Ccodi::EvaluationHandleBase< T_Func, T_Type, T_InputStore, T_OutputStore >
►Ccodi::EvaluationHandleForward< T_Func, T_Type, T_InputStore, T_OutputStore >
Ccodi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > >	See EvaluationHandleForward
►Ccodi::EvaluationHandleReverseBase< T_Func, T_Type, T_InputStore, T_OutputStore >
►Ccodi::EvaluationHandleReverseJacobianTapes< T_Func, T_Type, T_InputStore, T_OutputStore >
Ccodi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfJacobianTape< typename T_Type::Tape > >	See EvaluationHandleReverseJacobianTapes
►Ccodi::EvaluationHandleReversePrimalValueTapes< T_Func, T_Type, T_InputStore, T_OutputStore >
Ccodi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfPrimalValueTape< typename T_Type::Tape > >	See EvaluationHandleReversePrimalValueTapes
Ccodi::EvaluationHelper	Evaluate the primal, Jacobian and Hessian of function objects
►Ccodi::EventSystemBase< T_Tape >	Base class for the CoDiPack event system
Ccodi::EventSystem< T_Tape >	Full EventSystem implementation for reverse tapes
►Ccodi::EventSystemBase< ForwardEvaluation< Real, Gradient > >
Ccodi::EventSystem< ForwardEvaluation< Real, Gradient > >	Specialization for ForwardEvaluation
►Ccodi::ExternalFunctionHelper< T_Type, T_Synchronization, T_ThreadInformation >	Helper class for the implementation of an external function in CoDiPack
Ccodi::EnzymeExternalFunctionHelper< T_Type >	Helper class for the implementation of an external function with Enzyme in CoDiPack
►Ccodi::ExternalFunctionInternalData	Internal untyped data for an external function
Ccodi::ExternalFunction< T_Tape >	User-defined evaluation functions for the taping process
Ccodi::ExternalFunctionLowLevelEntryMapper< T_Tape, T_Real, T_Identifier >	Low level function entry implementation for external functions
►Ccodi::ExternalFunctionTapeInterface< T_Real, T_Gradient, T_Identifier >	Add user defined functions to the tape evaluation
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::ExternalFunctionTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier >
Ccodi::ExternalFunctionTapeInterface< T_Real, T_Real, TagData< T_Tag > >
Ccodi::ExternalFunctionUserData	Ease of access structure for user-provided data on the tape for external functions. See ExternalFunctionTapeInterface
Ccodi::ExtFunc_matrixMatrixMultiplication< eigenStore, Type >	Low level function generation for matrixMatrixMultiplication
►Cstd::false_type
Ccodi::AtomicTraits::IsAtomic< Type >	Indicate whether a type is atomic
Ccodi::ExpressionTraits::IsConstantExpression< Expr >	If the expression inherits from ConstantExpression. Is either std::false_type or std::true_type
Ccodi::ExpressionTraits::IsExpression< Expr, typename >	If the expression inherits from ExpressionInterface. Is either std::false_type or std::true_type
Ccodi::ExpressionTraits::IsLhsExpression< Expr, typename >	If the expression inherits from LhsExpressionInterface. Is either std::false_type or std::true_type
Ccodi::ExpressionTraits::IsStaticContextActiveType< Expr >	If the expression inherits from StaticContextActiveType. Is either std::false_type or std::true_type
Ccodi::GradientTraits::IsDirection< Gradient, typename >	If the expression inherits from Direction. Is either std::false_type or std::true_type
Ccodi::TapeTraits::IsForwardTape< Tape, typename >	If the tape inherits from ForwardEvaluation
Ccodi::TapeTraits::IsJacobianTape< Tape, typename >	If the tape inherits from JacobianBaseTape
Ccodi::TapeTraits::IsPrimalValueTape< Tape, typename >	If the tape inherits from PrimalValueBaseTape
Ccodi::TapeTraits::IsReverseTape< Tape, typename >
Ccodi::FileIo	Helper structure for writing binary data
►CFirst
Ccodi::CODI_UNION< First >	Creates a union of interface definitions
►Ccodi::GradientAccessTapeInterface< T_Gradient, T_Identifier >	Allow for a direct access to the gradient information computed by the tape
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::ReverseTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier >
Ccodi::ReverseTapeInterface< T_Real, T_Real, TagData< T_Tag > >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
►Ccodi::ReverseTapeInterface< T_Real, T_Gradient, T_Identifier >	Minimum tape interface for a working reverse tape implementation
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
►Ccodi::GradientAccessTapeInterface< T_Gradient, T_Gradient >
Ccodi::ForwardEvaluation< T_Real, T_Gradient >	Implementation of a tape-free forward AD mode through the internal expression interfaces
Ccodi::GradientAccessTapeInterface< T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier >
Ccodi::GradientAccessTapeInterface< T_Real, TagData< T_Tag > >
►Ccodi::GradientAccessTapeInterface< T_Tag, T_Tag >
Ccodi::TagTapeForward< T_Real, T_Tag >	Tape for tagging variables and find errors in the AD workflow
►Ccodi::HessianInterface< T_T >	General interface for Hessian access in CoDiPack
Ccodi::Hessian< T_T, T_Store >	Default implementation of the Hessian interface
►Ccodi::HessianInterface< DummyValue >
Ccodi::DummyHessian	Dummy Hessian. Has size zero and no logic in any call
►Ccodi::IdentifierInformationTapeInterface< T_Real, T_Gradient, T_Identifier >	General information about the identifiers and checks if variables are active
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::IdentifierInformationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier >
Ccodi::IdentifierInformationTapeInterface< T_Real, T_Real, TagData< T_Tag > >
►Ccodi::IncrementOperators< T_Tape, T_Impl >	Implementation of increment operators for LhsExpressionInterface implementations
Ccodi::ActiveTypeBase< T_Tape, ActiveType< T_Tape > >
Ccodi::ActiveTypeBase< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > >
Ccodi::ActiveTypeBase< T_Tape, T_Impl >	Represents the base implementation concrete lvalue in the CoDiPack expression tree
►Ccodi::IncrementOperators< T_ActiveType::Tape, ActiveTypeWrapper< T_ActiveType > >
Ccodi::ActiveTypeWrapper< T_ActiveType >	Creates a pseudo active type from data references. Can be used to overlay existing data with active types
►Ccodi::IncrementOperators< T_ActiveType::Tape, ImmutableActiveType< T_ActiveType > >
Ccodi::ImmutableActiveType< T_ActiveType >	Creates a pseudo active type from a data value. Can be used to overlay existing data with immutable active types
Ccodi::IncrementOperators< T_Tape, ActiveType< T_Tape > >
►Ccodi::IncrementOperators< T_Tape, ActiveTypeStatelessTape< T_Tape > >
Ccodi::ActiveTypeStatelessTape< T_Tape >	Represents a concrete lvalue in the CoDiPack expression tree
Ccodi::IncrementOperators< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > >
►Ccodi::IncrementOperators< T_Type, ReferenceActiveType< T_Type > >
Ccodi::ReferenceActiveType< T_Type >	Holds a reference to an ActiveType for manual optimization of common arguments
Ccodi::TagTapeForward< T_Real, T_Tag >::TapeTypes::IndexManager	Required definition for event system
Ccodi::TagTapeReverse< T_Real, T_Tag >::TapeTypes::IndexManager	Required definition for event system
►Ccodi::IndexManagerInterface< T_Index >	Indices enable the mapping of primal values to their adjoint counterparts
Ccodi::ReuseIndexManagerBase< T_Index, ParallelReuseIndexManager< T_Index, T_ParallelToolbox > >
Ccodi::ReuseIndexManagerBase< T_Index, ReuseIndexManager< T_Index > >
Ccodi::LinearIndexManager< T_Index >	Identifiers are created in a linear fashion. Each assign creates a new index which is counted up
Ccodi::ReuseIndexManagerBase< T_Index, T_Impl >	Identifiers are reused. Freed identifiers are assigned to new variables. Variables keep their indices as long as they are active
Ccodi::InnerStatementEvaluatorStaticStore< Tape, Expr >
►Ccodi::InternalAdjointsInterface< T_Gradient, T_Identifier, T_Tape >	Abstracts the internal set of adjoint variables provided as part of the tape
Ccodi::LocalAdjoints< T_Gradient, T_Identifier, T_Tape >	Adjoint variables owned by a tape instance
Ccodi::ThreadSafeGlobalAdjoints< T_Gradient, T_Identifier, T_Tape, T_ParallelToolbox >	Provides global adjoint variables owned by a tape type. Thread-safe for use in parallel taping
►Ccodi::InternalStatementRecordingTapeInterface< T_Identifier >	Internal tape interface that is used by active types to trigger the storing of an expression
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::ReverseTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier >
Ccodi::ReverseTapeInterface< T_Real, T_Real, TagData< T_Tag > >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::ReverseTapeInterface< T_Real, T_Gradient, T_Identifier >	Minimum tape interface for a working reverse tape implementation
►Ccodi::InternalStatementRecordingTapeInterface< T_Gradient >
Ccodi::ForwardEvaluation< T_Real, T_Gradient >	Implementation of a tape-free forward AD mode through the internal expression interfaces
Ccodi::InternalStatementRecordingTapeInterface< T_ImplTapeTypes::Identifier >
►Ccodi::InternalStatementRecordingTapeInterface< T_Tag >
Ccodi::TagTapeForward< T_Real, T_Tag >	Tape for tagging variables and find errors in the AD workflow
Ccodi::InternalStatementRecordingTapeInterface< TagData< T_Tag > >
Ccodi::IoException	IoException for CoDiPack
Ccodi::RealTraits::IsTotalFinite< T_Type, typename >	Function for checking if all values of the type are finite
Ccodi::RealTraits::IsTotalFinite< T_Type, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > >	Function for checking if all values of the type are finite.
Ccodi::RealTraits::IsTotalZero< T_Type, typename >	Function for checking if the value of the type is completely zero
Ccodi::RealTraits::IsTotalZero< T_Type, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > >	Function for checking if the value of the type is completely zero.
Ccodi::JacobianConvertWrapper< T_Nested >	Wrapper for JacboianInterfaces that requires a passive value conversion
Ccodi::JacobianDelayAccessor< T_Issuer >
Ccodi::JacobianExpression< size >	Specialized for NumberOfActiveTypeArguments and NumberOfConstantTypeArguments
►Ccodi::JacobianInterface< T_T >	General interface for Jacobian access in CoDiPack
Ccodi::Jacobian< T_T, std::vector< T_T > >
Ccodi::Jacobian< Real, std::vector< Real > >
►Ccodi::Jacobian< T_T, T_Store >	Default implementation of the Jacobian interface
Ccodi::JacobianCountNonZerosRow< Real >
Ccodi::JacobianCountNonZerosRow< T_T, T_Store >	Adds counting of nonzero entries
►Ccodi::JacobianInterface< DummyValue >
Ccodi::DummyJacobian	Dummy Jacobian. Has size zero and no logic in any call
Ccodi::JacobianInterface< Real >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::JacobianStatementGenerator< T_size >
►Ccodi::LinearSystemInterface< T_InterfaceTypes >
►Ccodi::EigenLinearSystem< Number, Matrix, Vector >
CEigenSolver< Number >	[Function]
Ccodi::LinearSystemInterface< EigenLinearSystemTypes< Number, Matrix, Vector > >
►Ccodi::LinearSystemInterface< EigenLinearSystemTypes< T_Type, T_Matrix, T_Vector > >
►Ccodi::EigenLinearSystem< T_Type, T_Matrix, T_Vector >
Ccodi::SparseEigenLinearSystem< T_Type, T_Matrix, T_Vector >
Ccodi::LinearSystemInterfaceTypes
Ccodi::LinearSystemSolverHandler< T_LinearSystem, typename >
Ccodi::LinearSystemSpecializationDetection< T_LinearSystem >
Ccodi::Lock< T_Mutex >	RAII mutex locking
Ccodi::LockForRead< T_ReadWriteMutex >	RAII lock for read. ´
Ccodi::LockForWrite< T_ReadWriteMutex >	RAII lock for write
CLowLevelFunction	Indicator for generator
Ccodi::LowLevelFunctionCreationUtilities< T_ActiveArguments >	Helper structure for storing low level functions and their arguments on a tape
Ccodi::LowLevelFunctionEntry< T_Tape, T_Real, T_Identifier >	Low level function entry on the tape. See LowLevelFunctionTapeInterface for details
►Ccodi::LowLevelFunctionTapeInterface< T_Real, T_Gradient, T_Identifier >	Add functions with custom derivatives to the tape. Can, e.g, be used to optimize small recurring functions like matrix matrix multiplication
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::LowLevelFunctionTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier >
Ccodi::LowLevelFunctionTapeInterface< T_Real, T_Real, TagData< T_Tag > >
►Ccodi::ManualStatementPushTapeInterface< T_Real, T_Gradient, T_Identifier >	Add derivative information for custom operations to the tape
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::PreaccumulationEvaluationTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
►Ccodi::PreaccumulationEvaluationTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Perform tape evaluations but ensure that the state prior to evaluation equals the state after evaluation
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::ManualStatementPushTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier >
Ccodi::ManualStatementPushTapeInterface< T_Real, T_Real, TagData< T_Tag > >
Ccodi::MemberStore< T_Type, T_Parent, T_storeStatic >	Defines a member that can either be static or local to the struct
Ccodi::MemberStore< IndexManager, Impl, TapeTypes::IsStaticIndexHandler >
Ccodi::MemberStore< T_Type, T_Parent, true >	Defines a member that can either be static or local to the struct.
►Ccodi::MutexInterface	Abstracts a mutex
Ccodi::OpenMPMutex	Mutex implementation for OpenMP
►Ccodi::NodeInterface< T_Impl >	Node side interface for the traversal of expressions
Ccodi::ExpressionInterface< T_Tape::Real, ActiveType< T_Tape > >
Ccodi::ExpressionInterface< T_Tape::Real, T_Impl >
Ccodi::ExpressionInterface< T_Tape::Real, ActiveTypeStatelessTape< T_Tape > >
Ccodi::ExpressionInterface< T_ActiveType::Real, ActiveTypeWrapper< T_ActiveType > >
►Ccodi::ExpressionInterface< T_Real, BinaryExpression< T_Real, T_ArgA, T_ArgB, T_Operation > >
Ccodi::BinaryExpression< T_Real, T_ArgA, T_ArgB, T_Operation >	Represents an operator with two arguments in the expression tree
Ccodi::ExpressionInterface< T_Real, ConstantExpression< T_Real, ConstantDataConversion > >
Ccodi::ExpressionInterface< T_ActiveType::Real, ImmutableActiveType< T_ActiveType > >
Ccodi::ExpressionInterface< T_Tape::Real, ParallelActiveType< T_Tape, T_ParallelToolbox > >
Ccodi::ExpressionInterface< T_Type::Real, ReferenceActiveType< T_Type > >
►Ccodi::ExpressionInterface< T_Tape::Real, StaticContextActiveType< T_Tape > >
Ccodi::StaticContextActiveType< T_Tape >	Replacement type of LhsExpressionInterface types in ConstructStaticContext
►Ccodi::ExpressionInterface< T_Real, UnaryExpression< T_Real, T_Arg, T_Operation > >
Ccodi::UnaryExpression< T_Real, T_Arg, T_Operation >	Represents an operator with one argument in the expression tree
►Ccodi::ExpressionInterface< T_Real, T_Impl >	Base class for all CoDiPack expressions
Ccodi::LhsExpressionInterface< T_Tape::Real, T_Tape::Gradient, T_Tape, ActiveType< T_Tape > >
►Ccodi::LhsExpressionInterface< T_Tape::Real, T_Tape::Gradient, T_Tape, T_Impl >
Ccodi::ActiveTypeBase< T_Tape, T_Impl >	Represents the base implementation concrete lvalue in the CoDiPack expression tree
►Ccodi::LhsExpressionInterface< T_Tape::Real, T_Tape::Gradient, T_Tape, ActiveTypeStatelessTape< T_Tape > >
Ccodi::ActiveTypeStatelessTape< T_Tape >	Represents a concrete lvalue in the CoDiPack expression tree
►Ccodi::LhsExpressionInterface< T_ActiveType::Real, T_ActiveType::Gradient, T_ActiveType::Tape, ActiveTypeWrapper< T_ActiveType > >
Ccodi::ActiveTypeWrapper< T_ActiveType >	Creates a pseudo active type from data references. Can be used to overlay existing data with active types
►Ccodi::LhsExpressionInterface< T_ActiveType::Real, T_ActiveType::Gradient, T_ActiveType::Tape, ImmutableActiveType< T_ActiveType > >
Ccodi::ImmutableActiveType< T_ActiveType >	Creates a pseudo active type from a data value. Can be used to overlay existing data with immutable active types
Ccodi::LhsExpressionInterface< T_Tape::Real, T_Tape::Gradient, T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > >
►Ccodi::LhsExpressionInterface< T_Type::Real, T_Type::Gradient, T_Type::Tape, ReferenceActiveType< T_Type > >
Ccodi::ReferenceActiveType< T_Type >	Holds a reference to an ActiveType for manual optimization of common arguments
Ccodi::ConstantExpression< T_Real, T_ConversionOperator >	Represents constant values in the expression tree
►Ccodi::LhsExpressionInterface< T_Real, T_Gradient, T_Tape, T_Impl >	Base class for all CoDiPack lvalue expression
Ccodi::ActiveTypeBase< T_Tape, ActiveType< T_Tape > >
Ccodi::ActiveTypeBase< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > >
Ccodi::NodeInterface< ActiveType< T_Tape > >
Ccodi::NodeInterface< ActiveTypeStatelessTape< T_Tape > >
Ccodi::NodeInterface< ActiveTypeWrapper< T_ActiveType > >
Ccodi::NodeInterface< BinaryExpression< T_Real, T_ArgA, T_ArgB, T_Operation > >
Ccodi::NodeInterface< ConstantExpression< T_Real, ConstantDataConversion > >
Ccodi::NodeInterface< ImmutableActiveType< T_ActiveType > >
Ccodi::NodeInterface< ParallelActiveType< T_Tape, T_ParallelToolbox > >
Ccodi::NodeInterface< ReferenceActiveType< T_Type > >
Ccodi::NodeInterface< StaticContextActiveType< T_Tape > >
Ccodi::NodeInterface< UnaryExpression< T_Real, T_Arg, T_Operation > >
Ccodi::ExpressionTraits::NumberOfActiveTypeArguments< JacobianExpression< size > >	Specialization for manual statement pushes of the used expression type
Ccodi::ExpressionTraits::NumberOfConstantTypeArguments< JacobianExpression< size > >	Specialization for manual statement pushes of the used expression type
Ccodi::ParallelToolbox< T_ThreadInformation, T_Atomic, T_Mutex, T_StaticThreadLocalPointer, T_Synchronization >	Collects parallel programming facilties required to make CoDiPack applicable in a shared memory parallel environment
Ccodi::PassiveArgumentStoreTraits< T_T, T_S, typename >	Traits for storing passive arguments in byte streams
Ccodi::PointerStore< T_ChunkData >	Inserts data pointers at the back of all arguments in the nested call hierarchy
Ccodi::PointerStore< Chunk1< T_Data1 > >	Pointer store for Chunk1 data
Ccodi::PointerStore< Chunk2< T_Data1, T_Data2 > >	Pointer store for Chunk2 data
Ccodi::PointerStore< Chunk3< T_Data1, T_Data2, T_Data3 > >	Pointer store for Chunk3 data
Ccodi::PointerStore< Chunk4< T_Data1, T_Data2, T_Data3, T_Data4 > >	Pointer store for Chunk4 data
►Ccodi::PositionalEvaluationTapeInterface< T_Position >	Reverse AD evaluation for parts of a recorded tape
Ccodi::ForwardEvaluationTapeInterface< CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::ForwardEvaluationTapeInterface< CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::ForwardEvaluationTapeInterface< EmptyPosition >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::PreaccumulationEvaluationTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::PrimalEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::PrimalEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::PrimalEvaluationTapeInterface< T_Real, TagData< T_Tag >, EmptyPosition >
►Ccodi::ForwardEvaluationTapeInterface< T_Position >	Forward AD evaluation of a recorded tape
Ccodi::CustomAdjointVectorEvaluationTapeInterface< CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::CustomAdjointVectorEvaluationTapeInterface< CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::CustomAdjointVectorEvaluationTapeInterface< EmptyPosition >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::PreaccumulationEvaluationTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
►Ccodi::CustomAdjointVectorEvaluationTapeInterface< T_Position >	Allows user defined vectors for the forward and adjoint evaluation
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::PreaccumulationEvaluationTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Perform tape evaluations but ensure that the state prior to evaluation equals the state after evaluation
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::PreaccumulationEvaluationTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Perform tape evaluations but ensure that the state prior to evaluation equals the state after evaluation
►Ccodi::PrimalEvaluationTapeInterface< T_Real, T_Identifier, T_Position >	Perform a primal reevaluation of the tape
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
Ccodi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Full tape interface that supports all features of CoDiPack
Ccodi::PositionalEvaluationTapeInterface< CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::PositionalEvaluationTapeInterface< CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::PositionalEvaluationTapeInterface< EmptyPosition >
Ccodi::PreaccumulationHelper< T_Type, typename >	Stores the Jacobian matrix for a code section
►Ccodi::PrimalTapeStatementFunctions	Data required for all possible handle calls
Ccodi::InnerPrimalTapeStatementData	Additional data required by an InnerStatementEvaluator
Ccodi::ReadWriteMutex< T_ThreadInformation, T_AtomicInt >	Mutex construct that distinguishes between lock for read and lock for write
Ccodi::AtomicTraits::RemoveAtomicImpl< T_NotAtomic, typename >	Convert an atomic type into the underlying type. Implementation
Ccodi::AtomicTraits::RemoveAtomicImpl< Atomic, EnableIfAtomic< Atomic > >	Specialization for atomic types
Ccodi::StatementEvaluatorInnerTapeInterface< T_Real >	Tape side interface for StatementEvaluatorInterface
►Ccodi::StatementEvaluatorInnerTapeInterface< T_TapeTypes::Real >
Ccodi::PrimalValueBaseTape< T_TapeTypes, PrimalValueLinearTape< T_TapeTypes > >
Ccodi::PrimalValueBaseTape< T_TapeTypes, PrimalValueReuseTape< T_TapeTypes > >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >	Base class for all standard Primal value tape implementations
►Ccodi::StatementEvaluatorInterface< T_Real >	Creation of handles for the evaluation of expressions in a context where the expression type is not available
Ccodi::DirectStatementEvaluator< T_Real >	Full evaluation of the expression in the function handle. Storing in static context
Ccodi::InnerStatementEvaluator< T_Real >	Expression evaluation in the inner function. Data loading in the compilation context of the tape. Storing in static context
Ccodi::ReverseStatementEvaluator< T_Real >	Only stores the function handle for the reverse evaluation
Ccodi::StatementEvaluatorTapeInterface< T_Real >	Tape side interface for StatementEvaluatorInterface
►Ccodi::StatementEvaluatorTapeInterface< T_TapeTypes::Real >
Ccodi::PrimalValueBaseTape< T_TapeTypes, PrimalValueLinearTape< T_TapeTypes > >
Ccodi::PrimalValueBaseTape< T_TapeTypes, PrimalValueReuseTape< T_TapeTypes > >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >	Base class for all standard Primal value tape implementations
Ccodi::StatementPushHelperBase< T_Type, T_Impl >	Base class for manual statement pushes on the tape
►Ccodi::StatementPushHelperBase< T_Type, StatementPushHelper< T_Type > >
Ccodi::StatementPushHelper< T_Type, typename >	Add statements to the tape where the Jacobians are computed manually
Ccodi::StaticDummy< Dummy >	Static dummy objects for e.g. default reference arguments
Ccodi::StaticThreadLocalPointerInterface< T_Type, T_Owner, T_Impl >	Abstracts a static thread-local pointer
►Ccodi::StaticThreadLocalPointerInterface< T_Type, T_Owner, OpenMPStaticThreadLocalPointer< T_Type, T_Owner > >
Ccodi::OpenMPStaticThreadLocalPointer< T_Type, T_Owner >	Static thread-local pointers for OpenMP
►Ccodi::SynchronizationInterface	Provides basic synchronization facilities
Ccodi::DefaultSynchronization	Default implementation of SynchronizationInterface for serial applications
Ccodi::OpenMPSynchronization	OpenMP synchronization facilities
►CT_Base
Ccodi::TerminatingPointerStore< T_Base >
Ccodi::TagData< T_Tag >	Data for a tag
Ccodi::TagData< Tag >
Ccodi::TagTapeBase< T_Real, T_Tag, T_Gradient, T_Impl >	Base implementation for tagging tapes
►Ccodi::TagTapeBase< T_Real, T_Tag, T_Real, TagTapeReverse< T_Real, T_Tag > >
Ccodi::TagTapeReverse< T_Real, T_Tag >	Tape for tagging variables and find errors in the AD workflow
►Ccodi::TagTapeBase< T_Real, T_Tag, TagData< T_Tag >, TagTapeForward< T_Real, T_Tag > >
Ccodi::TagTapeForward< T_Real, T_Tag >	Tape for tagging variables and find errors in the AD workflow
►Ccodi::TapeHelperBase< T_Type, T_Impl >	A helper class that allows for a simpler access and management of a CoDiPack tape
►Ccodi::TapeHelperNoImpl< Type >
Ccodi::TapeHelper< Type, typename >	See TapeHelperBase
►Ccodi::TapeHelperBase< T_Type, TapeHelperJacobi< T_Type > >
Ccodi::TapeHelperJacobi< T_Type >
►Ccodi::TapeHelperBase< T_Type, TapeHelperNoImpl< T_Type > >
Ccodi::TapeHelperNoImpl< T_Type >
►Ccodi::TapeHelperBase< T_Type, TapeHelperPrimal< T_Type > >
Ccodi::TapeHelperPrimal< T_Type >
Ccodi::TapeHelperBase< Type, TapeHelperNoImpl< Type > >
Ccodi::RealTraits::TapeRegistration< T_Type, typename >	Tape registration methods for aggregated types that contain CoDiPack active types
Ccodi::TagTapeForward< T_Real, T_Tag >::TapeTypes	Required definition for event system
Ccodi::TagTapeReverse< T_Real, T_Tag >::TapeTypes	Required definition for event system
►Ccodi::TapeTypesInterface	Interface for the definition of tape types
Ccodi::JacobianTapeTypes< T_Real, T_Gradient, T_IndexManager, T_Data, T_Adjoints >	Type definitions for the Jacobian tapes
Ccodi::PrimalValueTapeTypes< T_Real, T_Gradient, T_IndexManager, T_StatementEvaluator, T_Data >	Type definitions for the primal value tapes
Ccodi::TapeValues	Tape information that can be printed in a pretty print format or a table format
Ccodi::TemporaryMemory	Allocator for temporary used memory
►Ccodi::ThreadInformationInterface	Provides information on threads
Ccodi::DefaultThreadInformation	Default implementation of ThreadInformationInterface for serial applications
Ccodi::OpenMPThreadInformation	Thread information for OpenMP
Ccodi::GradientTraits::TraitsImplementation< T_Gradient, typename >	Common traits for all types used as gradients
Ccodi::RealTraits::TraitsImplementation< T_Type, typename >	Common traits for all types used as real values
Ccodi::ComputationTraits::TransposeImpl< T_Jacobian, typename >	Perform or if entries are complex. No default implementation available
►Ccodi::TraversalLogic< T_Impl >	Traversal of CoDiPack expressions
►Ccodi::ForEachLeafLogic< PushDelayedJacobianLogic >
Ccodi::JacobianBaseTape< T_TapeTypes, T_Impl >::PushDelayedJacobianLogic	Pushes all delayed Jacobians
►Ccodi::ForEachLeafLogic< CountActiveArguments >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::CountActiveArguments	Count all arguments that have non-zero index
►Ccodi::ForEachLeafLogic< PushIdentfierPassiveAndConstant >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::PushIdentfierPassiveAndConstant	Push all data for each argument
►Ccodi::ForEachLeafLogic< ValidateTags >
Ccodi::TagTapeBase< T_Real, T_Tag, T_Gradient, T_Impl >::ValidateTags	Looks at the tags for the expression
Ccodi::JacobianComputationLogic< LocalReverseLogic >
►Ccodi::JacobianComputationLogic< PushJacobianLogic >
Ccodi::JacobianBaseTape< T_TapeTypes, T_Impl >::PushJacobianLogic	Pushes Jacobians and indices to the tape
►Ccodi::JacobianComputationLogic< IncrementForwardLogic >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::IncrementForwardLogic	Perform the adjoint update based on the configuration in codi::Config::VariableAdjointInterfaceInPrimalTapes
►Ccodi::JacobianComputationLogic< IncrementReversalLogic >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::IncrementReversalLogic	Perform the adjoint update based on the configuration in codi::Config::VariableAdjointInterfaceInPrimalTapes
►Ccodi::JacobianComputationLogic< JacobianExtractionLogic >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::JacobianExtractionLogic	Computes Jacobian entries for the event system
Ccodi::ForEachLeafLogic< T_Impl >	Implement logic for leaf nodes only
Ccodi::JacobianComputationLogic< T_Impl >
Ccodi::TraversalLogic< CountActiveArguments >
Ccodi::TraversalLogic< IncrementForwardLogic >
Ccodi::TraversalLogic< IncrementReversalLogic >
Ccodi::TraversalLogic< JacobianExtractionLogic >
Ccodi::TraversalLogic< LocalReverseLogic >
Ccodi::TraversalLogic< PushDelayedJacobianLogic >
Ccodi::TraversalLogic< PushIdentfierPassiveAndConstant >
Ccodi::TraversalLogic< PushJacobianLogic >
Ccodi::TraversalLogic< ValidateTags >
►Cstd::true_type
Ccodi::AtomicTraits::IsAtomic< OpenMPAtomic< T_Type > >	Declare OpenMPAtomic to be atomic in terms of AtomicTraits
►Ccodi::UnaryOperation< T_Real >	Interface for implementing the logic for a UnaryExpression
Ccodi::OperationAbs< T_Real >	UnaryOperation implementation for abs
Ccodi::OperationAcos< T_Real >	UnaryOperation implementation for acos
Ccodi::OperationAsin< T_Real >	UnaryOperation implementation for asin
Ccodi::OperationAtan< T_Real >	UnaryOperation implementation for atan
Ccodi::OperationAtanh< T_Real >	UnaryOperation implementation for atanh
Ccodi::OperationCbrt< T_Real >	UnaryOperation implementation for cbrt
Ccodi::OperationCos< T_Real >	UnaryOperation implementation for cos
Ccodi::OperationCosh< T_Real >	UnaryOperation implementation for cosh
Ccodi::OperationErf< T_Real >	UnaryOperation implementation for erf
Ccodi::OperationErfc< T_Real >	UnaryOperation implementation for erfc
Ccodi::OperationExp< T_Real >	UnaryOperation implementation for exp
Ccodi::OperationLog< T_Real >	UnaryOperation implementation for log
Ccodi::OperationLog10< T_Real >	UnaryOperation implementation for log10
Ccodi::OperationSin< T_Real >	UnaryOperation implementation for sin
Ccodi::OperationSinh< T_Real >	UnaryOperation implementation for sinh
Ccodi::OperationSqrt< T_Real >	UnaryOperation implementation for sqrt
Ccodi::OperationTan< T_Real >	UnaryOperation implementation for tan
Ccodi::OperationTanh< T_Real >	UnaryOperation implementation for tanh
Ccodi::OperationTgamma< T_Real >	UnaryOperation implementation for tgamma
Ccodi::OperationUnaryMinus< T_Real >	UnaryOperation implementation for operator -
Ccodi::ComputationTraits::UpdateImpl< T_Lhs, T_Rhs, typename >	Perform the operation lhs += rhs. Default logic uses operator +=
Ccodi::ExpressionTraits::ValidateResultImpl< ResultA, ResultB, typename >
Ccodi::ValidationIndicator< Real, Tag >	Helper class for statement validation
►Ccodi::VectorAccessInterface< T_Real, T_Identifier >	Unified access to the adjoint vector and primal vector in a tape evaluation
Ccodi::AdjointVectorAccess< Real, Identifier, Gradient >
►Ccodi::AdjointVectorAccess< T_Real, T_Identifier, T_Gradient >	Implementation of VectorAccessInterface for adjoint vectors
Ccodi::PrimalAdjointVectorAccess< T_Real, T_Identifier, T_Gradient >	Implementation of VectorAccessInterface for adjoint and primal vectors
Ccodi::AggregatedTypeVectorAccessWrapperBase< T_Real, T_Identifier, T_InnerInterface >	Implements all methods from AggregatedTypeVectorAccessWrapper, that can be implemented with combinations of other methods
►Ccodi::VectorAccessInterface< int, int >
Ccodi::AggregatedTypeVectorAccessWrapper< T_Type, typename >	Generalized wrapper of the VectorAccessInterface for aggregated data types, e.g. std::complex<codi::RealReverse>
Ccodi::VectorAccessInterface< Real, Identifier >
Ccodi::Warning
Ccodi::JacobianBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluateForward_EvalStatements< TT >	Wrapper helper for improved compiler optimizations
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluateForward_EvalStatements	Additional wrapper that triggers compiler optimizations
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluatePrimal_EvalStatements	Wrapper helper for improved compiler optimizations
Ccodi::JacobianBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluateReverse_EvalStatements< TT >	Wrapper helper for improved compiler optimizations
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluateReverse_EvalStatements	Additional wrapper that triggers compiler optimizations