C codi::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 C codi::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 C codi::ActiveArgumentStoreTraits< T_T, typename > Traits for storing active arguments in byte streams C codi::ActiveArgumentValueStore< T_PointerStore > Declares all variables that may be needed to store/restore an active argument which has a value type C codi::ExpressionTraits::ActiveResultImpl< T_Real, T_Tape, T_isStatic, typename > C codi::ExpressionTraits::ActiveResultImpl< std::complex< T_InnerReal >, T_Tape, false > Specialization of ActiveResultImpl for std::complex C codi::ExpressionTraits::ActiveResultImpl< T_Real, T_Tape, false > Specialization of ActiveResultImpl for active types in a static context C codi::ExpressionTraits::ActiveResultImpl< T_Real, T_Tape, true > Specialization of ActiveResultImpl for active types in a static context C codi::AdjointVectorWithOffset< T_Identifier, T_Gradient > Implementation of vector-based adjoints that take into account an offset when addressing into the vector C codi::RealTraits::AggregatedTypeTraits< T_Type, typename > Methods that access inner values of aggregated types that contain CoDiPack active types C codi::AggregatedTypeVectorAccessWrapperFactory< T_Type, typename > Factory for the creation of AggregatedTypeVectorAccessWrapper instances C codi::Algorithms< T_Type, T_ActiveChecks > Basic algorithms for tape evaluation in CoDiPack C codi::ArrayAccessExpressionImpl< T_Aggregated, T_element > C codi::RealTraits::ArrayAggregatedTypeTraitsBase< T_Type, T_InnerType, T_Real, T_Elements > Base implementation of AggregatedTypeTraits for aggregated types that can be defined as an array ► C codi::RealTraits::ArrayAggregatedTypeTraitsBase< ActiveComplex< T_InnerReal >, T_InnerReal, std::conditional< std::is_floating_point< RealTraits::Real< T_InnerReal > >::value, std::complex< RealTraits::Real< T_InnerReal > >, ActiveComplex< RealTraits::Real< T_InnerReal > > >::type, 2 > C codi::RealTraits::AggregatedTypeTraits< ActiveComplex< T_InnerReal > > Specialize real traits for std::complex ► C codi::RealTraits::ArrayAggregatedTypeTraitsBase< std::complex< T_InnerReal >, T_InnerReal, std::complex< RealTraits::Real< T_InnerReal > >, 2 > C codi::RealTraits::AggregatedTypeTraits< std::complex< T_InnerReal > > Specialize real traits for std::complex ► C codi::RealTraits::ArrayAggregatedTypeTraitsBase< Vector4, Number, Vector4, 4 > C codi::RealTraits::AggregatedTypeTraits< Vector4 > [Base declaration] ► C codi::ArrayPosition< T_NestedPosition > Position with one index for e.g. array access C codi::ChunkPosition< T_NestedPosition > Position with two indices for e.g. chunked data access ► C codi::ArrayPosition< NestedPosition > C codi::ChunkPosition< NestedPosition > ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_Real, T_JacobianOptimization, T_Impl > Default implementations for the passive += and -= operators C codi::AssignmentOperators< InnerReal, false, ResolveSelf< Impl, ActiveComplex > > C codi::AssignmentOperators< std::complex< InnerReal >, false, ResolveSelf< Impl, ActiveComplex > > ► C codi::AssignmentOperators< T_Real, T_JacobianOptimization, T_Impl > Provides assignment operators for LhsExpressionInterface implementations C codi::ActiveComplex< codi::ActiveType< Tape >, complex< codi::ActiveType< T_Tape > > > C codi::ActiveComplex< codi::ActiveType< Tape >, complex< codi::ActiveType< T_Tape > > > C codi::ActiveTypeBase< T_Tape, ActiveType > C codi::ActiveTypeBase< Tape, ParallelActiveType > C codi::ActiveTypeStatelessTape< ForwardEvaluation< Real, Gradient > > ► C codi::AssignmentOperatorsPassiveJacobianOptimization< codi::ActiveType< T_Tape >::Real, T_JacobianOptimization, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > ► C codi::AssignmentOperators< codi::ActiveType< T_Tape >::Real, false, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > ► C codi::ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > C std::complex< codi::ActiveType< T_Tape > > ► C codi::AssignmentOperatorsPassiveJacobianOptimization< std::complex< codi::ActiveType< T_Tape >::Real >, T_JacobianOptimization, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > ► C codi::AssignmentOperators< std::complex< codi::ActiveType< T_Tape >::Real >, false, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > C codi::ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > ► C codi::AssignmentOperatorsPassiveJacobianOptimization< std::complex< T_InnerActive::Real >, T_JacobianOptimization, T_Impl > ► C codi::AssignmentOperators< std::complex< T_InnerActive::Real >, false, ResolveSelf< T_Impl, ActiveComplex< T_InnerActive, T_Impl > > > C codi::ActiveComplex< T_InnerActive, T_Impl > ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_ActiveType::Tape::Real, T_JacobianOptimization, ActiveTypeWrapper< T_ActiveType > > ► C codi::AssignmentOperators< T_ActiveType::Tape::Real, T_ActiveType::Tape::AllowJacobianOptimization, ActiveTypeWrapper< T_ActiveType > > C codi::ActiveTypeWrapper< T_ActiveType > Creates a pseudo active type from data references. Can be used to overlay existing data with active types ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_ActiveType::Tape::Real, T_JacobianOptimization, ImmutableActiveType< T_ActiveType > > ► C codi::AssignmentOperators< T_ActiveType::Tape::Real, T_ActiveType::Tape::AllowJacobianOptimization, ImmutableActiveType< T_ActiveType > > C codi::ImmutableActiveType< T_ActiveType > Creates a pseudo active type from a data value. Can be used to overlay existing data with immutable active types ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_InnerActive::Real, T_JacobianOptimization, T_Impl > ► C codi::AssignmentOperators< T_InnerActive::Real, false, ResolveSelf< T_Impl, ActiveComplex< T_InnerActive, T_Impl > > > C codi::ActiveComplex< T_InnerActive, T_Impl > C codi::AssignmentOperatorsPassiveJacobianOptimization< T_Real, true, T_Impl > Optimized Jacobian implementations for the passive += and -= operators ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_Tape::Real, T_JacobianOptimization, ActiveType< T_Tape > > ► C codi::AssignmentOperators< T_Tape::Real, T_Tape::AllowJacobianOptimization, ActiveType< T_Tape > > ► C codi::ActiveTypeBase< T_Tape, ActiveType< T_Tape > > C codi::ActiveType< T_Tape > Represents a concrete lvalue in the CoDiPack expression tree ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_Tape::Real, T_JacobianOptimization, ActiveTypeStatelessTape< T_Tape > > ► C codi::AssignmentOperators< T_Tape::Real, T_Tape::AllowJacobianOptimization, ActiveTypeStatelessTape< T_Tape > > C codi::ActiveTypeStatelessTape< T_Tape > Represents a concrete lvalue in the CoDiPack expression tree ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_Tape::Real, T_JacobianOptimization, ParallelActiveType< T_Tape, T_ParallelToolbox > > ► C codi::AssignmentOperators< T_Tape::Real, T_Tape::AllowJacobianOptimization, ParallelActiveType< T_Tape, T_ParallelToolbox > > ► C codi::ActiveTypeBase< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > > C codi::ParallelActiveType< T_Tape, T_ParallelToolbox > Represents a concrete lvalue in the CoDiPack expression tree ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_Tape::Real, T_JacobianOptimization, T_Impl > ► C codi::AssignmentOperators< T_Tape::Real, T_Tape::AllowJacobianOptimization, T_Impl > ► C codi::ActiveTypeBase< T_Tape, T_Impl > Represents the base implementation concrete lvalue in the CoDiPack expression tree C codi::ActiveType< ForwardEvaluation< Real, Gradient > > C codi::ActiveType< JacobianLinearTape< JacobianTapeTypes< Real, Gradient, LinearIndexManager< Index >, DefaultChunkedData > > > C codi::ActiveType< JacobianLinearTape< JacobianTapeTypes< Real, Gradient, LinearIndexManager< Index >, DefaultBlockData > > > C codi::ActiveType< JacobianReuseTape< JacobianTapeTypes< Real, Gradient, IndexManager, DefaultChunkedData > > > C codi::ActiveType< PrimalValueLinearTape< PrimalValueTapeTypes< Real, Gradient, LinearIndexManager< Index >, StatementEvaluator, DefaultChunkedData > > > C codi::ActiveType< PrimalValueReuseTape< PrimalValueTapeTypes< Real, Gradient, IndexManager, StatementEvaluator, DefaultChunkedData > > > C codi::ActiveType< TagTapeReverse< double, int > > C codi::ActiveType< TagTapeForward< double, int > > C codi::ActiveType< Tape > C codi::ParallelActiveType< JacobianReuseTape< JacobianTapeTypes< Real, Gradient, IndexManager, DefaultChunkedData, OpenMPGlobalAdjoints > >, OpenMPToolbox > ► C codi::AssignmentOperatorsPassiveJacobianOptimization< T_Type::Tape::Real, T_JacobianOptimization, ReferenceActiveType< T_Type > > ► C codi::AssignmentOperators< T_Type::Tape::Real, T_Type::Tape::AllowJacobianOptimization, ReferenceActiveType< T_Type > > C codi::ReferenceActiveType< T_Type > Holds a reference to an ActiveType for manual optimization of common arguments C codi::AssignStatement< T_Lhs, T_Rhs > ► C codi::AtomicInterface< T_Type, T_Impl > Provides a data type on which all operations are performed atomically C codi::OpenMPAtomicImpl< Type > ► C codi::AtomicInterface< T_Type, OpenMPAtomicImpl< T_Type, void > > C codi::OpenMPAtomicImpl< T_Type, T_Sfinae > Atomic implementation for OpenMP C codi::ByteDataView ► C codi::ChunkBase A chunk stores a contiguous block of data in CoDiPack C codi::Chunk1< char > C codi::Chunk2< Config::LowLevelFunctionToken, Config::LowLevelFunctionDataSize > C codi::Chunk2< Real, Identifier > C codi::Chunk3< Config::ArgumentSize, EvalHandle, Config::LowLevelFunctionDataSize > C codi::Chunk1< Data1 > C codi::Chunk2< Data1, Data2 > C codi::Chunk3< Data1, Data2, Data3 > C codi::Chunk4< Data1, Data2, Data3, Data4 > C std::codi_numeric_limits< Type > Specialization of std::numeric_limits for the default CoDiPack active types ► C std::codi_numeric_limits< codi::ActiveType< Tape > > C std::numeric_limits< codi::ActiveType< Tape > > Specialization of std::numeric_limits for CoDiPack active types ► C std::codi_numeric_limits< codi::ActiveTypeStatelessTape< Tape > > C std::numeric_limits< codi::ActiveTypeStatelessTape< Tape > > Specialization of std::numeric_limits for no tape CoDiPack active types ► C std::codi_numeric_limits< codi::ParallelActiveType< Tape, ParallelToolbox > > C std::numeric_limits< codi::ParallelActiveType< Tape, ParallelToolbox > > Specialization of std::numeric_limits for parallel CoDiPack active types C codi::CoDiMpiTypes< T_Type, T_Tool > MPI datatype implementation for CoDipack types in the type wrapper of MeDiPack ► C codi::CommonReaderWriterMethods Used to implement methods common to both the tape readers and the tape writers ► C codi::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 ► C codi::JacobianBaseTapeReader< T_Type > Used to register a statement for a Jacobian tape C codi::JacobianBinaryTapeReader< T_Type > Reads and restores a binary file for a Jacobian tape C codi::JacobianTextTapeReader< T_Type > Reads and restores a text file for a Jacobian tape C codi::PrimalBinaryTapeReader< T_Type > Reads and restores a binary file for a Primal tape C codi::PrimalTextTapeReader< T_Type > Reads and restores a text file for a primal value tape ► C codi::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 ► C codi::CommonTextTapeWriter< T_Type > This base class is used to modify the math representation of a statement C codi::JacobianGraphTapeWriter< T_Type > Generates a graphical .dot file for a Jacobian tape C codi::MathRepWriter< T_Type > Generates a file with the math representation for each of the statements C codi::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 C codi::JacobianBinaryTapeWriter< T_Type > Writes a Jacobian tape in a binary format C codi::JacobianTextTapeWriter< T_Type > Writes a Jacobian tape in a text format ► C codi::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 C codi::PrimalBinaryTapeWriter< T_Type > Writes a primal value tape in a binary format C codi::PrimalTextTapeWriter< T_Type > Writes a primal value tape in a text format C codi::CommonTapeTypes< T_TapeTypes > Declares all types used in the CommonTapeImplementation C codi::CompileTimeLoop< T_pos, T_end, T_step > Compile time loop evaluation C codi::CompileTimeLoop< T_pos, T_pos, T_step > Termination of loop evaluation ► C codi::CompileTimeTraversalLogic< T_ResultType, T_Impl > Traversal of CoDiPack expressions during compile time C codi::ExpressionTraits::NumberOfActiveTypeArguments< JacobianExpression< size > > Specialization for manual statement pushes of the used expression type C codi::ExpressionTraits::NumberOfConstantTypeArguments< JacobianExpression< size > > Specialization for manual statement pushes of the used expression type ► C codi::CompileTimeTraversalLogic< size_t, NumberOfActiveTypeArguments< Expr > > C codi::ExpressionTraits::NumberOfActiveTypeArguments< Expr > Counts the number of nodes that inherit from LhsExpressionInterface in the expression ► C codi::CompileTimeTraversalLogic< size_t, NumberOfConstantTypeArguments< Expr > > C codi::ExpressionTraits::NumberOfConstantTypeArguments< Expr > Counts the number of types that inherit from ConstantExpression in the expression ► C codi::CompileTimeTraversalLogic< size_t, NumberOfOperations< Expr > > C codi::ExpressionTraits::NumberOfOperations< Expr > Counts the number of nodes in the expression ► C codi::ComputeOperation< T_Real > Interface for implementing the logic for a ComputeExpression ► C codi::BinaryOperation< T_Real, OperationAdd< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationAdd< T_Real > > C codi::OperationAdd< T_Real > BinaryJacobianOperation implementation for operator + ► C codi::BinaryOperation< T_Real, OperationAtan2< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationAtan2< T_Real > > C codi::OperationAtan2< T_Real > BinaryJacobianOperation implementation for atan2 ► C codi::BinaryOperation< T_Real, OperationCopysign< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationCopysign< T_Real > > C codi::OperationCopysign< T_Real > BinaryJacobianOperation implementation for copysign ► C codi::BinaryOperation< T_Real, OperationDivide< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationDivide< T_Real > > C codi::OperationDivide< T_Real > BinaryJacobianOperation implementation for operator / ► C codi::BinaryOperation< T_Real, OperationFmod< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationFmod< T_Real > > C codi::OperationFmod< T_Real > BinaryJacobianOperation implementation for fmod ► C codi::BinaryOperation< T_Real, OperationFrexp< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationFrexp< T_Real > > C codi::OperationFrexp< T_Real > BinaryJacobianOperation implementation for frexp ► C codi::BinaryOperation< T_Real, OperationHypot< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationHypot< T_Real > > C codi::OperationHypot< T_Real > BinaryJacobianOperation implementation for hypot ► C codi::BinaryOperation< T_Real, OperationLdexp< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationLdexp< T_Real > > C codi::OperationLdexp< T_Real > BinaryJacobianOperation implementation for ldexp ► C codi::BinaryOperation< T_Real, OperationMax< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationMax< T_Real > > C codi::OperationMax< T_Real > BinaryJacobianOperation implementation for max ► C codi::BinaryOperation< T_Real, OperationMin< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationMin< T_Real > > C codi::OperationMin< T_Real > BinaryJacobianOperation implementation for min ► C codi::BinaryOperation< T_Real, OperationMultiply< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationMultiply< T_Real > > C codi::OperationMultiply< T_Real > BinaryJacobianOperation implementation for operator * ► C codi::BinaryOperation< T_Real, OperationPow< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationPow< T_Real > > C codi::OperationPow< std::complex< T_Real > > BinaryJacobianOperation specialization for complex pow C codi::OperationPow< T_Real > BinaryJacobianOperation implementation for pow ► C codi::BinaryOperation< T_Real, OperationPow< std::complex< T_Real > > > ► C codi::BinaryJacobianOperation< std::complex< T_Real >, OperationPow< std::complex< T_Real > > > C codi::OperationPow< std::complex< T_Real > > BinaryJacobianOperation specialization for complex pow ► C codi::BinaryOperation< T_Real, OperationRemainder< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationRemainder< T_Real > > C codi::OperationRemainder< T_Real > ► C codi::BinaryOperation< T_Real, OperationSubstract< T_Real > > ► C codi::BinaryJacobianOperation< T_Real, OperationSubstract< T_Real > > C codi::OperationSubstract< T_Real > BinaryJacobianOperation implementation for operator - ► C codi::UnaryOperation< T_Real, ArrayAccessOperation< T_Real > > C codi::ArrayAccessExpressionImpl< T_Aggregated, T_element >::ArrayAccessOperation< T_Real > ► C codi::UnaryOperation< T_Real, OperationAbs< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationAbs< T_Real > > C codi::OperationAbs< T_Real > UnaryJacobianOperation implementation for abs ► C codi::UnaryOperation< T_Real, OperationAcos< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationAcos< T_Real > > C codi::OperationAcos< T_Real > UnaryJacobianOperation implementation for acos ► C codi::UnaryOperation< T_Real, OperationAcosh< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationAcosh< T_Real > > C codi::OperationAcosh< T_Real > UnaryJacobianOperation implementation for acosh ► C codi::UnaryOperation< T_Real, OperationAsin< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationAsin< T_Real > > C codi::OperationAsin< T_Real > UnaryJacobianOperation implementation for asin ► C codi::UnaryOperation< T_Real, OperationAsinh< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationAsinh< T_Real > > C codi::OperationAsinh< T_Real > UnaryJacobianOperation implementation for asinh ► C codi::UnaryOperation< T_Real, OperationAtan< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationAtan< T_Real > > C codi::OperationAtan< T_Real > UnaryJacobianOperation implementation for atan ► C codi::UnaryOperation< T_Real, OperationAtanh< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationAtanh< T_Real > > C codi::OperationAtanh< T_Real > UnaryJacobianOperation implementation for atanh ► C codi::UnaryOperation< T_Real, OperationCbrt< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationCbrt< T_Real > > C codi::OperationCbrt< T_Real > UnaryJacobianOperation implementation for cbrt ► C codi::UnaryOperation< T_Real, OperationComplexAbs< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationComplexAbs< T_Real > > C codi::OperationComplexAbs< T_Real > UnaryJacobianOperation implementation for complex abs ► C codi::UnaryOperation< T_Real, OperationComplexArg< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationComplexArg< T_Real > > C codi::OperationComplexArg< T_Real > UnaryJacobianOperation implementation for complex arg ► C codi::UnaryOperation< T_Real, OperationComplexImag< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationComplexImag< T_Real > > C codi::OperationComplexImag< T_Real > UnaryJacobianOperation implementation for complex imag ► C codi::UnaryOperation< T_Real, OperationComplexNorm< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationComplexNorm< T_Real > > C codi::OperationComplexNorm< T_Real > UnaryJacobianOperation implementation for complex real ► C codi::UnaryOperation< T_Real, OperationComplexReal< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationComplexReal< T_Real > > C codi::OperationComplexReal< T_Real > UnaryJacobianOperation implementation for complex real ► C codi::UnaryOperation< T_Real, OperationCos< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationCos< T_Real > > C codi::OperationCos< T_Real > UnaryJacobianOperation implementation for cos ► C codi::UnaryOperation< T_Real, OperationCosh< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationCosh< T_Real > > C codi::OperationCosh< T_Real > UnaryJacobianOperation implementation for cosh ► C codi::UnaryOperation< T_Real, OperationErf< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationErf< T_Real > > C codi::OperationErf< T_Real > UnaryJacobianOperation implementation for erf ► C codi::UnaryOperation< T_Real, OperationErfc< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationErfc< T_Real > > C codi::OperationErfc< T_Real > UnaryJacobianOperation implementation for erfc ► C codi::UnaryOperation< T_Real, OperationExp< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationExp< T_Real > > C codi::OperationExp< T_Real > UnaryJacobianOperation implementation for exp ► C codi::UnaryOperation< T_Real, OperationLog< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationLog< T_Real > > C codi::OperationLog< T_Real > UnaryJacobianOperation implementation for log ► C codi::UnaryOperation< T_Real, OperationLog10< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationLog10< T_Real > > C codi::OperationLog10< T_Real > UnaryJacobianOperation implementation for log10 ► C codi::UnaryOperation< T_Real, OperationLog1p< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationLog1p< T_Real > > C codi::OperationLog1p< T_Real > UnaryJacobianOperation implementation for log1p ► C codi::UnaryOperation< T_Real, OperationLog2< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationLog2< T_Real > > C codi::OperationLog2< T_Real > UnaryJacobianOperation implementation for log2 ► C codi::UnaryOperation< T_Real, OperationSin< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationSin< T_Real > > C codi::OperationSin< T_Real > UnaryJacobianOperation implementation for sin ► C codi::UnaryOperation< T_Real, OperationSinh< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationSinh< T_Real > > C codi::OperationSinh< T_Real > UnaryJacobianOperation implementation for sinh ► C codi::UnaryOperation< T_Real, OperationSqrt< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationSqrt< T_Real > > C codi::OperationSqrt< T_Real > UnaryJacobianOperation implementation for sqrt ► C codi::UnaryOperation< T_Real, OperationTan< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationTan< T_Real > > C codi::OperationTan< T_Real > UnaryJacobianOperation implementation for tan ► C codi::UnaryOperation< T_Real, OperationTanh< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationTanh< T_Real > > C codi::OperationTanh< T_Real > UnaryJacobianOperation implementation for tanh ► C codi::UnaryOperation< T_Real, OperationTgamma< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationTgamma< T_Real > > C codi::OperationTgamma< T_Real > UnaryJacobianOperation implementation for tgamma ► C codi::UnaryOperation< T_Real, OperationUnaryMinus< T_Real > > ► C codi::UnaryJacobianOperation< T_Real, OperationUnaryMinus< T_Real > > C codi::OperationUnaryMinus< T_Real > UnaryJacobianOperation implementation for operator - ► C codi::BinaryOperation< T_Real, T_Impl > Implements ComputeOperation for two arguments C codi::BinaryJacobianOperation< T_Real, T_Impl > Implements BinaryOperation for functions where the gradients can be computed and transposed ► C codi::UnaryOperation< T_Real, T_Impl > Implements ComputeOperation for one argument C codi::UnaryJacobianOperation< T_Real, T_Impl > Implements UnaryOperation for functions where the gradient can be computed and transposed ► C codi::ComputeOperation< Number > ► C codi::UnaryOperation< Number, VectorNormOperation< T > > ► C codi::UnaryJacobianOperation< Number, VectorNormOperation< T > > C VectorNormOperation< T > [Operation implementation] ► C codi::ComputeOperation< T_ComplexReal > ► C codi::BinaryOperation< T_ComplexReal, OperationComplexPolar< T_ComplexReal > > C codi::OperationComplexPolar< T_ComplexReal > BinaryJacobianOperation specialization for complex polar ► C codi::UnaryOperation< T_ComplexReal, OperationComplexConj< T_ComplexReal > > C codi::OperationComplexConj< T_ComplexReal > UnaryJacobianOperation implementation for complex conj ► C codi::UnaryOperation< T_ComplexReal, OperationComplexProj< T_ComplexReal > > ► C codi::UnaryJacobianOperation< T_ComplexReal, OperationComplexProj< T_ComplexReal > > C codi::OperationComplexProj< T_ComplexReal > UnaryJacobianOperation implementation for complex proj ► C codi::UnaryOperation< T_ComplexReal, OperationRealToComplexCast< T_ComplexReal > > C codi::OperationRealToComplexCast< T_ComplexReal > Returns a proxy object for the gradient that implements the operation in the multiplication of the proxy ► C codi::ComputeOperation< Vector4 > ► C codi::BinaryOperation< Vector4, ScalarVectorMultiplicationOperation< T > > ► C codi::BinaryJacobianOperation< Vector4, ScalarVectorMultiplicationOperation< T > > C ScalarVectorMultiplicationOperation< T > [Vector4 specializations] ► C codi::BinaryOperation< Vector4, VectorAdditionOperation< T > > ► C codi::BinaryJacobianOperation< Vector4, VectorAdditionOperation< T > > C VectorAdditionOperation< T > Operation for vector + vector C codi::ConstantDataConversion< T_StoreData > C codi::ConstructStaticContextLogic< T_Rhs, T_Tape, T_primalValueOffset, T_constantValueOffset, typename > Helper class for the construction of an expression in a different context C codi::ConstructVectorImpl< T_V, typename > C codi::ConstructVectorImpl< std::array< T_T, T_n > > ► C codi::CustomAdjointVectorInterface< T_Type > General interface for an arbitrary adjoint evaluation C codi::CustomAdjointVectorHelper< T_Type, T_Gradient > Allows for an arbitrary adjoint evaluation of a recorded tape C codi::RealTraits::DataExtraction< T_Type, typename > Data handling methods for aggregated types that contain CoDiPack active types ► C codi::DataInterface< T_NestedData, T_InternalPosHandle > Data stream interface for tape data. Encapsulates data that is written e.g. for each statement or argument C codi::BlockData< Chunk, NestedData > C codi::ChunkedData< Chunk, NestedData > ► C codi::EmptyData No data is stored in this DataInterface implementation. It is used to terminate the recursive nature of the DataInterface design C codi::ReuseIndexManagerBase< Index, ParallelReuseIndexManager > C codi::ReuseIndexManagerBase< Index, ReuseIndexManager > ► C codi::ReuseIndexManagerBase< T_Index, ParallelReuseIndexManager< T_Index, T_ParallelToolbox > > C codi::ParallelReuseIndexManager< T_Index, T_ParallelToolbox > Reuse index manager with a one-to-one relation between tapes and index manager ► C codi::ReuseIndexManagerBase< T_Index, ReuseIndexManager< T_Index > > ► C codi::ReuseIndexManager< T_Index > Reuse index manager with a many-to-one relation between tapes and index manager C codi::MultiUseIndexManager< T_Index > Extends the ReuseIndexManager with a copy optimization ► C codi::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 C codi::ReuseIndexManager< Index > C codi::LinearIndexManager< T_Index > Identifiers are created in a linear fashion. Each assign creates a new index which is counted up ► C codi::DataInterface< EmptyData > C codi::BlockData< T_Chunk, T_NestedData, T_PointerInserter > Data is stored in one contiguous block in this DataInterface implementation C codi::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 ► C codi::DataManagementTapeInterface< T_Real, T_Identifier > Provides file IO, information about internal tape vectors and allows to clear tape data C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::DataManagementTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Identifier > ► C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::CommonTapeImplementation< T_ImplTapeTypes, T_Impl > Implementation of all common tape functionality C codi::JacobianBaseTape< TapeTypes, JacobianLinearTape > C codi::JacobianBaseTape< T_TapeTypes, JacobianReuseTape > ► C codi::PrimalValueBaseTape< T_TapeTypes, PrimalValueLinearTape< T_TapeTypes > > C codi::PrimalValueLinearTape< T_TapeTypes > Final implementation for a primal value tape with a linear index management ► C codi::PrimalValueBaseTape< T_TapeTypes, PrimalValueReuseTape< T_TapeTypes > > C codi::PrimalValueReuseTape< T_TapeTypes > Final implementation for a primal value tape with a reuse index management ► C codi::DataManagementTapeInterface< T_Real, TagData< T_Tag > > ► C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::TagTapeReverse< T_Real, T_Tag > Tape for tagging variables and find errors in the AD workflow ► C codi::DataManagementTapeInterface< T_TapeTypes::Real, T_TapeTypes::Identifier > ► C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > ► C codi::CommonTapeImplementation< T_TapeTypes, T_Impl > C codi::JacobianBaseTape< T_TapeTypes, T_Impl > Base class for all standard Jacobian tape implementations C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl > Base class for all standard Primal value tape implementations ► C codi::CommonTapeImplementation< T_TapeTypes, JacobianLinearTape< T_TapeTypes > > ► C codi::JacobianBaseTape< T_TapeTypes, JacobianLinearTape< T_TapeTypes > > C codi::JacobianLinearTape< T_TapeTypes > Final implementation for a Jacobian tape with a linear index management ► C codi::CommonTapeImplementation< T_TapeTypes, JacobianReuseTape< T_TapeTypes > > ► C codi::JacobianBaseTape< T_TapeTypes, JacobianReuseTape< T_TapeTypes > > C codi::JacobianReuseTape< T_TapeTypes > Final implementation for a Jacobian tape with a reuse index management C codi::DerivativeAccess< T_Type > A helper class for the access of the various derivatives in higher order AD types C codi::Direction< T_Real, T_dim > Fixed size vector mode implementation C codi::DirectStatementEvaluatorStaticStore< Generator, Stmt > C codi::DummyValue Dummy value that can be assigned C codi::DummyVector Dummy vector that provides a dummy element access and size function C codi::DuplicateJacobianRemover< T_Real, T_Identifier > Combines entries of Jacobians with the same identifier C codi::EditingTapeInterface< T_Position > Edit tapes after they have been recorded ► C codi::EditingTapeInterface< JacobianBaseTape< T_TapeTypes, JacobianReuseTape< T_TapeTypes > >::Position > C codi::JacobianReuseTape< T_TapeTypes > Final implementation for a Jacobian tape with a reuse index management C codi::EigenLinearSystemTypes< T_Type, T_Matrix, T_Vector > Eigen definition for the LinearSystemInterfaceTypes C codi::EmptyPosition Empty Position with no nested data C codi::EnumBitset< T_Enum > A bitset with enum items as flags ► C codi::EvaluationHandleBase< T_Func, T_Type, T_InputStore, T_OutputStore > Basic interface and data storage for all EvaluationHandle implementations C codi::EvaluationHandleForward< Func, JacobianComputationType > C codi::EvaluationHandleForward< Func, HessianComputationType > C codi::EvaluationHandleForward< Func, JacobianComputationType, std::array< JacobianComputationType, n >, std::array< JacobianComputationType, m > > C codi::EvaluationHandleForward< Func, HessianComputationType, std::array< HessianComputationType, n >, std::array< HessianComputationType, m > > C codi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, typename > See EvaluationHandleBase C codi::EvaluationHandleForward< T_Func, T_Type, T_InputStore, T_OutputStore > ► C codi::EvaluationHandleReverseBase< T_Func, T_Type, T_InputStore, T_OutputStore > Implementation for reverse mode CoDiPack types of EvaluationHandleBase C codi::EvaluationHandleReverseJacobianTapes< T_Func, T_Type, T_InputStore, T_OutputStore > Implementation for Jacobian reverse mode CoDiPack types of EvaluationHandleBase C codi::EvaluationHandleReversePrimalValueTapes< T_Func, T_Type, T_InputStore, T_OutputStore > Implementation of EvaluationHandleBase for primal value reverse mode CoDiPack types ► C codi::EvaluationHandleBase< Func, Type, InputStore, OutputStore > C codi::EvaluationHandleReverseBase< Func, Type, InputStore, OutputStore > ► C codi::EvaluationHandleBase< T_Func, T_Type, std::vector< T_Type >, std::vector< T_Type > > C codi::EvaluationHandleReverseBase< T_Func, T_Type, std::vector< T_Type >, std::vector< T_Type > > ► C codi::EvaluationHandleBase< T_Func, T_Type, T_InputStore, T_OutputStore > C codi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > > See EvaluationHandleForward C codi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfJacobianTape< typename T_Type::Tape > > See EvaluationHandleReverseJacobianTapes C codi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfPrimalValueTape< typename T_Type::Tape > > See EvaluationHandleReversePrimalValueTapes ► C codi::EvaluationHandleForward< T_Func, T_Type, T_InputStore, T_OutputStore > C codi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > > See EvaluationHandleForward ► C codi::EvaluationHandleReverseBase< T_Func, T_Type, T_InputStore, T_OutputStore > ► C codi::EvaluationHandleReverseJacobianTapes< T_Func, T_Type, T_InputStore, T_OutputStore > C codi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfJacobianTape< typename T_Type::Tape > > See EvaluationHandleReverseJacobianTapes ► C codi::EvaluationHandleReversePrimalValueTapes< T_Func, T_Type, T_InputStore, T_OutputStore > C codi::EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfPrimalValueTape< typename T_Type::Tape > > See EvaluationHandleReversePrimalValueTapes C codi::EvaluationHelper Evaluate the primal, Jacobian and Hessian of function objects ► C codi::EventSystemBase< T_Tape > Base class for the CoDiPack event system C codi::EventSystem< T_Tape > Full EventSystem implementation for reverse tapes ► C codi::EventSystemBase< ForwardEvaluation< Real, Gradient > > C codi::EventSystem< ForwardEvaluation< Real, Gradient > > Specialization for ForwardEvaluation C codi::EventSystem< ForwardEvaluation< Real, Gradient > > Specialization for ForwardEvaluation ► C codi::ExpressionMemberOperations< T_Real, T_Impl, typename > C codi::ExpressionInterface< Real, StaticContextActiveType > ► C codi::ExpressionInterface< T_Real, T_Impl > Base class for all CoDiPack expressions ► C codi::AggregatedActiveTypeBase< T_Real, T_InnerActiveType, T_Impl, false > ► C codi::AggregatedActiveType< T_Real, T_InnerActiveType, T_Impl > Represents a concrete aggregated lvalue int the CoDiPack expression tree C codi::ActiveComplex< codi::ActiveType< Tape >, complex< codi::ActiveType< T_Tape > > > C codi::AggregatedActiveTypeBase< Real, InnerActiveType, StaticAggregatedActiveType, true > C codi::ComputeExpression< InnerReal, ArrayAccessOperation, Arg > C codi::ComputeExpression< std::complex< T_Real >, OperationRealToComplexCast, T_Arg > C codi::ComputeExpression< InnerType, OperationComplexReal, Impl > C codi::ComputeExpression< InnerType, OperationComplexImag, Impl > C codi::LhsExpressionInterface< Real, Gradient, T_Tape, T_Impl > C codi::LhsExpressionInterface< Real, Gradient, T_Tape, ActiveTypeStatelessTape< T_Tape > > C codi::LhsExpressionInterface< Real, Gradient, Tape, ActiveTypeWrapper > C codi::LhsExpressionInterface< Real, Gradient, Tape, ImmutableActiveType > C codi::StaticContextActiveType< Tape > ► C codi::AggregatedActiveTypeBase< T_Real, T_InnerActiveType, T_Impl, T_isStatic > Defines an aggregated type via an array and implements the ExpressionInterface C codi::AggregatedActiveType< Real, InnerActive, Impl > ► C codi::AggregatedActiveType< Vector4, ActiveNumber, ActiveVector4 > C ActiveVector4 [Member operation implementation] ► C codi::LhsExpressionInterface< T_Real, T_Gradient, T_Tape, T_Impl > Base class for all CoDiPack lvalue expression C codi::ActiveTypeBase< T_Tape, ActiveType > C codi::ActiveTypeBase< Tape, ParallelActiveType > C codi::ActiveTypeStatelessTape< ForwardEvaluation< Real, Gradient > > ► C codi::ExpressionMemberOperations< std::complex< codi::ActiveType< T_Tape >::Real >, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > ► C codi::ExpressionInterface< std::complex< codi::ActiveType< T_Tape >::Real >, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > ► C codi::AggregatedActiveTypeBase< std::complex< codi::ActiveType< T_Tape >::Real >, codi::ActiveType< T_Tape >, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > >, false > ► C codi::AggregatedActiveType< std::complex< codi::ActiveType< T_Tape >::Real >, codi::ActiveType< T_Tape >, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > C codi::ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > ► C codi::ExpressionMemberOperations< std::complex< T_InnerActive::Real >, T_Impl > ► C codi::ExpressionInterface< std::complex< T_InnerActive::Real >, T_Impl > ► C codi::AggregatedActiveTypeBase< std::complex< T_InnerActive::Real >, T_InnerActive, T_Impl, false > ► C codi::AggregatedActiveType< std::complex< T_InnerActive::Real >, T_InnerActive, ResolveSelf< T_Impl, ActiveComplex< T_InnerActive, T_Impl > > > C codi::ActiveComplex< T_InnerActive, T_Impl > ► C codi::ExpressionMemberOperations< T_ActiveType::Real, ActiveTypeWrapper< T_ActiveType > > ► C codi::ExpressionInterface< T_ActiveType::Real, ActiveTypeWrapper< T_ActiveType > > ► C codi::LhsExpressionInterface< T_ActiveType::Real, T_ActiveType::Gradient, T_ActiveType::Tape, ActiveTypeWrapper< T_ActiveType > > C codi::ActiveTypeWrapper< T_ActiveType > Creates a pseudo active type from data references. Can be used to overlay existing data with active types ► C codi::ExpressionMemberOperations< T_ActiveType::Real, ImmutableActiveType< T_ActiveType > > ► C codi::ExpressionInterface< T_ActiveType::Real, ImmutableActiveType< T_ActiveType > > ► C codi::LhsExpressionInterface< T_ActiveType::Real, T_ActiveType::Gradient, T_ActiveType::Tape, ImmutableActiveType< T_ActiveType > > C codi::ImmutableActiveType< T_ActiveType > Creates a pseudo active type from a data value. Can be used to overlay existing data with immutable active types ► C codi::ExpressionMemberOperations< T_Real, ComputeExpression< T_Real, T_Operation, T_ArgExprs... > > ► C codi::ExpressionInterface< T_Real, ComputeExpression< T_Real, T_Operation, T_ArgExprs... > > C codi::ComputeExpression< T_Real, T_Operation, T_ArgExprs > Represents an operator or function with an arbitrary number of arguments in the expression tree ► C codi::ExpressionMemberOperations< T_Real, ConstantExpression< T_Real, ConstantDataConversion > > ► C codi::ExpressionInterface< T_Real, ConstantExpression< T_Real, ConstantDataConversion > > C codi::ConstantExpression< T_Real, T_ConversionOperator > Represents constant values in the expression tree ► C codi::ExpressionMemberOperations< T_Real, StaticAggregatedActiveType< T_Real, T_InnerActiveType > > ► C codi::ExpressionInterface< T_Real, StaticAggregatedActiveType< T_Real, T_InnerActiveType > > ► C codi::AggregatedActiveTypeBase< T_Real, T_InnerActiveType, StaticAggregatedActiveType< T_Real, T_InnerActiveType >, true > C codi::StaticAggregatedActiveType< T_Real, T_InnerActiveType > Static context implementation of the aggregated active type C codi::ExpressionMemberOperations< T_Real, T_Impl, typename std::enable_if< std::is_same< T_Real, std::complex< typename T_Real::value_type > >::value >::type > ► C codi::ExpressionMemberOperations< T_Tape::Real, ActiveType< T_Tape > > ► C codi::ExpressionInterface< T_Tape::Real, ActiveType< T_Tape > > ► C codi::LhsExpressionInterface< T_Tape::Real, T_Tape::Gradient, T_Tape, ActiveType< T_Tape > > C codi::ActiveTypeBase< T_Tape, ActiveType< T_Tape > > ► C codi::ExpressionMemberOperations< T_Tape::Real, ActiveTypeStatelessTape< T_Tape > > ► C codi::ExpressionInterface< T_Tape::Real, ActiveTypeStatelessTape< T_Tape > > ► C codi::LhsExpressionInterface< T_Tape::Real, T_Tape::Gradient, T_Tape, ActiveTypeStatelessTape< T_Tape > > C codi::ActiveTypeStatelessTape< T_Tape > Represents a concrete lvalue in the CoDiPack expression tree ► C codi::ExpressionMemberOperations< T_Tape::Real, ParallelActiveType< T_Tape, T_ParallelToolbox > > ► C codi::ExpressionInterface< T_Tape::Real, ParallelActiveType< T_Tape, T_ParallelToolbox > > ► C codi::LhsExpressionInterface< T_Tape::Real, T_Tape::Gradient, T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > > C codi::ActiveTypeBase< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > > ► C codi::ExpressionMemberOperations< T_Tape::Real, StaticContextActiveType< T_Tape > > ► C codi::ExpressionInterface< T_Tape::Real, StaticContextActiveType< T_Tape > > C codi::StaticContextActiveType< T_Tape > Replacement type of LhsExpressionInterface types in ConstructStaticContext ► C codi::ExpressionMemberOperations< T_Tape::Real, T_Impl > ► C codi::ExpressionInterface< T_Tape::Real, T_Impl > ► C codi::LhsExpressionInterface< T_Tape::Real, T_Tape::Gradient, T_Tape, T_Impl > C codi::ActiveTypeBase< T_Tape, T_Impl > Represents the base implementation concrete lvalue in the CoDiPack expression tree ► C codi::ExpressionMemberOperations< T_Type::Real, ReferenceActiveType< T_Type > > ► C codi::ExpressionInterface< T_Type::Real, ReferenceActiveType< T_Type > > ► C codi::LhsExpressionInterface< T_Type::Real, T_Type::Gradient, T_Type::Tape, ReferenceActiveType< T_Type > > C codi::ReferenceActiveType< T_Type > Holds a reference to an ActiveType for manual optimization of common arguments C codi::ExpressionMemberOperations< Vector4, Impl > ► C codi::ExternalFunctionHelper< T_Type, T_Synchronization, T_ThreadInformation > Helper class for the implementation of an external function in CoDiPack C codi::EnzymeExternalFunctionHelper< T_Type > Helper class for the implementation of an external function with Enzyme in CoDiPack ► C codi::ExternalFunctionInternalData Internal untyped data for an external function C codi::ExternalFunction< Tape > C codi::ExternalFunction< T_Tape > User-defined evaluation functions for the taping process C codi::ExternalFunctionLowLevelEntryMapper< T_Tape, T_Real, T_Identifier > Low level function entry implementation for external functions ► C codi::ExternalFunctionTapeInterface< T_Real, T_Gradient, T_Identifier > Add user defined functions to the tape evaluation C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::ExternalFunctionTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::ExternalFunctionTapeInterface< T_Real, T_Real, TagData< T_Tag > > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::ExternalFunctionTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::ExternalFunctionUserData Ease of access structure for user-provided data on the tape for external functions. See ExternalFunctionTapeInterface C codi::ExtFunc_matrixMatrixMultiplication< eigenStore, Type > Low level function generation for matrixMatrixMultiplication ► C std::false_type C codi::AtomicTraits::IsAtomic< OpenMPAtomic< T_Type > > Declare OpenMPAtomic to be atomic in terms of AtomicTraits C codi::AtomicTraits::IsAtomic< OpenMPReverseAtomic< T_Type > > Declare OpenMPAtomic to be atomic in terms of AtomicTraits C codi::AtomicTraits::IsAtomic< Type > Indicate whether a type is atomic C codi::ExpressionTraits::IsConstantExpression< Expr > If the expression inherits from ConstantExpression . Is either std::false_type or std::true_type C codi::ExpressionTraits::IsExpression< Expr, typename > If the expression inherits from ExpressionInterface . Is either std::false_type or std::true_type C codi::ExpressionTraits::IsLhsExpression< Expr, typename > If the expression inherits from LhsExpressionInterface . Is either std::false_type or std::true_type C codi::ExpressionTraits::IsStaticContextActiveType< Expr > If the expression inherits from StaticContextActiveType . Is either std::false_type or std::true_type C codi::GradientTraits::IsDirection< Gradient, typename > If the expression inherits from Direction . Is either std::false_type or std::true_type C codi::InternalAdjointVectorTraits::IsGlobal< InternalAdjointType > Whether the adjoint vector is global, that is, shared among different tapes C codi::TapeTraits::IsForwardTape< Tape, typename > If the tape inherits from ForwardEvaluation C codi::TapeTraits::IsJacobianTape< Tape, typename > If the tape inherits from JacobianBaseTape C codi::TapeTraits::IsPrimalValueTape< Tape, typename > If the tape inherits from PrimalValueBaseTape C codi::TapeTraits::IsReverseTape< Tape, typename > C codi::TapeTraits::IsTagTape< Tape, typename > If the tape inherits from TagTapeBase C codi::TapeTraits::IsTagTapeReverse< Tape, typename > If the tape inherits from TagTapeReverse C codi::TapeTraits::SupportsEditing< Tape, typename > C codi::FileIo Helper structure for writing binary data ► C First C codi::CODI_UNION< First > Creates a union of interface definitions ► C codi::GradientAccessTapeInterface< T_Gradient, T_Identifier > Allow for a direct access to the gradient information computed by the tape C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::ReverseTapeInterface< T_Real, T_Gradient, T_Identifier > Minimum tape interface for a working reverse tape implementation C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::GradientAccessTapeInterface< T_Gradient, T_Gradient > C codi::ForwardEvaluation< T_Real, T_Gradient > Implementation of a tape-free forward AD mode through the internal expression interfaces ► C codi::GradientAccessTapeInterface< T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::ReverseTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::GradientAccessTapeInterface< T_Real, TagData< T_Tag > > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::ReverseTapeInterface< T_Real, T_Real, TagData< T_Tag > > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::GradientAccessTapeInterface< T_Tag, T_Tag > C codi::TagTapeForward< T_Real, T_Tag > Tape for tagging variables and find errors in the AD workflow ► C codi::GradientAccessTapeInterface< T_TapeTypes::Gradient, T_TapeTypes::Identifier > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > ► C codi::ReverseTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::AdjointVectorTraits::GradientImplementation< AdjointVector > Trait implementation to deduce the entry type from an adjoint vector type ► C codi::HessianInterface< T_T > General interface for Hessian access in CoDiPack C codi::Hessian< PassiveReal > C codi::Hessian< T_T, T_Store > Default implementation of the Hessian interface ► C codi::HessianInterface< DummyValue > C codi::DummyHessian Dummy Hessian . Has size zero and no logic in any call ► C codi::IdentifierInformationTapeInterface< T_Real, T_Gradient, T_Identifier > General information about the identifiers and checks if variables are active C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::IdentifierInformationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::IdentifierInformationTapeInterface< T_Real, T_Real, TagData< T_Tag > > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::IdentifierInformationTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > ► C codi::IncrementOperators< T_Tape, T_Impl > Implementation of increment operators for LhsExpressionInterface implementations C codi::ActiveTypeBase< T_Tape, ActiveType > C codi::ActiveTypeBase< Tape, ParallelActiveType > C codi::ActiveTypeStatelessTape< ForwardEvaluation< Real, Gradient > > C codi::ActiveTypeBase< T_Tape, T_Impl > Represents the base implementation concrete lvalue in the CoDiPack expression tree ► C codi::IncrementOperators< T_ActiveType::Tape, ActiveTypeWrapper< T_ActiveType > > C codi::ActiveTypeWrapper< T_ActiveType > Creates a pseudo active type from data references. Can be used to overlay existing data with active types ► C codi::IncrementOperators< T_ActiveType::Tape, ImmutableActiveType< T_ActiveType > > C codi::ImmutableActiveType< T_ActiveType > Creates a pseudo active type from a data value. Can be used to overlay existing data with immutable active types ► C codi::IncrementOperators< T_Tape, ActiveType< T_Tape > > C codi::ActiveTypeBase< T_Tape, ActiveType< T_Tape > > ► C codi::IncrementOperators< T_Tape, ActiveTypeStatelessTape< T_Tape > > C codi::ActiveTypeStatelessTape< T_Tape > Represents a concrete lvalue in the CoDiPack expression tree ► C codi::IncrementOperators< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > > C codi::ActiveTypeBase< T_Tape, ParallelActiveType< T_Tape, T_ParallelToolbox > > ► C codi::IncrementOperators< T_Type::Tape, ReferenceActiveType< T_Type > > C codi::ReferenceActiveType< T_Type > Holds a reference to an ActiveType for manual optimization of common arguments C codi::TagTapeForward< T_Real, T_Tag >::TapeTypes::IndexManager Required definition for event system C codi::TagTapeReverse< T_Real, T_Tag >::TapeTypes::IndexManager Required definition for event system ► C codi::IndexManagerInterface< T_Index > Indices enable the mapping of primal values to their adjoint counterparts C codi::ReuseIndexManagerBase< T_Index, ParallelReuseIndexManager< T_Index, T_ParallelToolbox > > C codi::ReuseIndexManagerBase< T_Index, ReuseIndexManager< T_Index > > C codi::LinearIndexManager< T_Index > Identifiers are created in a linear fashion. Each assign creates a new index which is counted up C codi::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 ► C codi::IndexManagerInterface< Index > C codi::ReuseIndexManagerBase< Index, ParallelReuseIndexManager > C codi::ReuseIndexManagerBase< Index, ReuseIndexManager > C codi::InnerPrimalTapeStatementData Additional data required by an InnerStatementEvaluator C codi::InnerStatementEvaluatorStaticStore< Generator, Stmt > ► C codi::InternalAdjointsInterface< T_Gradient, T_Identifier, T_Tape > Abstracts the internal set of adjoint variables provided as part of the tape C codi::ThreadSafeGlobalAdjoints< Gradient, Identifier, Tape, OpenMPToolbox > C codi::LocalAdjoints< T_Gradient, T_Identifier, T_Tape > Adjoint variables owned by a tape instance C codi::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 ► C codi::InternalStatementRecordingTapeInterface< T_Identifier > Internal tape interface that is used by active types to trigger the storing of an expression C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack C codi::ReverseTapeInterface< T_Real, T_Gradient, T_Identifier > Minimum tape interface for a working reverse tape implementation ► C codi::InternalStatementRecordingTapeInterface< T_Gradient > C codi::ForwardEvaluation< T_Real, T_Gradient > Implementation of a tape-free forward AD mode through the internal expression interfaces ► C codi::InternalStatementRecordingTapeInterface< T_ImplTapeTypes::Identifier > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::ReverseTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier > ► C codi::InternalStatementRecordingTapeInterface< T_Tag > C codi::TagTapeForward< T_Real, T_Tag > Tape for tagging variables and find errors in the AD workflow ► C codi::InternalStatementRecordingTapeInterface< T_TapeTypes::Identifier > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::ReverseTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier > ► C codi::InternalStatementRecordingTapeInterface< TagData< T_Tag > > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::ReverseTapeInterface< T_Real, T_Real, TagData< T_Tag > > C codi::IoException IoException for CoDiPack C codi::RealTraits::IsTotalFinite< T_Type, typename > Function for checking if all values of the type are finite C codi::RealTraits::IsTotalFinite< T_Type, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > > Function for checking if all values of the type are finite. C codi::RealTraits::IsTotalZero< T_Type, typename > Function for checking if the value of the type is completely zero C codi::RealTraits::IsTotalZero< T_Type, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > > Function for checking if the value of the type is completely zero. C codi::JacobianConvertWrapper< T_Nested > Wrapper for JacboianInterfaces that requires a passive value conversion C codi::JacobianDelayAccessor< T_Issuer > C codi::JacobianExpression< size > Specialized for NumberOfActiveTypeArguments and NumberOfConstantTypeArguments ► C codi::JacobianInterface< T_T > General interface for Jacobian access in CoDiPack C codi::Jacobian< T_T, T_Store > C codi::Jacobian< PassiveReal > C codi::Jacobian< T_T, std::vector< T_T > > ► C codi::Jacobian< T_T, T_Store > Default implementation of the Jacobian interface C codi::JacobianCountNonZerosRow< Real > C codi::JacobianCountNonZerosRow< T_T, T_Store > Adds counting of nonzero entries ► C codi::JacobianInterface< DummyValue > C codi::DummyJacobian Dummy Jacobian . Has size zero and no logic in any call ► C codi::JacobianInterface< Real > C codi::Jacobian< Real, std::vector< Real > > ► C codi::LinearSystemInterface< T_InterfaceTypes > ► C codi::EigenLinearSystem< Number, Matrix, Vector > C EigenSolver< Number > [Function] ► C codi::LinearSystemInterface< EigenLinearSystemTypes< T_Type, T_Matrix, T_Vector > > ► C codi::EigenLinearSystem< T_Type, T_Matrix, T_Vector > C codi::SparseEigenLinearSystem< T_Type, T_Matrix, T_Vector > C codi::LinearSystemInterfaceTypes C codi::LinearSystemSolverHandler< T_LinearSystem, typename > C codi::LinearSystemSpecializationDetection< T_LinearSystem > C codi::Lock< T_Mutex > RAII mutex locking C codi::LockForRead< T_ReadWriteMutex > RAII lock for read. ´ C codi::LockForWrite< T_ReadWriteMutex > RAII lock for write C LowLevelFunction Indicator for generator C codi::LowLevelFunctionCreationUtilities< T_ActiveArguments > Helper structure for storing low level functions and their arguments on a tape C codi::LowLevelFunctionEntry< T_Tape, T_Real, T_Identifier > Low level function entry on the tape. See LowLevelFunctionTapeInterface for details ► C codi::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 C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::LowLevelFunctionTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::LowLevelFunctionTapeInterface< T_Real, T_Real, TagData< T_Tag > > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::LowLevelFunctionTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > ► C codi::ManualStatementPushTapeInterface< T_Real, T_Gradient, T_Identifier > Add derivative information for custom operations to the tape C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::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 C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::ManualStatementPushTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::ManualStatementPushTapeInterface< T_Real, T_Real, TagData< T_Tag > > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::PreaccumulationEvaluationTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::ManualStatementPushTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > ► C codi::PreaccumulationEvaluationTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::MappedAdjoints< T_Identifier, T_Gradient > Implementation of adjoints via a map C codi::MemberStore< T_Type, T_Parent, T_storeStatic > Defines a member that can either be static or local to the struct C codi::MemberStore< T_Type, T_Parent, true > Defines a member that can either be static or local to the struct. ► C codi::MutexInterface Abstracts a mutex C codi::OpenMPMutex Mutex implementation for OpenMP ► C codi::NodeInterface< T_Impl > Node side interface for the traversal of expressions C codi::ExpressionInterface< Real, StaticContextActiveType > C codi::ExpressionInterface< std::complex< T_InnerActive::Real >, T_Impl > C codi::ExpressionInterface< T_Tape::Real, T_Impl > C codi::ExpressionInterface< T_Real, T_Impl > Base class for all CoDiPack expressions ► C codi::NodeInterface< ActiveType< T_Tape > > C codi::ExpressionInterface< T_Tape::Real, ActiveType< T_Tape > > ► C codi::NodeInterface< ActiveTypeStatelessTape< T_Tape > > C codi::ExpressionInterface< T_Tape::Real, ActiveTypeStatelessTape< T_Tape > > ► C codi::NodeInterface< ActiveTypeWrapper< T_ActiveType > > C codi::ExpressionInterface< T_ActiveType::Real, ActiveTypeWrapper< T_ActiveType > > ► C codi::NodeInterface< ComputeExpression< T_Real, T_Operation, T_ArgExprs... > > C codi::ExpressionInterface< T_Real, ComputeExpression< T_Real, T_Operation, T_ArgExprs... > > ► C codi::NodeInterface< ConstantExpression< T_Real, ConstantDataConversion > > C codi::ExpressionInterface< T_Real, ConstantExpression< T_Real, ConstantDataConversion > > ► C codi::NodeInterface< ImmutableActiveType< T_ActiveType > > C codi::ExpressionInterface< T_ActiveType::Real, ImmutableActiveType< T_ActiveType > > ► C codi::NodeInterface< ParallelActiveType< T_Tape, T_ParallelToolbox > > C codi::ExpressionInterface< T_Tape::Real, ParallelActiveType< T_Tape, T_ParallelToolbox > > ► C codi::NodeInterface< ReferenceActiveType< T_Type > > C codi::ExpressionInterface< T_Type::Real, ReferenceActiveType< T_Type > > ► C codi::NodeInterface< ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > C codi::ExpressionInterface< std::complex< codi::ActiveType< T_Tape >::Real >, ResolveSelf< complex< codi::ActiveType< T_Tape > >, ActiveComplex< codi::ActiveType< T_Tape >, complex< codi::ActiveType< T_Tape > > > > > ► C codi::NodeInterface< StaticAggregatedActiveType< T_Real, T_InnerActiveType > > C codi::ExpressionInterface< T_Real, StaticAggregatedActiveType< T_Real, T_InnerActiveType > > ► C codi::NodeInterface< StaticContextActiveType< T_Tape > > C codi::ExpressionInterface< T_Tape::Real, StaticContextActiveType< T_Tape > > C codi::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 C codi::PassiveArgumentStoreTraits< T_T, T_S, typename > Traits for storing passive arguments in byte streams C codi::PointerStore< T_ChunkData > Inserts data pointers at the back of all arguments in the nested call hierarchy C codi::PointerStore< Chunk1< T_Data1 > > Pointer store for Chunk1 data C codi::PointerStore< Chunk2< T_Data1, T_Data2 > > Pointer store for Chunk2 data C codi::PointerStore< Chunk3< T_Data1, T_Data2, T_Data3 > > Pointer store for Chunk3 data C codi::PointerStore< Chunk4< T_Data1, T_Data2, T_Data3, T_Data4 > > Pointer store for Chunk4 data ► C codi::PositionalEvaluationTapeInterface< T_Position > Reverse AD evaluation for parts of a recorded tape ► C codi::ForwardEvaluationTapeInterface< T_Position > Forward AD evaluation of a recorded tape ► C codi::CustomAdjointVectorEvaluationTapeInterface< T_Position > Allows user defined vectors for the forward and adjoint evaluation, and for clearing adjoints C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack C codi::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 C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack C codi::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 ► C codi::PrimalEvaluationTapeInterface< T_Real, T_Identifier, T_Position > Perform a primal reevaluation of the tape C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::PositionalEvaluationTapeInterface< CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::ForwardEvaluationTapeInterface< CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::CustomAdjointVectorEvaluationTapeInterface< CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::PreaccumulationEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::PrimalEvaluationTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::PositionalEvaluationTapeInterface< CommonTapeTypes< T_TapeTypes >::Position > ► C codi::ForwardEvaluationTapeInterface< CommonTapeTypes< T_TapeTypes >::Position > ► C codi::CustomAdjointVectorEvaluationTapeInterface< CommonTapeTypes< T_TapeTypes >::Position > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::PreaccumulationEvaluationTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::PreaccumulationEvaluationTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > ► C codi::PrimalEvaluationTapeInterface< T_TapeTypes::Real, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > ► C codi::PositionalEvaluationTapeInterface< EmptyPosition > ► C codi::ForwardEvaluationTapeInterface< EmptyPosition > ► C codi::CustomAdjointVectorEvaluationTapeInterface< EmptyPosition > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::PreaccumulationEvaluationTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::PreaccumulationEvaluationTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::PrimalEvaluationTapeInterface< T_Real, TagData< T_Tag >, EmptyPosition > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::PreaccumulationHelper< T_Type, typename > Stores the Jacobian matrix for a code section C codi::PrimalTapeStatementFunctions Data required for all possible handle calls C codi::ReadWriteMutex< T_ThreadInformation, T_AtomicInt > Mutex construct that distinguishes between lock for read and lock for write ► C codi::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 C codi::FullTapeInterface< T_Real, T_Gradient, T_Identifier, T_Position > Full tape interface that supports all features of CoDiPack ► C codi::ReadWriteTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > C codi::FullTapeInterface< T_ImplTapeTypes::Real, T_ImplTapeTypes::Gradient, T_ImplTapeTypes::Identifier, CommonTapeTypes< T_ImplTapeTypes >::Position > ► C codi::ReadWriteTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > C codi::FullTapeInterface< T_Real, T_Real, TagData< T_Tag >, EmptyPosition > ► C codi::ReadWriteTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::FullTapeInterface< T_TapeTypes::Real, T_TapeTypes::Gradient, T_TapeTypes::Identifier, CommonTapeTypes< T_TapeTypes >::Position > C codi::ReduceToReal Placeholder to identify the operation on the Jacobian C codi::AtomicTraits::RemoveAtomicImpl< T_NotAtomic, typename > Convert an atomic type into the underlying type. Implementation C codi::AtomicTraits::RemoveAtomicImpl< Atomic, EnableIfAtomic< Atomic > > Specialization for atomic types ► C codi::ReverseAtomicInterface< T_Type, T_Impl > Provides a data type on which += update operations are performed atomically C codi::OpenMPReverseAtomicImpl< Type > ► C codi::ReverseAtomicInterface< T_Type, OpenMPReverseAtomicImpl< T_Type, void > > C codi::OpenMPReverseAtomicImpl< T_Type, T_Sfinae > Reverse atomic implementation for OpenMP C codi::Self C codi::JacobianStatementGenerator< T_TapeImpl, T_size >::StatementCallGenerator< type, Stmt > This structure is accessed by the StatementEvaluatorInterface . C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGenerator< type, Stmt > This structure is accessed by the StatementEvaluatorInterface . C codi::StatementEvaluatorInnerTapeInterface::StatementCallGenerator< type, Expr > This structure is accessed by the StatementEvaluatorInterface C codi::StatementEvaluatorTapeInterface::StatementCallGenerator< type, Expr > This structure is accessed by the StatementEvaluatorInterface C codi::JacobianStatementGenerator< T_TapeImpl, T_size >::StatementCallGenerator< StatementCall::Forward, Stmt > Forward implementation C codi::JacobianStatementGenerator< T_TapeImpl, T_size >::StatementCallGenerator< StatementCall::Primal, Stmt > Primal implementation C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGeneratorBase< Stmt, GenImpl > Base class for statement call generators. Prepares the static construction context ► C StatementCallGeneratorBase C codi::JacobianStatementGenerator< T_TapeImpl, T_size >::StatementCallGenerator< StatementCall::ClearAdjoints, Stmt > WriteInformation implementation C codi::JacobianStatementGenerator< T_TapeImpl, T_size >::StatementCallGenerator< StatementCall::ResetPrimals, Stmt > ResetPrimal implementation C codi::JacobianStatementGenerator< T_TapeImpl, T_size >::StatementCallGenerator< StatementCall::Reverse, Stmt > Reverse implementation C codi::JacobianStatementGenerator< T_TapeImpl, T_size >::StatementCallGenerator< StatementCall::WriteInformation, Stmt > WriteInformation implementation ► C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGeneratorBase< Stmt, StatementCallGenerator< StatementCall::ClearAdjoints, Stmt > > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGenerator< StatementCall::ClearAdjoints, Stmt > ClearAdjoints implementation ► C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGeneratorBase< Stmt, StatementCallGenerator< StatementCall::Forward, Stmt > > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGenerator< StatementCall::Forward, Stmt > Forward implementation ► C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGeneratorBase< Stmt, StatementCallGenerator< StatementCall::Primal, Stmt > > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGenerator< StatementCall::Primal, Stmt > Primal implementation ► C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGeneratorBase< Stmt, StatementCallGenerator< StatementCall::ResetPrimals, Stmt > > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGenerator< StatementCall::ResetPrimals, Stmt > ResetPrimal implementation ► C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGeneratorBase< Stmt, StatementCallGenerator< StatementCall::Reverse, Stmt > > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGenerator< StatementCall::Reverse, Stmt > Reverse implementation ► C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGeneratorBase< Stmt, StatementCallGenerator< StatementCall::WriteInformation, Stmt > > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementCallGenerator< StatementCall::WriteInformation, Stmt > WriteInformation implementation C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::StatementDataPointers Definition of the data for a statement. The pointers a populated from a byte data stream ► C codi::StatementEvaluatorInnerTapeInterface Tape side interface for StatementEvaluatorInterface C codi::PrimalValueBaseTape< T_TapeTypes, PrimalValueLinearTape< T_TapeTypes > > C codi::PrimalValueBaseTape< T_TapeTypes, PrimalValueReuseTape< T_TapeTypes > > C codi::JacobianStatementGenerator< T_TapeImpl, T_size > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl > Base class for all standard Primal value tape implementations ► C codi::StatementEvaluatorInterface Creation of handles for the evaluation of expressions in a context where the expression type is not available C codi::DirectStatementEvaluator Full evaluation of the expression in the function handle. Storing in static context C codi::InnerStatementEvaluator Expression evaluation in the inner function. Data loading in the compilation context of the tape. Storing in static context C codi::ReverseStatementEvaluator Only stores the function handle for the reverse evaluation ► C codi::StatementEvaluatorTapeInterface Tape side interface for StatementEvaluatorInterface C codi::PrimalValueBaseTape< T_TapeTypes, PrimalValueLinearTape< T_TapeTypes > > C codi::PrimalValueBaseTape< T_TapeTypes, PrimalValueReuseTape< T_TapeTypes > > C codi::JacobianStatementGenerator< T_TapeImpl, T_size > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl > Base class for all standard Primal value tape implementations C codi::StatementPushHelperBase< T_Type, T_Impl > Base class for manual statement pushes on the tape ► C codi::StatementPushHelperBase< T_Type, StatementPushHelper< T_Type > > C codi::StatementPushHelper< T_Type, typename > Add statements to the tape where the Jacobians are computed manually C codi::StatementSizes Define all static sizes of an Expression C codi::StaticDummy< Dummy > Static dummy objects for e.g. default reference arguments C codi::StaticThreadLocalPointerInterface< T_Type, T_Owner, T_Impl > Abstracts a static thread-local pointer ► C codi::StaticThreadLocalPointerInterface< T_Type, T_Owner, OpenMPStaticThreadLocalPointer< T_Type, T_Owner > > C codi::OpenMPStaticThreadLocalPointer< T_Type, T_Owner > Static thread-local pointers for OpenMP ► C codi::SynchronizationInterface Provides basic synchronization facilities C codi::DefaultSynchronization Default implementation of SynchronizationInterface for serial applications C codi::OpenMPSynchronization OpenMP synchronization facilities ► C T_Base C codi::TerminatingPointerStore< T_Base > C codi::TagData< T_Tag > Data for a tag C codi::TagTapeBase< T_Real, T_Tag, T_Gradient, T_Impl > Base implementation for tagging tapes ► C codi::TagTapeBase< T_Real, T_Tag, T_Real, TagTapeReverse< T_Real, T_Tag > > C codi::TagTapeReverse< T_Real, T_Tag > Tape for tagging variables and find errors in the AD workflow ► C codi::TagTapeBase< T_Real, T_Tag, TagData< T_Tag >, TagTapeForward< T_Real, T_Tag > > C codi::TagTapeForward< T_Real, T_Tag > Tape for tagging variables and find errors in the AD workflow C codi::TapeHelperBase< T_Type, T_Impl > A helper class that allows for a simpler access and management of a CoDiPack tape ► C codi::TapeHelperBase< T_Type, TapeHelperJacobi< T_Type > > C codi::TapeHelperJacobi< T_Type > ► C codi::TapeHelperBase< T_Type, TapeHelperNoImpl< T_Type > > C codi::TapeHelperNoImpl< T_Type > ► C codi::TapeHelperBase< T_Type, TapeHelperPrimal< T_Type > > C codi::TapeHelperPrimal< T_Type > ► C codi::TapeHelperBase< Type, TapeHelperNoImpl< Type > > ► C codi::TapeHelperNoImpl< Type > C codi::TapeHelper< Type, typename > See TapeHelperBase ► C codi::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 C codi::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 C codi::RealTraits::TapeRegistration< T_Type, typename > Tape registration methods for aggregated types that contain CoDiPack active types C codi::TagTapeForward< T_Real, T_Tag >::TapeTypes Required definition for event system C codi::TagTapeReverse< T_Real, T_Tag >::TapeTypes Required definition for event system ► C codi::TapeTypesInterface Interface for the definition of tape types C codi::JacobianTapeTypes< T_Real, T_Gradient, T_IndexManager, T_Data, T_Adjoints > Type definitions for the Jacobian tapes C codi::PrimalValueTapeTypes< T_Real, T_Gradient, T_IndexManager, T_StatementEvaluator, T_Data > Type definitions for the primal value tapes C codi::TapeValues Tape information that can be printed in a pretty print format or a table format ► C codi::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 C codi::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 C codi::TemporaryMemory Allocator for temporary used memory ► C codi::ThreadInformationInterface Provides information on threads C codi::DefaultThreadInformation Default implementation of ThreadInformationInterface for serial applications C codi::OpenMPThreadInformation Thread information for OpenMP C codi::GradientTraits::TraitsImplementation< T_Gradient, typename > Common traits for all types used as gradients C codi::RealTraits::TraitsImplementation< T_Type, typename > Common traits for all types used as real values C codi::ComputationTraits::TransposeImpl< T_Jacobian, typename > Perform ► C codi::TraversalLogic< T_Impl > Traversal of CoDiPack expressions C codi::ForEachLeafLogic< T_Impl > Implement logic for leaf nodes only C codi::JacobianComputationLogic< T_Impl > ► C codi::TraversalLogic< CountActiveArguments > ► C codi::ForEachLeafLogic< CountActiveArguments > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::CountActiveArguments Count all arguments that have non-zero index ► C codi::TraversalLogic< IncrementForwardLogic > ► C codi::JacobianComputationLogic< IncrementForwardLogic > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::IncrementForwardLogic Perform the adjoint update based on the configuration in codi::Config::VariableAdjointInterfaceInPrimalTapes ► C codi::TraversalLogic< IncrementReversalLogic > ► C codi::JacobianComputationLogic< IncrementReversalLogic > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::IncrementReversalLogic Perform the adjoint update based on the configuration in codi::Config::VariableAdjointInterfaceInPrimalTapes ► C codi::TraversalLogic< JacobianExtractionLogic > ► C codi::JacobianComputationLogic< JacobianExtractionLogic > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::JacobianExtractionLogic Computes Jacobian entries for the event system ► C codi::TraversalLogic< LocalReverseLogic > C codi::JacobianComputationLogic< LocalReverseLogic > ► C codi::TraversalLogic< MathStatementGenLogic< Identifier > > ► C codi::ForEachLeafLogic< MathStatementGenLogic< Identifier > > C codi::MathStatementGenLogic< Identifier > Creates a math representation from a given rhs in the form of a string ► C codi::TraversalLogic< PushDelayedJacobianLogic > ► C codi::ForEachLeafLogic< PushDelayedJacobianLogic > C codi::JacobianBaseTape< T_TapeTypes, T_Impl >::PushDelayedJacobianLogic Pushes all delayed Jacobians ► C codi::TraversalLogic< PushIdentifierPassiveAndConstant > ► C codi::ForEachLeafLogic< PushIdentifierPassiveAndConstant > C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::PushIdentifierPassiveAndConstant Push all data for each argument ► C codi::TraversalLogic< PushJacobianLogic > ► C codi::JacobianComputationLogic< PushJacobianLogic > C codi::JacobianBaseTape< T_TapeTypes, T_Impl >::PushJacobianLogic Pushes Jacobians and indices to the tape ► C codi::TraversalLogic< ValidateTags > ► C codi::ForEachLeafLogic< ValidateTags > C codi::TagTapeBase< T_Real, T_Tag, T_Gradient, T_Impl >::ValidateTags Looks at the tags for the expression ► C std::true_type C codi::AtomicTraits::IsAtomic< OpenMPAtomic< T_Type > > Declare OpenMPAtomic to be atomic in terms of AtomicTraits C codi::AtomicTraits::IsAtomic< OpenMPReverseAtomic< T_Type > > Declare OpenMPAtomic to be atomic in terms of AtomicTraits C codi::TupleMemoryBase< Ids, Ts > Base for tuple implementation see TupleMemory for details ► C codi::TupleMemoryBase< std::make_index_sequence< sizeof...(Ts)>, Ts... > C codi::TupleMemory< typename T_ArgExprs::StoreAs... > C codi::TupleMemory< Ts > Tuple implementation which allows to force inline of the construction of the tuple C codi::TupleMemoryLeaf< i, T > Leaf for tuple implementation see TupleMemory for details ► C codi::TupleMemoryLeaf< Ids, Ts > C codi::TupleMemoryBase< std::integer_sequence< size_t, Ids... >, Ts... > Base for tuple implementation see TupleMemory for details C codi::ComputationTraits::UpdateImpl< T_Lhs, T_Rhs, typename > Perform the operation lhs += rhs. Default logic uses operator += C codi::ExpressionTraits::ValidateADLogicImpl< Logic > Validates if the AD logic of an arbitrary amount of expressions are the same or compatible. void results are interpreted as the AD logic of a constant expression C codi::ExpressionTraits::ValidateADLogicImpl< Logic > Validation for one arguments just defines the input logic as the valid one C codi::ExpressionTraits::ValidateADLogicImpl< LogicA, LogicB > Validation for two arguments. Validates if one of the two is void or both are the same C codi::ExpressionTraits::ValidateADLogicImpl< LogicA, LogicOther... > Validation for an arbitrary number of arguments. Gets the logic of the remainder and validates this with LogicA C codi::ValidationIndicator< Real, Tag > Helper class for statement validation ► C codi::VectorAccessInterface< T_Real, T_Identifier > Unified access to the adjoint vector and primal vector in a tape evaluation ► C codi::AdjointVectorAccess< T_Real, T_Identifier, T_AdjointVector > Implementation of VectorAccessInterface for adjoint vectors C codi::PrimalAdjointVectorAccess< T_Real, T_Identifier, T_AdjointVector > Implementation of VectorAccessInterface for adjoint and primal vectors ► C codi::VectorAccessInterface< int, int > C codi::AggregatedTypeVectorAccessWrapper< Type > C codi::AggregatedTypeVectorAccessWrapper< T_Type, RealTraits::EnableIfAggregatedActiveType< T_Type > > C codi::AggregatedTypeVectorAccessWrapper< T_Type, typename > Generalized wrapper of the VectorAccessInterface for aggregated data types, e.g. std::complex<codi::RealReverse> ► C codi::VectorAccessInterface< Real, Identifier > ► C codi::AdjointVectorAccess< Real, Identifier, AdjointVector > C codi::PrimalAdjointVectorAccess< Real, Identifier, AdjointVector > C codi::AdjointVectorAccess< Real, Identifier, Gradient * > C codi::Warning C codi::JacobianBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluateForward_EvalStatements< TT > Wrapper helper for improved compiler optimizations C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluateForward_EvalStatements Additional wrapper that triggers compiler optimizations C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluatePrimal_EvalStatements Wrapper helper for improved compiler optimizations C codi::JacobianBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluateReverse_EvalStatements< TT > Wrapper helper for improved compiler optimizations C codi::PrimalValueBaseTape< T_TapeTypes, T_Impl >::Wrap_internalEvaluateReverse_EvalStatements Additional wrapper that triggers compiler optimizations C codi::WriteInfo This class is used during the writing process of a primal value tape. The WriteInfo is returned by StatementEvaluator call with StatementCall::WriteInformation
1.13.2