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::Tape, 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 all 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::CommonReaderWriterMethods	Used to implement methods common to both the tape readers and the tape writers
►Ccodi::CommonBaseTapeReader< T_Type >	Used to restore the IO from the "filename"IO.dat or "filename"IO.txt files. Also provides the get methods from the codi::tapeReaderInterface
►Ccodi::JacobianBaseTapeReader< T_Type >	Used to register a statement for a Jacobian tape
Ccodi::JacobianBinaryTapeReader< T_Type >	Reads and restores a binary file for a Jacobian tape
Ccodi::JacobianTextTapeReader< T_Type >	Reads and restores a text file for a Jacobian tape
Ccodi::PrimalBinaryTapeReader< T_Type >	Reads and restores a binary file for a Primal tape
Ccodi::PrimalTextTapeReader< T_Type >	Reads and restores a text file for a primal value tape
►Ccodi::CommonBaseTapeWriter< T_Type >	This class is a common base for all the writers and produces a IO file that contains the input and output variables of the current tape. The IO file is written in a binary or text format
►Ccodi::CommonTextTapeWriter< T_Type >	This base class is used to modify the math representation of a statement
Ccodi::JacobianGraphTapeWriter< T_Type >	Generates a graphical .dot file for a Jacobian tape
Ccodi::MathRepWriter< T_Type >	Generates a file with the math representation for each of the statements
Ccodi::PrimalGraphTapeWriter< T_Type >	Generates a graphical .dot file for a primal value tape. The writer adds the math representation of statements into the node labels
Ccodi::JacobianBinaryTapeWriter< T_Type >	Writes a Jacobian tape in a binary format
Ccodi::JacobianTextTapeWriter< T_Type >	Writes a Jacobian tape in a text format
►Ccodi::PrimalBaseTapeWriter< T_Type >	This base class is used to implement the automatic generation of the .hpp file that restores the evaluation handles in the reading process
Ccodi::PrimalBinaryTapeWriter< T_Type >	Writes a primal value tape in a binary format
Ccodi::PrimalTextTapeWriter< T_Type >	Writes a primal value tape in a text format
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::InternalAdjointVectorTraits::IsGlobal< InternalAdjointType >	Whether the adjoint vector is global, that is, shared among different tapes
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::TapeTraits::SupportsEditing< 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::AdjointVectorTraits::GradientImplementation< AdjointVector >	Trait implementation to deduce the entry type from an adjoint vector type
►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::Tape, 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::MappedAdjoints< T_Identifier, T_Gradient >	Implementation of adjoints via a map
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_ReverseAtomic, 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, and for clearing adjoints
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::ReadWriteTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position >	Write a tape to a file using a writer from the codi::TapeWriterInterface. When reading a stored tape, create a primal or a Jacobian statement on 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::ReadWriteTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position >
Ccodi::ReadWriteTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position >
Ccodi::ReadWriteTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition >
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::ReverseAtomicInterface< T_Type, T_Impl >	Provides a data type on which += update operations are performed atomically
Ccodi::OpenMPReverseAtomicImpl< T_Type, T_Sfinae >	Reverse atomic implementation for OpenMP
Ccodi::ReverseAtomicInterface< T_Type, OpenMPReverseAtomicImpl< T_Type, void > >
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::TapeReaderInterface< T_Type >	The interface is used by all the tape readers. The tape readers are used to restore a tape from either a text file or a binary file that was created by the codi::TapeWriterInterface. The readers produce an identical tape in a new context, which can be evaluated and new statements can be added
Ccodi::CommonBaseTapeReader< T_Type >	Used to restore the IO from the "filename"IO.dat or "filename"IO.txt files. Also provides the get methods from the codi::tapeReaderInterface
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::TapeWriterInterface< T_Type >	The interface used by all the tape writers. The tape writers are used to generate text, binary, graphical or the math statement files from the current tape. The text and binary files can be used to restore a tape using the codi::TapeReaderInterface in a new context. The writers are supported for both Jacobian and primal value tapes
Ccodi::CommonBaseTapeWriter< T_Type >	This class is a common base for all the writers and produces a IO file that contains the input and output variables of the current tape. The IO file is written in a binary or text 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< MathStatementGenLogic< Identifier > >
Ccodi::MathStatementGenLogic< Identifier >	Creates a math representation from a given rhs in the form of a string
►Ccodi::ForEachLeafLogic< CountActiveArguments >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::CountActiveArguments	Count all arguments that have non-zero index
►Ccodi::ForEachLeafLogic< PushIdentifierPassiveAndConstant >
Ccodi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::PushIdentifierPassiveAndConstant	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< MathStatementGenLogic< Identifier > >
Ccodi::TraversalLogic< PushDelayedJacobianLogic >
Ccodi::TraversalLogic< PushIdentifierPassiveAndConstant >
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::AtomicTraits::IsAtomic< OpenMPReverseAtomic< 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::OperationAcosh< T_Real >	UnaryOperation implementation for acosh
Ccodi::OperationAsin< T_Real >	UnaryOperation implementation for asin
Ccodi::OperationAsinh< T_Real >	UnaryOperation implementation for asinh
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::OperationLog1p< T_Real >	UnaryOperation implementation for log1p
Ccodi::OperationLog2< T_Real >	UnaryOperation implementation for log2
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_AdjointVector >	Implementation of VectorAccessInterface for adjoint vectors
Ccodi::PrimalAdjointVectorAccess< T_Real, T_Identifier, T_AdjointVector >	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
Ccodi::WriteInfo	This class is used during the writing process of a primal value tape. The WriteInfo is returned by codi::PrimalValueBaseTape::statementGetWriteInformation method