Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►Ncodi	CoDiPack - Code Differentiation Package.
►NAdjointVectorTraits	General traits of adjoint vectors
CGradientImplementation	Trait implementation to deduce the entry type from an adjoint vector type
►NAtomicTraits	Traits for atomic types
CIsAtomic	Indicate whether a type is atomic
CIsAtomic< OpenMPAtomic< T_Type > >	Declare OpenMPAtomic to be atomic in terms of AtomicTraits
CIsAtomic< OpenMPReverseAtomic< T_Type > >	Declare OpenMPAtomic to be atomic in terms of AtomicTraits
CRemoveAtomicImpl	Convert an atomic type into the underlying type. Implementation
CRemoveAtomicImpl< Atomic, EnableIfAtomic< Atomic > >	Specialization for atomic types
►NComputationTraits
CAdjointConversionImpl	Perform the conversion of Outer(Inner) in the adjoint context. Default implementation for Outer == Inner
CTransposeImpl	Perform or if entries are complex. No default implementation available
CUpdateImpl	Perform the operation lhs += rhs. Default logic uses operator +=
►NExpressionTraits	Traits for everything that can be an expression e.g. codi::RealReverse, a + b, etc.
CIsConstantExpression	If the expression inherits from ConstantExpression. Is either std::false_type or std::true_type
CIsExpression	If the expression inherits from ExpressionInterface. Is either std::false_type or std::true_type
CIsLhsExpression	If the expression inherits from LhsExpressionInterface. Is either std::false_type or std::true_type
CIsStaticContextActiveType	If the expression inherits from StaticContextActiveType. Is either std::false_type or std::true_type
CNumberOfActiveTypeArguments	Counts the number of nodes that inherit from LhsExpressionInterface in the expression
CNumberOfActiveTypeArguments< JacobianExpression< size > >	Specialization for manual statement pushes of the used expression type
CNumberOfConstantTypeArguments	Counts the number of types that inherit from ConstantExpression in the expression
CNumberOfConstantTypeArguments< JacobianExpression< size > >	Specialization for manual statement pushes of the used expression type
CNumberOfOperations	Counts the number of nodes in the expression
CValidateResultImpl
►NGradientTraits
CIsDirection	If the expression inherits from Direction. Is either std::false_type or std::true_type
CTraitsImplementation	Common traits for all types used as gradients
►NInternalAdjointVectorTraits	Traits for the internal adjoint variables maintained by the tape
CIsGlobal	Whether the adjoint vector is global, that is, shared among different tapes
►NRealTraits	Traits for values that can be used as real values e.g. double, float, codi::RealReverse etc.
CDataExtraction	Data handling methods for aggregated types that contain CoDiPack active types
CIsTotalFinite	Function for checking if all values of the type are finite
CIsTotalFinite< T_Type, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > >	Function for checking if all values of the type are finite.
CIsTotalZero	Function for checking if the value of the type is completely zero
CIsTotalZero< T_Type, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > >	Function for checking if the value of the type is completely zero.
CTapeRegistration	Tape registration methods for aggregated types that contain CoDiPack active types
CTraitsImplementation	Common traits for all types used as real values
►NTapeTraits
CIsForwardTape	If the tape inherits from ForwardEvaluation
CIsJacobianTape	If the tape inherits from JacobianBaseTape
CIsPrimalValueTape	If the tape inherits from PrimalValueBaseTape
CIsReverseTape
CSupportsEditing
CActiveArgumentPointerStore	Declares all variables that may be needed to store/restore an active argument which has a pointer type
CActiveArgumentStoreInterface	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
CActiveArgumentStoreTraits	Traits for storing active arguments in byte streams
CActiveArgumentValueStore	Declares all variables that may be needed to store/restore an active argument which has a value type
CActiveType	Represents a concrete lvalue in the CoDiPack expression tree
CActiveTypeBase	Represents the base implementation concrete lvalue in the CoDiPack expression tree
CActiveTypeStatelessTape	Represents a concrete lvalue in the CoDiPack expression tree
CActiveTypeWrapper	Creates a pseudo active type from data references. Can be used to overlay existing data with active types
CAdjointVectorAccess	Implementation of VectorAccessInterface for adjoint vectors
CAggregatedTypeVectorAccessWrapper	Generalized wrapper of the VectorAccessInterface for aggregated data types, e.g. std::complex<codi::RealReverse>
CAggregatedTypeVectorAccessWrapperBase	Implements all methods from AggregatedTypeVectorAccessWrapper, that can be implemented with combinations of other methods
CAggregatedTypeVectorAccessWrapperFactory	Factory for the creation of AggregatedTypeVectorAccessWrapper instances
CAlgorithms	Basic algorithms for tape evaluation in CoDiPack
CArrayPosition	Position with one index for e.g. array access
CAssignmentOperators	Implementation of assignment operators for LhsExpressionInterface implementations
CAtomicInterface	Provides a data type on which all operations are performed atomically
CBinaryExpression	Represents an operator with two arguments in the expression tree
CBinaryOperation	Interface for implementing the logic for a BinaryExpression
CBlockData	Data is stored in one contiguous block in this DataInterface implementation
CByteDataView
CChunk1
CChunk2
CChunk3
CChunk4
CChunkBase	A chunk stores a contiguous block of data in CoDiPack
CChunkedData	Data is stored chunk-wise in this DataInterface implementation. If a chunk runs out of space, a new chunk is allocated
CChunkPosition	Position with two indices for e.g. chunked data access
CCODI_UNION< First >	Creates a union of interface definitions
CCoDiMpiTypes	MPI datatype implementation for CoDipack types in the type wrapper of MeDiPack
CCommonBaseTapeReader	Used to restore the IO from the "filename"IO.dat or "filename"IO.txt files. Also provides the get methods from the codi::tapeReaderInterface
CCommonBaseTapeWriter	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
CCommonReaderWriterMethods	Used to implement methods common to both the tape readers and the tape writers
CCommonTapeImplementation	Implementation of all common tape functionality
CCommonTapeTypes	Declares all types used in the CommonTapeImplementation
CCommonTextTapeWriter	This base class is used to modify the math representation of a statement
CCompileTimeLoop	Compile time loop evaluation
CCompileTimeLoop< 0 >	Termination of loop evaluation
CCompileTimeTraversalLogic	Traversal of CoDiPack expressions during compile time
CConstantDataConversion
CConstantExpression	Represents constant values in the expression tree
CConstructStaticContextLogic	Helper class for the construction of an expression in a different context
CConstructVectorImpl
CConstructVectorImpl< std::array< T_T, T_n > >
CCustomAdjointVectorEvaluationTapeInterface	Allows user defined vectors for the forward and adjoint evaluation, and for clearing adjoints
CCustomAdjointVectorHelper	Allows for an arbitrary adjoint evaluation of a recorded tape
CCustomAdjointVectorInterface	General interface for an arbitrary adjoint evaluation
CDataInterface	Data stream interface for tape data. Encapsulates data that is written e.g. for each statement or argument
CDataManagementTapeInterface	Provides file IO, information about internal tape vectors and allows to clear tape data
CDefaultSynchronization	Default implementation of SynchronizationInterface for serial applications
CDefaultThreadInformation	Default implementation of ThreadInformationInterface for serial applications
CDerivativeAccess	A helper class for the access of the various derivatives in higher order AD types
CDirection	Fixed size vector mode implementation
CDirectStatementEvaluator	Full evaluation of the expression in the function handle. Storing in static context
CDirectStatementEvaluatorStaticStore
CDummyHessian	Dummy Hessian. Has size zero and no logic in any call
CDummyJacobian	Dummy Jacobian. Has size zero and no logic in any call
CDummyValue	Dummy value that can be assigned
CDummyVector	Dummy vector that provides a dummy element access and size function
CDuplicateJacobianRemover	Combines entries of Jacobians with the same identifier
CEditingTapeInterface	Edit tapes after they have been recorded
CEigenLinearSystem
CEigenLinearSystemTypes	Eigen definition for the LinearSystemInterfaceTypes
CEmptyData	No data is stored in this DataInterface implementation. It is used to terminate the recursive nature of the DataInterface design
CEmptyPosition	Empty Position with no nested data
CEnumBitset	A bitset with enum items as flags
CEnzymeExternalFunctionHelper	Helper class for the implementation of an external function with Enzyme in CoDiPack
CEvaluationHandle	See EvaluationHandleBase
CEvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > >	See EvaluationHandleForward
CEvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfJacobianTape< typename T_Type::Tape > >	See EvaluationHandleReverseJacobianTapes
CEvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfPrimalValueTape< typename T_Type::Tape > >	See EvaluationHandleReversePrimalValueTapes
CEvaluationHandleBase	Basic interface and data storage for all EvaluationHandle implementations
CEvaluationHandleForward
CEvaluationHandleReverseBase	Implementation for reverse mode CoDiPack types of EvaluationHandleBase
CEvaluationHandleReverseJacobianTapes	Implementation for Jacobian reverse mode CoDiPack types of EvaluationHandleBase
CEvaluationHandleReversePrimalValueTapes	Implementation of EvaluationHandleBase for primal value reverse mode CoDiPack types
CEvaluationHelper	Evaluate the primal, Jacobian and Hessian of function objects
CEventSystem	Full EventSystem implementation for reverse tapes
CEventSystem< ForwardEvaluation< Real, Gradient > >	Specialization for ForwardEvaluation
CEventSystemBase	Base class for the CoDiPack event system
CExpressionInterface	Base class for all CoDiPack expressions
CExternalFunction	User-defined evaluation functions for the taping process
CExternalFunctionHelper	Helper class for the implementation of an external function in CoDiPack
CExternalFunctionInternalData	Internal untyped data for an external function
CExternalFunctionLowLevelEntryMapper	Low level function entry implementation for external functions
CExternalFunctionTapeInterface	Add user defined functions to the tape evaluation
CExternalFunctionUserData	Ease of access structure for user-provided data on the tape for external functions. See ExternalFunctionTapeInterface
CExtFunc_matrixMatrixMultiplication	Low level function generation for matrixMatrixMultiplication
CFileIo	Helper structure for writing binary data
CForEachLeafLogic	Implement logic for leaf nodes only
CForwardEvaluation	Implementation of a tape-free forward AD mode through the internal expression interfaces
CForwardEvaluationTapeInterface	Forward AD evaluation of a recorded tape
CFullTapeInterface	Full tape interface that supports all features of CoDiPack
CGradientAccessTapeInterface	Allow for a direct access to the gradient information computed by the tape
CHessian	Default implementation of the Hessian interface
CHessianInterface	General interface for Hessian access in CoDiPack
CIdentifierInformationTapeInterface	General information about the identifiers and checks if variables are active
CImmutableActiveType	Creates a pseudo active type from a data value. Can be used to overlay existing data with immutable active types
CIncrementOperators	Implementation of increment operators for LhsExpressionInterface implementations
CIndexManagerInterface	Indices enable the mapping of primal values to their adjoint counterparts
CInnerPrimalTapeStatementData	Additional data required by an InnerStatementEvaluator
CInnerStatementEvaluator	Expression evaluation in the inner function. Data loading in the compilation context of the tape. Storing in static context
CInnerStatementEvaluatorStaticStore
CInternalAdjointsInterface	Abstracts the internal set of adjoint variables provided as part of the tape
CInternalStatementRecordingTapeInterface	Internal tape interface that is used by active types to trigger the storing of an expression
CIoException	IoException for CoDiPack
CJacobian	Default implementation of the Jacobian interface
►CJacobianBaseTape	Base class for all standard Jacobian tape implementations
CPushDelayedJacobianLogic	Pushes all delayed Jacobians
CPushJacobianLogic	Pushes Jacobians and indices to the tape
CWrap_internalEvaluateForward_EvalStatements	Wrapper helper for improved compiler optimizations
CWrap_internalEvaluateReverse_EvalStatements	Wrapper helper for improved compiler optimizations
CJacobianBaseTapeReader	Used to register a statement for a Jacobian tape
CJacobianBinaryTapeReader	Reads and restores a binary file for a Jacobian tape
CJacobianBinaryTapeWriter	Writes a Jacobian tape in a binary format
CJacobianComputationLogic
CJacobianConvertWrapper	Wrapper for JacboianInterfaces that requires a passive value conversion
CJacobianCountNonZerosRow	Adds counting of nonzero entries
CJacobianDelayAccessor
CJacobianExpression	Specialized for NumberOfActiveTypeArguments and NumberOfConstantTypeArguments
CJacobianGraphTapeWriter	Generates a graphical .dot file for a Jacobian tape
CJacobianInterface	General interface for Jacobian access in CoDiPack
CJacobianLinearTape	Final implementation for a Jacobian tape with a linear index management
CJacobianReuseTape	Final implementation for a Jacobian tape with a reuse index management
CJacobianTapeTypes	Type definitions for the Jacobian tapes
CJacobianTextTapeReader	Reads and restores a text file for a Jacobian tape
CJacobianTextTapeWriter	Writes a Jacobian tape in a text format
CLhsExpressionInterface	Base class for all CoDiPack lvalue expression
CLinearIndexManager	Identifiers are created in a linear fashion. Each assign creates a new index which is counted up
CLinearSystemInterface
CLinearSystemInterfaceTypes
CLinearSystemSolverHandler
CLinearSystemSpecializationDetection
CLocalAdjoints	Adjoint variables owned by a tape instance
CLock	RAII mutex locking
CLockForRead	RAII lock for read. ´
CLockForWrite	RAII lock for write
CLowLevelFunctionCreationUtilities	Helper structure for storing low level functions and their arguments on a tape
CLowLevelFunctionEntry	Low level function entry on the tape. See LowLevelFunctionTapeInterface for details
CLowLevelFunctionTapeInterface	Add functions with custom derivatives to the tape. Can, e.g, be used to optimize small recurring functions like matrix matrix multiplication
CManualStatementPushTapeInterface	Add derivative information for custom operations to the tape
CMappedAdjoints	Implementation of adjoints via a map
CMathRepWriter	Generates a file with the math representation for each of the statements
CMathStatementGenLogic	Creates a math representation from a given rhs in the form of a string
CMemberStore	Defines a member that can either be static or local to the struct
CMemberStore< T_Type, T_Parent, true >	Defines a member that can either be static or local to the struct.
CMultiUseIndexManager	Extends the ReuseIndexManager with a copy optimization
CMutexInterface	Abstracts a mutex
CNodeInterface	Node side interface for the traversal of expressions
COpenMPAtomicImpl	Atomic implementation for OpenMP
COpenMPMutex	Mutex implementation for OpenMP
COpenMPReverseAtomicImpl	Reverse atomic implementation for OpenMP
COpenMPStaticThreadLocalPointer	Static thread-local pointers for OpenMP
COpenMPSynchronization	OpenMP synchronization facilities
COpenMPThreadInformation	Thread information for OpenMP
COperationAbs	UnaryOperation implementation for abs
COperationAcos	UnaryOperation implementation for acos
COperationAcosh	UnaryOperation implementation for acosh
COperationAdd	BinaryOperation implementation for operator +
COperationAsin	UnaryOperation implementation for asin
COperationAsinh	UnaryOperation implementation for asinh
COperationAtan	UnaryOperation implementation for atan
COperationAtan2	BinaryOperation implementation for atan2
COperationAtanh	UnaryOperation implementation for atanh
COperationCbrt	UnaryOperation implementation for cbrt
COperationCopysign	BinaryOperation implementation for copysign
COperationCos	UnaryOperation implementation for cos
COperationCosh	UnaryOperation implementation for cosh
COperationDivide	BinaryOperation implementation for operator /
COperationErf	UnaryOperation implementation for erf
COperationErfc	UnaryOperation implementation for erfc
COperationExp	UnaryOperation implementation for exp
COperationFmod	BinaryOperation implementation for fmod
COperationFrexp	BinaryOperation implementation for frexp
COperationHypot	BinaryOperation implementation for hypot
COperationLdexp	BinaryOperation implementation for ldexp
COperationLog	UnaryOperation implementation for log
COperationLog10	UnaryOperation implementation for log10
COperationLog1p	UnaryOperation implementation for log1p
COperationLog2	UnaryOperation implementation for log2
COperationMax	BinaryOperation implementation for max
COperationMin	BinaryOperation implementation for min
COperationMultiply	BinaryOperation implementation for operator *
COperationPow	BinaryOperation implementation for pow
COperationRemainder
COperationSin	UnaryOperation implementation for sin
COperationSinh	UnaryOperation implementation for sinh
COperationSqrt	UnaryOperation implementation for sqrt
COperationSubstract	BinaryOperation implementation for operator -
COperationTan	UnaryOperation implementation for tan
COperationTanh	UnaryOperation implementation for tanh
COperationTgamma	UnaryOperation implementation for tgamma
COperationUnaryMinus	UnaryOperation implementation for operator -
CParallelActiveType	Represents a concrete lvalue in the CoDiPack expression tree
CParallelReuseIndexManager	Reuse index manager with a one-to-one relation between tapes and index manager
CParallelToolbox	Collects parallel programming facilties required to make CoDiPack applicable in a shared memory parallel environment
CPassiveArgumentStoreTraits	Traits for storing passive arguments in byte streams
CPointerStore	Inserts data pointers at the back of all arguments in the nested call hierarchy
CPointerStore< Chunk1< T_Data1 > >	Pointer store for Chunk1 data
CPointerStore< Chunk2< T_Data1, T_Data2 > >	Pointer store for Chunk2 data
CPointerStore< Chunk3< T_Data1, T_Data2, T_Data3 > >	Pointer store for Chunk3 data
CPointerStore< Chunk4< T_Data1, T_Data2, T_Data3, T_Data4 > >	Pointer store for Chunk4 data
CPositionalEvaluationTapeInterface	Reverse AD evaluation for parts of a recorded tape
CPreaccumulationEvaluationTapeInterface	Perform tape evaluations but ensure that the state prior to evaluation equals the state after evaluation
CPreaccumulationHelper	Stores the Jacobian matrix for a code section
CPrimalAdjointVectorAccess	Implementation of VectorAccessInterface for adjoint and primal vectors
CPrimalBaseTapeWriter	This base class is used to implement the automatic generation of the .hpp file that restores the evaluation handles in the reading process
CPrimalBinaryTapeReader	Reads and restores a binary file for a Primal tape
CPrimalBinaryTapeWriter	Writes a primal value tape in a binary format
CPrimalEvaluationTapeInterface	Perform a primal reevaluation of the tape
CPrimalGraphTapeWriter	Generates a graphical .dot file for a primal value tape. The writer adds the math representation of statements into the node labels
CPrimalTapeStatementFunctions	Data required for all possible handle calls
CPrimalTextTapeReader	Reads and restores a text file for a primal value tape
CPrimalTextTapeWriter	Writes a primal value tape in a text format
►CPrimalValueBaseTape	Base class for all standard Primal value tape implementations
CCountActiveArguments	Count all arguments that have non-zero index
CIncrementForwardLogic	Perform the adjoint update based on the configuration in codi::Config::VariableAdjointInterfaceInPrimalTapes
CIncrementReversalLogic	Perform the adjoint update based on the configuration in codi::Config::VariableAdjointInterfaceInPrimalTapes
CJacobianExtractionLogic	Computes Jacobian entries for the event system
CJacobianStatementGenerator
CPushIdentifierPassiveAndConstant	Push all data for each argument
CWrap_internalEvaluateForward_EvalStatements	Additional wrapper that triggers compiler optimizations
CWrap_internalEvaluatePrimal_EvalStatements	Wrapper helper for improved compiler optimizations
CWrap_internalEvaluateReverse_EvalStatements	Additional wrapper that triggers compiler optimizations
CPrimalValueLinearTape	Final implementation for a primal value tape with a linear index management
CPrimalValueReuseTape	Final implementation for a primal value tape with a reuse index management
CPrimalValueTapeTypes	Type definitions for the primal value tapes
CReadWriteMutex	Mutex construct that distinguishes between lock for read and lock for write
CReadWriteTapeInterface	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
CReferenceActiveType	Holds a reference to an ActiveType for manual optimization of common arguments
CReuseIndexManager	Reuse index manager with a many-to-one relation between tapes and index manager
CReuseIndexManagerBase	Identifiers are reused. Freed identifiers are assigned to new variables. Variables keep their indices as long as they are active
CReverseAtomicInterface	Provides a data type on which += update operations are performed atomically
CReverseStatementEvaluator	Only stores the function handle for the reverse evaluation
CReverseTapeInterface	Minimum tape interface for a working reverse tape implementation
CSparseEigenLinearSystem
CStatementEvaluatorInnerTapeInterface	Tape side interface for StatementEvaluatorInterface
CStatementEvaluatorInterface	Creation of handles for the evaluation of expressions in a context where the expression type is not available
CStatementEvaluatorTapeInterface	Tape side interface for StatementEvaluatorInterface
CStatementPushHelper	Add statements to the tape where the Jacobians are computed manually
CStatementPushHelperBase	Base class for manual statement pushes on the tape
CStaticContextActiveType	Replacement type of LhsExpressionInterface types in ConstructStaticContext
CStaticDummy	Static dummy objects for e.g. default reference arguments
CStaticThreadLocalPointerInterface	Abstracts a static thread-local pointer
CSynchronizationInterface	Provides basic synchronization facilities
CTagData	Data for a tag
►CTagTapeBase	Base implementation for tagging tapes
CValidateTags	Looks at the tags for the expression
►CTagTapeForward	Tape for tagging variables and find errors in the AD workflow
►CTapeTypes	Required definition for event system
CIndexManager	Required definition for event system
►CTagTapeReverse	Tape for tagging variables and find errors in the AD workflow
►CTapeTypes	Required definition for event system
CIndexManager	Required definition for event system
CTapeHelper	See TapeHelperBase
CTapeHelperBase	A helper class that allows for a simpler access and management of a CoDiPack tape
CTapeHelperJacobi
CTapeHelperNoImpl
CTapeHelperPrimal
CTapeReaderInterface	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
CTapeTypesInterface	Interface for the definition of tape types
CTapeValues	Tape information that can be printed in a pretty print format or a table format
CTapeWriterInterface	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
CTemporaryMemory	Allocator for temporary used memory
CTerminatingPointerStore
CThreadInformationInterface	Provides information on threads
CThreadSafeGlobalAdjoints	Provides global adjoint variables owned by a tape type. Thread-safe for use in parallel taping
CTraversalLogic	Traversal of CoDiPack expressions
CUnaryExpression	Represents an operator with one argument in the expression tree
CUnaryOperation	Interface for implementing the logic for a UnaryExpression
CValidationIndicator	Helper class for statement validation
CVectorAccessInterface	Unified access to the adjoint vector and primal vector in a tape evaluation
CWarning
CWriteInfo	This class is used during the writing process of a primal value tape. The WriteInfo is returned by codi::PrimalValueBaseTape::statementGetWriteInformation method
►Nstd
Ccodi_numeric_limits	Specialization of std::numeric_limits for the default CoDiPack active types
Cnumeric_limits< codi::ActiveType< Tape > >	Specialization of std::numeric_limits for CoDiPack active types
Cnumeric_limits< codi::ActiveTypeStatelessTape< Tape > >	Specialization of std::numeric_limits for no tape CoDiPack active types
Cnumeric_limits< codi::ParallelActiveType< Tape, ParallelToolbox > >	Specialization of std::numeric_limits for parallel CoDiPack active types
CEigenSolver	[Function]
CLowLevelFunction	Indicator for generator