|
CoDiPack
2.3.0
A Code Differentiation Package
|
|
|
CoDiPack
2.3.0
A Code Differentiation Package
|
|
| ►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 |
| NConfig | Configuration options for CoDiPack |
| NEventHints | |
| ►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 |
1.10.0