|
CoDiPack
2.2.0
A Code Differentiation Package
|
|
|
CoDiPack
2.2.0
A Code Differentiation Package
|
|
| ►Ncodi | CoDiPack - Code Differentiation Package. |
| ►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 |
| 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   |
| 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 |
| ►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 | |
| 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 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 |
| CCommonTapeImplementation | Implementation of all common tape functionality |
| CCommonTapeTypes | Declares all types used in the CommonTapeImplementation |
| 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 |
| 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 |
| CJacobianComputationLogic | |
| CJacobianConvertWrapper | Wrapper for JacboianInterfaces that requires a passive value conversion |
| CJacobianCountNonZerosRow | Adds counting of nonzero entries |
| CJacobianDelayAccessor | |
| CJacobianExpression | Specialized for NumberOfActiveTypeArguments and NumberOfConstantTypeArguments |
| 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 |
| 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 |
| 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 |
| 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 |
| COperationAdd | BinaryOperation implementation for operator + |
| COperationAsin | UnaryOperation implementation for asin |
| 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 |
| 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 |
| CPrimalEvaluationTapeInterface | Perform a primal reevaluation of the tape |
| CPrimalTapeStatementFunctions | Data required for all possible handle calls |
| ►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 | |
| CPushIdentfierPassiveAndConstant | 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 |
| 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 |
| 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 | |
| CTapeTypesInterface | Interface for the definition of tape types |
| CTapeValues | Tape information that can be printed in a pretty print format or a table format |
| 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 | |
| ►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 |
1.10.0