|
CoDiPack
3.0.0
A Code Differentiation Package
|
|
|
CoDiPack
3.0.0
A Code Differentiation Package
|
|
CoDiPack - Code Differentiation Package. More...
Namespaces | |
| namespace | AdjointVectorTraits |
| General traits of adjoint vectors. | |
| namespace | AtomicTraits |
| Traits for atomic types. | |
| namespace | Config |
| Configuration options for CoDiPack. | |
| namespace | EventHints |
| namespace | ExpressionTraits |
| Traits for everything that can be an expression e.g. codi::RealReverse, a + b, etc.. | |
| namespace | GradientTraits |
| namespace | InternalAdjointVectorTraits |
| Traits for the internal adjoint variables maintained by the tape. | |
| namespace | RealTraits |
| Traits for values that can be used as real values, e.g. double, float, codi::RealReverse etc.. | |
| namespace | TapeTraits |
Classes | |
| struct | ActiveArgumentPointerStore |
| Declares all variables that may be needed to store/restore an active argument which has a pointer type. More... | |
| struct | ActiveArgumentStoreInterface |
| 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. More... | |
| struct | ActiveArgumentStoreTraits |
| Traits for storing active arguments in byte streams. More... | |
| struct | ActiveArgumentValueStore |
| Declares all variables that may be needed to store/restore an active argument which has a value type. More... | |
| struct | ActiveComplex |
| struct | ActiveType |
| Represents a concrete lvalue in the CoDiPack expression tree. More... | |
| struct | ActiveTypeBase |
| Represents the base implementation concrete lvalue in the CoDiPack expression tree. More... | |
| struct | ActiveTypeStatelessTape |
| Represents a concrete lvalue in the CoDiPack expression tree. More... | |
| struct | ActiveTypeWrapper |
| Creates a pseudo active type from data references. Can be used to overlay existing data with active types. More... | |
| struct | AdjointVectorAccess |
| Implementation of VectorAccessInterface for adjoint vectors. More... | |
| struct | AdjointVectorWithOffset |
| Implementation of vector-based adjoints that take into account an offset when addressing into the vector. More... | |
| struct | AggregatedActiveType |
| Represents a concrete aggregated lvalue int the CoDiPack expression tree. More... | |
| struct | AggregatedActiveTypeBase |
| Defines an aggregated type via an array and implements the ExpressionInterface. More... | |
| struct | AggregatedTypeVectorAccessWrapper |
| Generalized wrapper of the VectorAccessInterface for aggregated data types, e.g. std::complex<codi::RealReverse>. More... | |
| struct | AggregatedTypeVectorAccessWrapper< T_Type, RealTraits::EnableIfAggregatedActiveType< T_Type > > |
| struct | AggregatedTypeVectorAccessWrapperFactory |
| Factory for the creation of AggregatedTypeVectorAccessWrapper instances. More... | |
| struct | Algorithms |
| Basic algorithms for tape evaluation in CoDiPack. More... | |
| struct | ArrayAccessExpressionImpl |
| struct | ArrayPosition |
| Position with one index for e.g. array access. More... | |
| struct | AssignmentOperators |
| Provides assignment operators for LhsExpressionInterface implementations. More... | |
| struct | AssignmentOperatorsPassiveJacobianOptimization |
| Default implementations for the passive += and -= operators. More... | |
| struct | AssignmentOperatorsPassiveJacobianOptimization< T_Real, true, T_Impl > |
| Optimized Jacobian implementations for the passive += and -= operators. More... | |
| struct | AssignStatement |
| struct | AtomicInterface |
| Provides a data type on which all operations are performed atomically. More... | |
| struct | BinaryJacobianOperation |
| Implements BinaryOperation for functions where the gradients can be computed and transposed. More... | |
| struct | BinaryOperation |
| Implements ComputeOperation for two arguments. More... | |
| struct | BlockData |
| Data is stored in one contiguous block in this DataInterface implementation. More... | |
| struct | ByteDataView |
| struct | Chunk1 |
| struct | Chunk2 |
| struct | Chunk3 |
| struct | Chunk4 |
| struct | ChunkBase |
| A chunk stores a contiguous block of data in CoDiPack. More... | |
| struct | ChunkedData |
| Data is stored chunk-wise in this DataInterface implementation. If a chunk runs out of space, a new chunk is allocated. More... | |
| struct | ChunkPosition |
| Position with two indices for e.g. chunked data access. More... | |
| struct | CODI_UNION< First > |
| Creates a union of interface definitions. More... | |
| struct | CoDiMpiTypes |
| MPI datatype implementation for CoDipack types in the type wrapper of MeDiPack. More... | |
| struct | CommonBaseTapeReader |
Used to restore the IO from the "filename"IO.dat or "filename"IO.txt files. Also provides the get methods from the codi::tapeReaderInterface. More... | |
| struct | CommonBaseTapeWriter |
| 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. More... | |
| struct | CommonReaderWriterMethods |
| Used to implement methods common to both the tape readers and the tape writers. More... | |
| struct | CommonTapeImplementation |
| Implementation of all common tape functionality. More... | |
| struct | CommonTapeTypes |
| Declares all types used in the CommonTapeImplementation. More... | |
| struct | CommonTextTapeWriter |
| This base class is used to modify the math representation of a statement. More... | |
| struct | CompileTimeLoop |
| Compile time loop evaluation. More... | |
| struct | CompileTimeLoop< T_pos, T_pos, T_step > |
| Termination of loop evaluation. More... | |
| struct | CompileTimeTraversalLogic |
| Traversal of CoDiPack expressions during compile time. More... | |
| struct | ComputeExpression |
| Represents an operator or function with an arbitrary number of arguments in the expression tree. More... | |
| struct | ComputeOperation |
| Interface for implementing the logic for a ComputeExpression. More... | |
| struct | ConstantDataConversion |
| struct | ConstantExpression |
| Represents constant values in the expression tree. More... | |
| struct | ConstructStaticContextLogic |
| Helper class for the construction of an expression in a different context. More... | |
| struct | ConstructVectorImpl |
| struct | ConstructVectorImpl< std::array< T_T, T_n > > |
| struct | CustomAdjointVectorEvaluationTapeInterface |
| Allows user defined vectors for the forward and adjoint evaluation, and for clearing adjoints. More... | |
| struct | CustomAdjointVectorHelper |
| Allows for an arbitrary adjoint evaluation of a recorded tape. More... | |
| struct | CustomAdjointVectorInterface |
| General interface for an arbitrary adjoint evaluation. More... | |
| struct | DataInterface |
| Data stream interface for tape data. Encapsulates data that is written e.g. for each statement or argument. More... | |
| struct | DataManagementTapeInterface |
| Provides file IO, information about internal tape vectors and allows to clear tape data. More... | |
| struct | DefaultSynchronization |
| Default implementation of SynchronizationInterface for serial applications. More... | |
| struct | DefaultThreadInformation |
| Default implementation of ThreadInformationInterface for serial applications. More... | |
| struct | DerivativeAccess |
| A helper class for the access of the various derivatives in higher order AD types. More... | |
| struct | Direction |
| Fixed size vector mode implementation. More... | |
| struct | DirectStatementEvaluator |
| Full evaluation of the expression in the function handle. Storing in static context. More... | |
| struct | DirectStatementEvaluatorStaticStore |
| struct | DummyHessian |
| Dummy Hessian. Has size zero and no logic in any call. More... | |
| struct | DummyJacobian |
| Dummy Jacobian. Has size zero and no logic in any call. More... | |
| struct | DummyValue |
| Dummy value that can be assigned. More... | |
| struct | DummyVector |
| Dummy vector that provides a dummy element access and size function. More... | |
| struct | DuplicateJacobianRemover |
| Combines entries of Jacobians with the same identifier. More... | |
| struct | EditingTapeInterface |
| Edit tapes after they have been recorded. More... | |
| struct | EigenLinearSystem |
| struct | EigenLinearSystemTypes |
| Eigen definition for the LinearSystemInterfaceTypes. More... | |
| struct | EmptyData |
| No data is stored in this DataInterface implementation. It is used to terminate the recursive nature of the DataInterface design. More... | |
| struct | EmptyPosition |
| Empty Position with no nested data. More... | |
| struct | EnumBitset |
| A bitset with enum items as flags. More... | |
| struct | EnzymeExternalFunctionHelper |
| Helper class for the implementation of an external function with Enzyme in CoDiPack. More... | |
| struct | EvaluationHandle |
| See EvaluationHandleBase. More... | |
| struct | EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfForwardTape< typename T_Type::Tape > > |
| See EvaluationHandleForward. More... | |
| struct | EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfJacobianTape< typename T_Type::Tape > > |
| See EvaluationHandleReverseJacobianTapes. More... | |
| struct | EvaluationHandle< T_Func, T_Type, T_InputStore, T_OutputStore, TapeTraits::EnableIfPrimalValueTape< typename T_Type::Tape > > |
| See EvaluationHandleReversePrimalValueTapes. More... | |
| struct | EvaluationHandleBase |
| Basic interface and data storage for all EvaluationHandle implementations. More... | |
| struct | EvaluationHandleForward |
| struct | EvaluationHandleReverseBase |
| Implementation for reverse mode CoDiPack types of EvaluationHandleBase. More... | |
| struct | EvaluationHandleReverseJacobianTapes |
| Implementation for Jacobian reverse mode CoDiPack types of EvaluationHandleBase. More... | |
| struct | EvaluationHandleReversePrimalValueTapes |
| Implementation of EvaluationHandleBase for primal value reverse mode CoDiPack types. More... | |
| struct | EvaluationHelper |
| Evaluate the primal, Jacobian and Hessian of function objects. More... | |
| struct | EventSystem |
| Full EventSystem implementation for reverse tapes. More... | |
| struct | EventSystem< ForwardEvaluation< Real, Gradient > > |
| Specialization for ForwardEvaluation. More... | |
| struct | EventSystemBase |
| Base class for the CoDiPack event system. More... | |
| struct | ExpressionInterface |
| Base class for all CoDiPack expressions. More... | |
| struct | ExpressionMemberOperations |
| struct | ExpressionMemberOperations< T_Real, T_Impl, typename std::enable_if< std::is_same< T_Real, std::complex< typename T_Real::value_type > >::value >::type > |
| struct | ExpressionMemberOperations< Vector4, Impl > |
| struct | ExternalFunction |
| User-defined evaluation functions for the taping process. More... | |
| struct | ExternalFunctionHelper |
| Helper class for the implementation of an external function in CoDiPack. More... | |
| struct | ExternalFunctionInternalData |
| Internal untyped data for an external function. More... | |
| struct | ExternalFunctionLowLevelEntryMapper |
| Low level function entry implementation for external functions. More... | |
| struct | ExternalFunctionTapeInterface |
| Add user defined functions to the tape evaluation. More... | |
| struct | ExternalFunctionUserData |
| Ease of access structure for user-provided data on the tape for external functions. See ExternalFunctionTapeInterface. More... | |
| struct | ExtFunc_matrixMatrixMultiplication |
| Low level function generation for matrixMatrixMultiplication. More... | |
| struct | FileIo |
| Helper structure for writing binary data. More... | |
| struct | ForEachLeafLogic |
| Implement logic for leaf nodes only. More... | |
| struct | ForwardEvaluation |
| Implementation of a tape-free forward AD mode through the internal expression interfaces. More... | |
| struct | ForwardEvaluationTapeInterface |
| Forward AD evaluation of a recorded tape. More... | |
| struct | FullTapeInterface |
| Full tape interface that supports all features of CoDiPack. More... | |
| struct | GradientAccessTapeInterface |
| Allow for a direct access to the gradient information computed by the tape. More... | |
| struct | Hessian |
| Default implementation of the Hessian interface. More... | |
| struct | HessianInterface |
| General interface for Hessian access in CoDiPack. More... | |
| struct | IdentifierInformationTapeInterface |
| General information about the identifiers and checks if variables are active. More... | |
| struct | ImmutableActiveType |
| Creates a pseudo active type from a data value. Can be used to overlay existing data with immutable active types. More... | |
| struct | IncrementOperators |
| Implementation of increment operators for LhsExpressionInterface implementations. More... | |
| struct | IndexManagerInterface |
| Indices enable the mapping of primal values to their adjoint counterparts. More... | |
| struct | InnerPrimalTapeStatementData |
| Additional data required by an InnerStatementEvaluator. More... | |
| struct | InnerStatementEvaluator |
| Expression evaluation in the inner function. Data loading in the compilation context of the tape. Storing in static context. More... | |
| struct | InnerStatementEvaluatorStaticStore |
| struct | InternalAdjointsInterface |
| Abstracts the internal set of adjoint variables provided as part of the tape. More... | |
| struct | InternalStatementRecordingTapeInterface |
| Internal tape interface that is used by active types to trigger the storing of an expression. More... | |
| struct | IoException |
| IoException for CoDiPack. More... | |
| struct | Jacobian |
| Default implementation of the Jacobian interface. More... | |
| struct | JacobianBaseTape |
| Base class for all standard Jacobian tape implementations. More... | |
| struct | JacobianBaseTapeReader |
| Used to register a statement for a Jacobian tape. More... | |
| struct | JacobianBinaryTapeReader |
| Reads and restores a binary file for a Jacobian tape. More... | |
| struct | JacobianBinaryTapeWriter |
| Writes a Jacobian tape in a binary format. More... | |
| struct | JacobianComputationLogic |
| struct | JacobianConvertWrapper |
| Wrapper for JacboianInterfaces that requires a passive value conversion. More... | |
| struct | JacobianCountNonZerosRow |
| Adds counting of nonzero entries. More... | |
| struct | JacobianDelayAccessor |
| struct | JacobianExpression |
| Specialized for NumberOfActiveTypeArguments and NumberOfConstantTypeArguments. More... | |
| struct | JacobianGraphTapeWriter |
| Generates a graphical .dot file for a Jacobian tape. More... | |
| struct | JacobianInterface |
| General interface for Jacobian access in CoDiPack. More... | |
| struct | JacobianLinearTape |
| Final implementation for a Jacobian tape with a linear index management. More... | |
| struct | JacobianReuseTape |
| Final implementation for a Jacobian tape with a reuse index management. More... | |
| struct | JacobianStatementGenerator |
| struct | JacobianTapeTypes |
| Type definitions for the Jacobian tapes. More... | |
| struct | JacobianTextTapeReader |
| Reads and restores a text file for a Jacobian tape. More... | |
| struct | JacobianTextTapeWriter |
| Writes a Jacobian tape in a text format. More... | |
| struct | LhsExpressionInterface |
| Base class for all CoDiPack lvalue expression. More... | |
| struct | LinearIndexManager |
| Identifiers are created in a linear fashion. Each assign creates a new index which is counted up. More... | |
| struct | LinearSystemInterface |
| struct | LinearSystemInterfaceTypes |
| struct | LinearSystemSolverHandler |
| struct | LinearSystemSpecializationDetection |
| struct | LocalAdjoints |
| Adjoint variables owned by a tape instance. More... | |
| struct | Lock |
| RAII mutex locking. More... | |
| struct | LockForRead |
| RAII lock for read. ´ More... | |
| struct | LockForWrite |
| RAII lock for write. More... | |
| struct | LowLevelFunctionCreationUtilities |
| Helper structure for storing low level functions and their arguments on a tape. More... | |
| struct | LowLevelFunctionEntry |
| Low level function entry on the tape. See LowLevelFunctionTapeInterface for details. More... | |
| struct | LowLevelFunctionTapeInterface |
| Add functions with custom derivatives to the tape. Can, e.g, be used to optimize small recurring functions like matrix matrix multiplication. More... | |
| struct | ManualStatementPushTapeInterface |
| Add derivative information for custom operations to the tape. More... | |
| struct | MappedAdjoints |
| Implementation of adjoints via a map. More... | |
| struct | MathRepWriter |
| Generates a file with the math representation for each of the statements. More... | |
| struct | MathStatementGenLogic |
| Creates a math representation from a given rhs in the form of a string. More... | |
| struct | MemberStore |
| Defines a member that can either be static or local to the struct. More... | |
| struct | MemberStore< T_Type, T_Parent, true > |
| Defines a member that can either be static or local to the struct. More... | |
| struct | MultiUseIndexManager |
| Extends the ReuseIndexManager with a copy optimization. More... | |
| struct | MutexInterface |
| Abstracts a mutex. More... | |
| struct | Namespace |
| CoDiPack - Code Differentiation Package. | |
| struct | NodeInterface |
| Node side interface for the traversal of expressions. More... | |
| struct | OpenMPAtomicImpl |
| Atomic implementation for OpenMP. More... | |
| struct | OpenMPMutex |
| Mutex implementation for OpenMP. More... | |
| struct | OpenMPReverseAtomicImpl |
| Reverse atomic implementation for OpenMP. More... | |
| struct | OpenMPStaticThreadLocalPointer |
| Static thread-local pointers for OpenMP. More... | |
| struct | OpenMPSynchronization |
| OpenMP synchronization facilities. More... | |
| struct | OpenMPThreadInformation |
| Thread information for OpenMP. More... | |
| struct | OperationAbs |
| UnaryJacobianOperation implementation for abs. More... | |
| struct | OperationAcos |
| UnaryJacobianOperation implementation for acos. More... | |
| struct | OperationAcosh |
| UnaryJacobianOperation implementation for acosh. More... | |
| struct | OperationAdd |
| BinaryJacobianOperation implementation for operator +. More... | |
| struct | OperationAsin |
| UnaryJacobianOperation implementation for asin. More... | |
| struct | OperationAsinh |
| UnaryJacobianOperation implementation for asinh. More... | |
| struct | OperationAtan |
| UnaryJacobianOperation implementation for atan. More... | |
| struct | OperationAtan2 |
| BinaryJacobianOperation implementation for atan2. More... | |
| struct | OperationAtanh |
| UnaryJacobianOperation implementation for atanh. More... | |
| struct | OperationCbrt |
| UnaryJacobianOperation implementation for cbrt. More... | |
| struct | OperationComplexAbs |
| UnaryJacobianOperation implementation for complex abs. More... | |
| struct | OperationComplexArg |
| UnaryJacobianOperation implementation for complex arg. More... | |
| struct | OperationComplexConj |
| UnaryJacobianOperation implementation for complex conj. More... | |
| struct | OperationComplexImag |
| UnaryJacobianOperation implementation for complex imag. More... | |
| struct | OperationComplexNorm |
| UnaryJacobianOperation implementation for complex real. More... | |
| struct | OperationComplexPolar |
| BinaryJacobianOperation specialization for complex polar. More... | |
| struct | OperationComplexProj |
| UnaryJacobianOperation implementation for complex proj. More... | |
| struct | OperationComplexReal |
| UnaryJacobianOperation implementation for complex real. More... | |
| struct | OperationCopysign |
| BinaryJacobianOperation implementation for copysign. More... | |
| struct | OperationCos |
| UnaryJacobianOperation implementation for cos. More... | |
| struct | OperationCosh |
| UnaryJacobianOperation implementation for cosh. More... | |
| struct | OperationDivide |
| BinaryJacobianOperation implementation for operator /. More... | |
| struct | OperationErf |
| UnaryJacobianOperation implementation for erf. More... | |
| struct | OperationErfc |
| UnaryJacobianOperation implementation for erfc. More... | |
| struct | OperationExp |
| UnaryJacobianOperation implementation for exp. More... | |
| struct | OperationFmod |
| BinaryJacobianOperation implementation for fmod. More... | |
| struct | OperationFrexp |
| BinaryJacobianOperation implementation for frexp. More... | |
| struct | OperationHypot |
| BinaryJacobianOperation implementation for hypot. More... | |
| struct | OperationLdexp |
| BinaryJacobianOperation implementation for ldexp. More... | |
| struct | OperationLog |
| UnaryJacobianOperation implementation for log. More... | |
| struct | OperationLog10 |
| UnaryJacobianOperation implementation for log10. More... | |
| struct | OperationLog1p |
| UnaryJacobianOperation implementation for log1p. More... | |
| struct | OperationLog2 |
| UnaryJacobianOperation implementation for log2. More... | |
| struct | OperationMax |
| BinaryJacobianOperation implementation for max. More... | |
| struct | OperationMin |
| BinaryJacobianOperation implementation for min. More... | |
| struct | OperationMultiply |
| BinaryJacobianOperation implementation for operator *. More... | |
| struct | OperationPow |
| BinaryJacobianOperation implementation for pow. More... | |
| struct | OperationPow< std::complex< T_Real > > |
| BinaryJacobianOperation specialization for complex pow. More... | |
| struct | OperationRealToComplexCast |
| Returns a proxy object for the gradient that implements the operation in the multiplication of the proxy. More... | |
| struct | OperationRemainder |
| struct | OperationSin |
| UnaryJacobianOperation implementation for sin. More... | |
| struct | OperationSinh |
| UnaryJacobianOperation implementation for sinh. More... | |
| struct | OperationSqrt |
| UnaryJacobianOperation implementation for sqrt. More... | |
| struct | OperationSubstract |
| BinaryJacobianOperation implementation for operator -. More... | |
| struct | OperationTan |
| UnaryJacobianOperation implementation for tan. More... | |
| struct | OperationTanh |
| UnaryJacobianOperation implementation for tanh. More... | |
| struct | OperationTgamma |
| UnaryJacobianOperation implementation for tgamma. More... | |
| struct | OperationUnaryMinus |
| UnaryJacobianOperation implementation for operator -. More... | |
| struct | ParallelActiveType |
| Represents a concrete lvalue in the CoDiPack expression tree. More... | |
| struct | ParallelReuseIndexManager |
| Reuse index manager with a one-to-one relation between tapes and index manager. More... | |
| struct | ParallelToolbox |
| Collects parallel programming facilties required to make CoDiPack applicable in a shared memory parallel environment. More... | |
| struct | PassiveArgumentStoreTraits |
| Traits for storing passive arguments in byte streams. More... | |
| struct | PointerStore |
| Inserts data pointers at the back of all arguments in the nested call hierarchy. More... | |
| struct | PointerStore< Chunk1< T_Data1 > > |
| Pointer store for Chunk1 data. More... | |
| struct | PointerStore< Chunk2< T_Data1, T_Data2 > > |
| Pointer store for Chunk2 data. More... | |
| struct | PointerStore< Chunk3< T_Data1, T_Data2, T_Data3 > > |
| Pointer store for Chunk3 data. More... | |
| struct | PointerStore< Chunk4< T_Data1, T_Data2, T_Data3, T_Data4 > > |
| Pointer store for Chunk4 data. More... | |
| struct | PositionalEvaluationTapeInterface |
| Reverse AD evaluation for parts of a recorded tape. More... | |
| struct | PreaccumulationEvaluationTapeInterface |
| Perform tape evaluations but ensure that the state prior to evaluation equals the state after evaluation. More... | |
| struct | PreaccumulationHelper |
| Stores the Jacobian matrix for a code section. More... | |
| struct | PrimalAdjointVectorAccess |
| Implementation of VectorAccessInterface for adjoint and primal vectors. More... | |
| struct | PrimalBaseTapeWriter |
| This base class is used to implement the automatic generation of the .hpp file that restores the evaluation handles in the reading process. More... | |
| struct | PrimalBinaryTapeReader |
| Reads and restores a binary file for a Primal tape. More... | |
| struct | PrimalBinaryTapeWriter |
| Writes a primal value tape in a binary format. More... | |
| struct | PrimalEvaluationTapeInterface |
| Perform a primal reevaluation of the tape. More... | |
| struct | PrimalGraphTapeWriter |
| Generates a graphical .dot file for a primal value tape. The writer adds the math representation of statements into the node labels. More... | |
| struct | PrimalTapeStatementFunctions |
| Data required for all possible handle calls. More... | |
| struct | PrimalTextTapeReader |
| Reads and restores a text file for a primal value tape. More... | |
| struct | PrimalTextTapeWriter |
| Writes a primal value tape in a text format. More... | |
| struct | PrimalValueBaseTape |
| Base class for all standard Primal value tape implementations. More... | |
| struct | PrimalValueLinearTape |
| Final implementation for a primal value tape with a linear index management. More... | |
| struct | PrimalValueReuseTape |
| Final implementation for a primal value tape with a reuse index management. More... | |
| struct | PrimalValueTapeTypes |
| Type definitions for the primal value tapes. More... | |
| struct | ReadWriteMutex |
| Mutex construct that distinguishes between lock for read and lock for write. More... | |
| struct | ReadWriteTapeInterface |
| 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. More... | |
| struct | ReduceToReal |
| Placeholder to identify the operation on the Jacobian. More... | |
| struct | ReferenceActiveType |
| Holds a reference to an ActiveType for manual optimization of common arguments. More... | |
| struct | ReuseIndexManager |
| Reuse index manager with a many-to-one relation between tapes and index manager. More... | |
| struct | ReuseIndexManagerBase |
| Identifiers are reused. Freed identifiers are assigned to new variables. Variables keep their indices as long as they are active. More... | |
| struct | ReverseAtomicInterface |
| Provides a data type on which += update operations are performed atomically. More... | |
| struct | ReverseStatementEvaluator |
| Only stores the function handle for the reverse evaluation. More... | |
| struct | ReverseTapeInterface |
| Minimum tape interface for a working reverse tape implementation. More... | |
| struct | Self |
| struct | SparseEigenLinearSystem |
| struct | StatementEvaluatorInnerTapeInterface |
| Tape side interface for StatementEvaluatorInterface. More... | |
| struct | StatementEvaluatorInterface |
| Creation of handles for the evaluation of expressions in a context where the expression type is not available. More... | |
| struct | StatementEvaluatorTapeInterface |
| Tape side interface for StatementEvaluatorInterface. More... | |
| struct | StatementPushHelper |
| Add statements to the tape where the Jacobians are computed manually. More... | |
| struct | StatementPushHelperBase |
| Base class for manual statement pushes on the tape. More... | |
| struct | StatementSizes |
| Define all static sizes of an Expression. More... | |
| struct | StaticAggregatedActiveType |
| Static context implementation of the aggregated active type. More... | |
| struct | StaticContextActiveType |
| Replacement type of LhsExpressionInterface types in ConstructStaticContext. More... | |
| struct | StaticDummy |
| Static dummy objects for e.g. default reference arguments. More... | |
| struct | StaticThreadLocalPointerInterface |
| Abstracts a static thread-local pointer. More... | |
| struct | SynchronizationInterface |
| Provides basic synchronization facilities. More... | |
| struct | TagData |
| Data for a tag. More... | |
| struct | TagTapeBase |
| Base implementation for tagging tapes. More... | |
| struct | TagTapeForward |
| Tape for tagging variables and find errors in the AD workflow. More... | |
| struct | TagTapeReverse |
| Tape for tagging variables and find errors in the AD workflow. More... | |
| struct | TapeHelper |
| See TapeHelperBase. More... | |
| struct | TapeHelperBase |
| A helper class that allows for a simpler access and management of a CoDiPack tape. More... | |
| struct | TapeHelperJacobi |
| struct | TapeHelperNoImpl |
| struct | TapeHelperPrimal |
| struct | TapeReaderInterface |
| 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. More... | |
| struct | TapeTypesInterface |
| Interface for the definition of tape types. More... | |
| struct | TapeValues |
| Tape information that can be printed in a pretty print format or a table format. More... | |
| struct | TapeWriterInterface |
| 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. More... | |
| struct | TemporaryMemory |
| Allocator for temporary used memory. More... | |
| struct | TerminatingPointerStore |
| struct | ThreadInformationInterface |
| Provides information on threads. More... | |
| struct | ThreadSafeGlobalAdjoints |
| Provides global adjoint variables owned by a tape type. Thread-safe for use in parallel taping. More... | |
| struct | TraversalLogic |
| Traversal of CoDiPack expressions. More... | |
| struct | TupleMemory |
| Tuple implementation which allows to force inline of the construction of the tuple. More... | |
| struct | TupleMemoryBase |
| Base for tuple implementation see TupleMemory for details. More... | |
| struct | TupleMemoryBase< std::integer_sequence< size_t, Ids... >, Ts... > |
| Base for tuple implementation see TupleMemory for details. More... | |
| struct | TupleMemoryLeaf |
| Leaf for tuple implementation see TupleMemory for details. More... | |
| struct | UnaryJacobianOperation |
| Implements UnaryOperation for functions where the gradient can be computed and transposed. More... | |
| struct | UnaryOperation |
| Implements ComputeOperation for one argument. More... | |
| struct | ValidationIndicator |
| Helper class for statement validation. More... | |
| struct | VectorAccessInterface |
| Unified access to the adjoint vector and primal vector in a tape evaluation. More... | |
| struct | Warning |
| struct | WriteInfo |
| This class is used during the writing process of a primal value tape. The WriteInfo is returned by StatementEvaluator call with StatementCall::WriteInformation. More... | |
Typedefs | |
| template<typename Aggregated, size_t element, typename Arg> | |
| using | ArrayAccessExpression = typename ArrayAccessExpressionImpl<Aggregated, element>::template Expression<Arg> |
| Expression that performs a[element] in a compile time context. | |
| template<typename Chunk, typename NestedData = EmptyData> | |
| using | DefaultBlockData = BlockData<Chunk, NestedData> |
| BlockData DataInterface used in all unchecked tapes. | |
| template<typename Chunk, typename NestedData = EmptyData> | |
| using | DefaultChunkedData = ChunkedData<Chunk, NestedData> |
| ChunkData DataInterface used in all regular tapes. | |
| template<typename Base, typename Impl, typename R = void> | |
| using | enable_if_base_of = std::enable_if<std::is_base_of<Base, Impl>::value, R> |
| Enable if abbreviation for std::is_base_of. | |
| template<typename T1, typename T2, typename R = void> | |
| using | enable_if_not_same = std::enable_if<!std::is_same<T1, T2>::value, R> |
Enable if abbreviation for "!std::is_same". | |
| template<typename T1, typename T2, typename R = void> | |
| using | enable_if_same = std::enable_if<std::is_same<T1, T2>::value, R> |
Enable if abbreviation for "std::is_same". | |
| using | EvalHandleKey = size_t |
| Key for the evalHandle lookup. | |
| using | HessianComputationScalarType = RealReversePrimalIndexGen<RealForward> |
| A regular CoDiPack type that can be used for Hessian computations in the TapeHelper. | |
| using | HessianComputationType = RealReversePrimalIndexGen<RealForwardVec<4>, Direction<RealForwardVec<4>, 4>> |
| A regular CoDiPack type that can be used for Hessian computations in the TapeHelper. | |
| using | JacobianComputationScalarType = RealReverseIndex |
| A regular CoDiPack type that can be used for Jacobian computations in the TapeHelper. | |
| using | JacobianComputationType = RealReverseIndexVec<4> |
| A regular CoDiPack type that can be used for Jacobian computations in the TapeHelper. | |
| using | LinearSystemSolverHints = EnumBitset<LinearSystemSolverFlags> |
| All hints for the LinearSystemSolverHelper. | |
| template<typename T, Eigen::StorageOptions store> | |
| using | MapEigenMatrix = Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, store>> |
| Abbreviation for a mapped Eigen matrix. | |
| template<typename T, Eigen::StorageOptions store> | |
| using | MapEigenMatrixConst = Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, store> const> |
| Abbreviation for a constant mapped Eigen matrix. | |
| template<typename T> | |
| using | MapEigenVector = Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1>> |
| Abbreviation for a mapped Eigen vector. | |
| template<typename T> | |
| using | MapEigenVectorConst = Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> const> |
| Abbreviation for a constant mapped Eigen vector. | |
| template<typename Type> | |
| using | OpenMPAtomic = OpenMPAtomicImpl<Type> |
| template<typename Type> | |
| using | OpenMPExternalFunctionHelper = ExternalFunctionHelper<Type, OpenMPSynchronization, OpenMPThreadInformation> |
| Thread-safe external function helper for external functions jointly worked on by multiple OpenMP threads. | |
| template<typename Gradient, typename Identifier, typename Tape> | |
| using | OpenMPGlobalAdjoints = ThreadSafeGlobalAdjoints<Gradient, Identifier, Tape, OpenMPToolbox> |
| Thread-safe global adjoints for OpenMP. | |
| template<typename Type> | |
| using | OpenMPReverseAtomic = OpenMPReverseAtomicImpl<Type> |
| using | OpenMPToolbox |
| Parallel toolbox for OpenMP. | |
| using | RealForward = RealForwardGen<double, double> |
| using | RealForwardCUDA = RealForwardCUDAGen<double, double> |
| Forward AD type for CUDA kernels. See Forward AD Equation for a forward mode AD explanation. | |
| template<typename Real, typename Gradient = Real> | |
| using | RealForwardCUDAGen = ActiveTypeStatelessTape<ForwardEvaluation<Real, Gradient>> |
| Forward AD type for CUDA kernels. See Forward AD Equation for a forward mode AD explanation. | |
| template<size_t dim> | |
| using | RealForwardCUDAVec = RealForwardCUDAGen<double, Direction<double, dim>> |
| Vector forward AD type for CUDA kernels. See Forward AD Equation for a forward mode AD explanation. | |
| template<typename Real, typename Gradient = Real> | |
| using | RealForwardGen = ActiveType<ForwardEvaluation<Real, Gradient>> |
| using | RealForwardTag = ActiveType<TagTapeForward<double, int>> |
| template<size_t dim> | |
| using | RealForwardVec = RealForwardGen<double, Direction<double, dim>> |
| using | RealReverse = RealReverseGen<double> |
| template<typename Real, typename Gradient = Real, typename Index = int> | |
| using | RealReverseGen |
| using | RealReverseIndex = RealReverseIndexGen<double> |
| template<typename Real, typename Gradient = Real, typename IndexManager = MultiUseIndexManager<int>> | |
| using | RealReverseIndexGen |
| using | RealReverseIndexOpenMP = RealReverseIndexOpenMPGen<double> |
| template<typename Real, typename Gradient = OpenMPReverseAtomic<Real>, typename IndexManager = ParallelReuseIndexManager<int, OpenMPToolbox>> | |
| using | RealReverseIndexOpenMPGen |
| using | RealReverseIndexUnchecked = RealReverseIndexUncheckedGen<double> |
| template<typename Real, typename Gradient = Real, typename IndexManager = MultiUseIndexManager<int>> | |
| using | RealReverseIndexUncheckedGen |
| template<size_t dim> | |
| using | RealReverseIndexVec = RealReverseIndexGen<double, Direction<double, dim>> |
| template<size_t dim> | |
| using | RealReverseIndexVecOpenMP = RealReverseIndexOpenMPGen<double, Direction<OpenMPReverseAtomic<double>, dim>> |
| using | RealReversePrimal = RealReversePrimalGen<double> |
| template<typename Real, typename Gradient = Real, typename Index = int, typename StatementEvaluator = InnerStatementEvaluator> | |
| using | RealReversePrimalGen |
| using | RealReversePrimalIndex = RealReversePrimalIndexGen<double> |
| template<typename Real, typename Gradient = Real, typename IndexManager = MultiUseIndexManager<int>, typename StatementEvaluator = InnerStatementEvaluator> | |
| using | RealReversePrimalIndexGen |
| using | RealReversePrimalIndexUnchecked = RealReversePrimalIndexUncheckedGen<double> |
| template<typename Real, typename Gradient = Real, typename IndexManager = MultiUseIndexManager<int>, typename StatementEvaluator = InnerStatementEvaluator> | |
| using | RealReversePrimalIndexUncheckedGen |
| template<size_t dim> | |
| using | RealReversePrimalIndexVec = RealReversePrimalIndexGen<double, Direction<double, dim>> |
| using | RealReversePrimalUnchecked = RealReversePrimalUncheckedGen<double> |
| template<typename Real, typename Gradient = Real, typename Index = int, typename StatementEvaluator = InnerStatementEvaluator> | |
| using | RealReversePrimalUncheckedGen |
| template<size_t dim> | |
| using | RealReversePrimalVec = RealReversePrimalGen<double, Direction<double, dim>> |
| using | RealReverseTag = ActiveType<TagTapeReverse<double, int>> |
| using | RealReverseUnchecked = RealReverseUncheckedGen<double> |
| template<typename Real, typename Gradient = Real, typename Index = int> | |
| using | RealReverseUncheckedGen |
| template<size_t dim> | |
| using | RealReverseVec = RealReverseGen<double, Direction<double, dim>> |
| template<typename T_Real, typename T_Arg> | |
| using | RealToComplexCast = ComputeExpression<std::complex<T_Real>, OperationRealToComplexCast, T_Arg> |
| template<typename T> | |
| using | remove_all |
| Removes all reference, constant and volatile modifiers. | |
| template<typename Impl, typename SelfType> | |
| using | ResolveSelf |
| using | RestoreActions = EnumBitset<RestoreAction> |
| Action set for a variable during a store. See Restore actions for a detailed description. | |
| using | StoreActions = EnumBitset<StoreAction> |
| Action set for a variable during a store. See Store actions for a detailed description. | |
Enumerations | |
| enum class | AdjointsManagement { Manual , Automatic } |
| Policies for management of the tape's interal adjoints. More... | |
| enum class | EnumInterface { MaxElement } |
| Default interface for enums. | |
| enum class | FileType { Text , Binary , Graph , Math , Invalid } |
| Used to select the type of writer that should be generated. | |
| enum class | IdentifierType { Input , Output , Temp } |
| Used by the math statements to record the type of each identifier. This information is then used in the math representation. | |
| enum struct | IoError { Mode , Open , Write , Read } |
| Possible IO errors. | |
| enum class | LinearSystemSolverFlags { ReverseEvaluation = 0 , ForwardEvaluation , PrimalEvaluation , ProvidePrimalSolution , RecomputePrimalInForwardEvaluation , MaxElement } |
| Flags for the linear system solver. See LinearSystemInterface for a description of the flags. | |
| enum class | LowLevelFunctionEntryCallKind { Forward , Reverse , Primal , Delete , MaxElement } |
| All possible call types for a low level function entry. | |
| enum class | RestoreAction { PrimalCreate , PrimalRestore , InputIdentifierRestore , OutputIdentifierRestore , InputGradientCreate , OutputGradientCreate , MaxElement } |
| Action flags for activities during a restore. See Restore actions for a detailed description. | |
| enum class | StatementCall { ClearAdjoints , Forward , Primal , ResetPrimals , Reverse , WriteInformation , N_Elements } |
| Defines all the operations which can be evaluated on a statement by a tape. More... | |
| enum class | StoreAction { PrimalCreateOnTape , PrimalExtract , InputIdentifierCreateAndStore , OutputIdentifierCreate , MaxElement } |
| Action flags for activities during a store. See Store actions for a detailed description. | |
| enum class | TagFlags { DoNotChange , DoNotWrite , DoNotUse , MaxElement } |
| Properties for values. More... | |
| enum class | TapeParameters { AdjointSize , ConstantValuesSize , ExternalFunctionsSize , JacobianSize , LargestIdentifier , PassiveValuesSize , PrimalSize , IdentifiersSize , StatementSize , StatementByteSize , LLFInfoDataSize , LLFByteDataSize } |
| Configuration options for a tape. More... | |
Functions | |
| template<typename Tape> | |
| inlineauto | abs (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | arg (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| inlinesize_t constexpr | binomial (size_t n, size_t k) |
| Binomial coefficient computation. | |
| void | checkAndOutputAssert (bool const condition, char const *conditionString, char const *function, char const *file, int line) |
| Checks the assert statement and aborts the program if the statement is false. | |
| CODI_CREATE_TRANSPOSE (Vector4, Vector4Transpose, jacobian.transpose()) | |
| Transpose operation for the vector type. | |
| template<typename... Args> | |
| inlinevoid | CODI_UNUSED (Args const &...) |
| Disable unused warnings for an arbitrary number of arguments. | |
| template<typename Tape> | |
| inlineauto | conj (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename V> | |
| V | constructVector (size_t const size) |
| Helper for the construction of vector types provided by the user. | |
| template<typename T_Type> | |
| std::unique_ptr< TapeWriterInterface< T_Type > > | createWriter (const std::string &fileName, std::vector< typename T_Type::Identifier > &inputVariables, std::vector< typename T_Type::Identifier > &outputVariables, FileType selectedType) |
| The createWriter() function is used to generate an automatic writer using the FileType and the TapeTraits. | |
| template<typename Name> | |
| std::string | demangleName () |
| Return a string of the provided template name. | |
| template<typename IntegralType> | |
| IntegralType | getNextMultiple (IntegralType const &targetSize, IntegralType const &chunkSize) |
| Helper function for overallocation in multiples of a given chunk size. | |
| template<typename Tape> | |
| inlineauto | imag (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename T, typename... Args> | |
| std::unique_ptr< T > | make_unique_helper (Args &&... args) |
| Helper for creating a unique pointer. (std::make_unique is not available in C++11.) | |
| template<Eigen::StorageOptions store, typename T> | |
| MapEigenMatrix< T, store > | mapEigen (T *p, int rows, int cols) |
| Create a mapped Eigen matrix with specified storing option. | |
| template<typename T> | |
| MapEigenVector< T > | mapEigen (T *p, int size) |
| Create a mapped Eigen vector. | |
| template<Eigen::StorageOptions store, typename T> | |
| MapEigenMatrixConst< T, store > | mapEigen (T const *p, int rows, int cols) |
| Create a mapped Eigen matrix with specified storing option. | |
| template<typename T> | |
| MapEigenVectorConst< T > | mapEigen (T const *p, int size) |
| Create a constant mapped Eigen vector. | |
| template<typename T> | |
| MapEigenMatrix< T, Eigen::StorageOptions::ColMajor > | mapEigenColMajor (T *p, int rows, int cols) |
| Create a mapped Eigen matrix with a column major data layout. | |
| template<typename T> | |
| MapEigenMatrixConst< T, Eigen::StorageOptions::ColMajor > | mapEigenColMajor (T const *p, int rows, int cols) |
| Create a constant mapped Eigen matrix with a column major data layout. | |
| template<typename T> | |
| MapEigenMatrix< T, Eigen::StorageOptions::RowMajor > | mapEigenRowMajor (T *p, int rows, int cols) |
| Create a mapped Eigen matrix with a row major data layout. | |
| template<typename T> | |
| MapEigenMatrixConst< T, Eigen::StorageOptions::RowMajor > | mapEigenRowMajor (T const *p, int rows, int cols) |
| Create a constant mapped Eigen matrix with a row major data layout. | |
| template<Eigen::StorageOptions eigenStore, typename Type> | |
| void | matrixMatrixMultiplication (Type const *A, Type const *B, Type *R, int n, int k, int m) |
| template<typename Type> | |
| void | matrixMatrixMultiplicationColMajor (Type const *A, Type const *B, Type *R, int n, int k, int m) |
| template<typename Type> | |
| void | matrixMatrixMultiplicationRowMajor (Type const *A, Type const *B, Type *R, int n, int k, int m) |
| template<typename Tape> | |
| inlineauto | norm (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename A, typename Real, size_t dim> | |
| inlinebool | operator!= (A const &s, Direction< Real, dim > const &v) |
| Component-wise test for inequality with scalar. True if at least one component differs. | |
| template<typename A, typename Real, size_t dim> | |
| inlinebool | operator!= (Direction< Real, dim > const &v, A const &s) |
| Component-wise test for inequality with scalar. True if at least one component differs. | |
| template<typename Real, size_t dim> | |
| inlinebool | operator!= (Direction< Real, dim > const &v1, Direction< Real, dim > const &v2) |
| Component-wise test for inequality. True if at least one component differs. | |
| template<typename Enum> | |
| inlinebool | operator!= (Enum a, EnumBitset< Enum > const &b) |
| Not equal comparison for an enum and a bitset. | |
| template<typename Tag> | |
| bool | operator!= (TagData< Tag > const &a, TagData< Tag > const &b) |
| Not equal comparison of two tag data objects. | |
| template<typename Enum> | |
| inlineEnumBitset< Enum > | operator& (Enum a, EnumBitset< Enum > const &b) |
| And operation of the bitset and an enum. | |
| template<typename Enum> | |
| inlineEnumBitset< Enum > | operator& (EnumBitset< Enum > const &a, Enum b) |
| And operation of the bitset and an enum. | |
| template<typename Enum> | |
| inlineEnumBitset< Enum > | operator& (EnumBitset< Enum > const &a, EnumBitset< Enum > const &b) |
| And operation of two bitsets. | |
| inlineEnumBitset< RestoreAction > | operator& (RestoreAction a, RestoreAction b) |
| Return a boolean structure when two enums are combined with and. | |
| inlineEnumBitset< StoreAction > | operator& (StoreAction a, StoreAction b) |
| Return a boolean structure when two enums are combined with and. | |
| template<typename Real, size_t dim, typename = AtomicTraits::EnableIfAtomic<Real>> | |
| inlineDirection< Real, dim > | operator* (AtomicTraits::RemoveAtomic< Real > const &s, Direction< Real, dim > const &v) |
| Multiplication of a non-atomic scalar with a direction that has atomic reals. | |
| template<typename Real, size_t dim, typename = AtomicTraits::EnableIfAtomic<Real>> | |
| inlineDirection< Real, dim > | operator* (Direction< Real, dim > const &v, AtomicTraits::RemoveAtomic< Real > const &s) |
| Multiplication of a non-atomic scalar with a direction that has atomic reals. | |
| template<typename Real, size_t dim> | |
| inlineDirection< Real, dim > | operator* (Direction< Real, dim > const &v, Real const &s) |
| Multiplication with a scalar. | |
| template<typename Real, size_t dim, typename = RealTraits::EnableIfNotPassiveReal<Real>> | |
| inlineDirection< Real, dim > | operator* (Direction< Real, dim > const &v, RealTraits::PassiveReal< Real > const &s) |
| Multiplication with passive a scalar. | |
| template<typename Real, size_t dim> | |
| inlineDirection< Real, dim > | operator* (Real const &s, Direction< Real, dim > const &v) |
| Multiplication with a scalar. | |
| template<typename Real, size_t dim, typename = RealTraits::EnableIfNotPassiveReal<Real>> | |
| inlineDirection< Real, dim > | operator* (RealTraits::PassiveReal< Real > const &s, Direction< Real, dim > const &v) |
| Multiplication with a passive scalar. | |
| template<typename Real, size_t dim> | |
| inlineDirection< Real, dim > | operator+ (Direction< Real, dim > const &v1, Direction< Real, dim > const &v2) |
| Summation of two vectors. | |
| template<typename Real, size_t dim> | |
| inlineDirection< Real, dim > | operator- (Direction< Real, dim > const &v) |
| Negation. | |
| template<typename Real, size_t dim> | |
| inlineDirection< Real, dim > | operator- (Direction< Real, dim > const &v1, Direction< Real, dim > const &v2) |
| Subtraction of two vectors. | |
| template<typename Real, size_t dim, typename = AtomicTraits::EnableIfAtomic<Real>> | |
| inlineDirection< Real, dim > | operator/ (Direction< Real, dim > const &v, AtomicTraits::RemoveAtomic< Real > const &s) |
| Division of a direction with atomic reals by a non-atomic scalar. | |
| template<typename Real, size_t dim> | |
| inlineDirection< Real, dim > | operator/ (Direction< Real, dim > const &v, Real const &s) |
| Division by a scalar. | |
| template<typename Real, size_t dim, typename = RealTraits::EnableIfNotPassiveReal<Real>> | |
| inlineDirection< Real, dim > | operator/ (Direction< Real, dim > const &v, RealTraits::PassiveReal< Real > const &s) |
| Division by a passive scalar. | |
| template<typename Out, typename Enum> | |
| inlineOut & | operator<< (Out &out, EnumBitset< Enum > const &b) |
| Stream output. | |
| template<typename Real, size_t dim> | |
| std::ostream & | operator<< (std::ostream &os, Direction< Real, dim > const &v) |
| Output stream operator. | |
| template<typename Expr> | |
| ExpressionTraits::EnableIfExpression< Expr, std::ostream > & | operator<< (std::ostream &out, Expr const &v) |
| Write the primal value to the stream. | |
| template<typename Stream, typename Jac, typename = enable_if_base_of<Jac, JacobianInterface<typename Jac::T>>> | |
| Stream & | operator<< (Stream &out, Jac const &jacobian) |
| Output a Jacobian on the data stream. | |
| template<typename A, typename Real, size_t dim> | |
| inlinebool | operator== (A const &s, Direction< Real, dim > const &v) |
| Component-wise test for equality with scalar. True if all components match. | |
| template<typename A, typename Real, size_t dim> | |
| inlinebool | operator== (Direction< Real, dim > const &v, A const &s) |
| Component-wise test for equality with scalar. True if all components match. | |
| template<typename Real, size_t dim> | |
| inlinebool | operator== (Direction< Real, dim > const &v1, Direction< Real, dim > const &v2) |
| Component-wise test for equality. True if all components match. | |
| template<typename Enum> | |
| inlinebool | operator== (Enum a, EnumBitset< Enum > const &b) |
| Equal comparison for an enum and a bitset. | |
| template<typename Tag> | |
| bool | operator== (TagData< Tag > const &a, TagData< Tag > const &b) |
| Equal comparison of two tag data objects. | |
| template<typename Expr> | |
| ExpressionTraits::EnableIfLhsExpression< Expr, std::istream > & | operator>> (std::istream &stream, Expr &v) |
| Read the primal value from a stream. | |
| template<typename Enum> | |
| inlineEnumBitset< Enum > | operator| (Enum a, EnumBitset< Enum > const &b) |
| Or operation of the bitset and an enum. | |
| template<typename Enum> | |
| inlineEnumBitset< Enum > | operator| (EnumBitset< Enum > const &a, Enum b) |
| Or operation of the bitset and an enum. | |
| template<typename Enum> | |
| inlineEnumBitset< Enum > | operator| (EnumBitset< Enum > const &a, EnumBitset< Enum > const &b) |
| Or operation of two bitsets. | |
| inlineLinearSystemSolverHints | operator| (LinearSystemSolverFlags a, LinearSystemSolverFlags b) |
| Return a hints structure when to enums are ored. | |
| inlineEnumBitset< RestoreAction > | operator| (RestoreAction a, RestoreAction b) |
| Return an EnumBitset structure when two enums are combined with or. | |
| inlineEnumBitset< StoreAction > | operator| (StoreAction a, StoreAction b) |
| Return an EnumBitset structure when two enums are combined with or. | |
| void | outputExceptionOrWarning (char const function[], char const file[], int const line, bool warning, char const *message,...) |
| Prints the positions and the message of the exception. | |
| template<typename Tape> | |
| inlineauto | proj (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename T_Type> | |
| std::unique_ptr< TapeReaderInterface< T_Type > > | readTapeFile (std::string const &fileName) |
| Uses the fileName to read and restore a Jacobian tape. The file extension is used to determine wether the tape file is a binary (.dat) or text (.txt) file. | |
| template<typename T_Type> | |
| std::unique_ptr< TapeReaderInterface< T_Type > > | readTapeFile (std::string const &fileName, std::vector< typename T_Type::Tape::EvalHandle > const &evalHandles) |
| Uses the fileName to read and restore a primal value tape. The file extension is used to determine whether the tape file is a binary (.dat) or text (.txt) file. | |
| template<typename Tape> | |
| inlineauto | real (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename LSInterface> | |
| void | solveLinearSystem (LSInterface lsi, typename LSInterface::Matrix &A, typename LSInterface::Vector &b, typename LSInterface::Vector &x, LinearSystemSolverHints hints=LinearSystemSolverHints::ALL()) |
| template<std::size_t N, typename F, typename... Args> | |
| inlinevoid | static_for (F func, Args &&... args) |
| Static for with i = 0 .. (N - 1). See CompileTimeLoop for details. | |
| template<typename T> | |
| inlineT const | toConst (T &&v) |
| Constant cast function that works with CUDA. | |
| template<typename T> | |
| inlineT const & | toConst (T &v) |
| Constant cast function that works with CUDA. | |
Builtin binary operators | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator+ (ExpressionInterface< std::complex< Real >, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(complex, real). | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator+ (ExpressionInterface< std::complex< Real >, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION(complex, passive real). | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator+ (std::complex< RealTraits::PassiveReal< Real > > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(passive complex, real). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator+ (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(real, complex). | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator+ (ExpressionInterface< Real, ArgA > const &argA, std::complex< RealTraits::PassiveReal< Real > > const &argB) |
| Function overload for FUNCTION(real, passive complex). | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator+ (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(passive real, complex). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator- (ExpressionInterface< std::complex< Real >, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(complex, real). | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator- (ExpressionInterface< std::complex< Real >, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION(complex, passive real). | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator- (std::complex< RealTraits::PassiveReal< Real > > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(passive complex, real). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator- (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(real, complex). | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator- (ExpressionInterface< Real, ArgA > const &argA, std::complex< RealTraits::PassiveReal< Real > > const &argB) |
| Function overload for FUNCTION(real, passive complex). | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator- (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(passive real, complex). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator* (ExpressionInterface< std::complex< Real >, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(complex, real). | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator* (ExpressionInterface< std::complex< Real >, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION(complex, passive real). | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator* (std::complex< RealTraits::PassiveReal< Real > > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(passive complex, real). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator* (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(real, complex). | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator* (ExpressionInterface< Real, ArgA > const &argA, std::complex< RealTraits::PassiveReal< Real > > const &argB) |
| Function overload for FUNCTION(real, passive complex). | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator* (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(passive real, complex). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator/ (ExpressionInterface< std::complex< Real >, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(complex, real). | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator/ (ExpressionInterface< std::complex< Real >, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION(complex, passive real). | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator/ (std::complex< RealTraits::PassiveReal< Real > > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(passive complex, real). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator/ (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(real, complex). | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator/ (ExpressionInterface< Real, ArgA > const &argA, std::complex< RealTraits::PassiveReal< Real > > const &argB) |
| Function overload for FUNCTION(real, passive complex). | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator/ (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(passive real, complex). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator+ (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator+ (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator+ (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator- (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator- (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator- (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator* (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator* (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator* (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | operator/ (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | operator/ (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | operator/ (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
Standard math library binary operators | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | polar (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(real, real). | |
| template<typename Real, typename ArgA> | |
| inlineauto | polar (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION(real, passive real). | |
| template<typename Real, typename ArgB> | |
| inlineauto | polar (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(passive real, real). | |
| template<typename Tape> | |
| inlineauto | polar (ActiveType< Tape > const &argA, ActiveType< Tape > const &argB) |
| Function overload for FUNCTION(ActiveType, ActiveType). | |
| template<typename Tape> | |
| inlineauto | polar (ActiveTypeStatelessTape< Tape > const &argA, ActiveTypeStatelessTape< Tape > const &argB) |
| Function overload for FUNCTION(ActiveTypeStatelessTape, ActiveTypeStatelessTape). | |
| template<typename Tape, typename Toolbox> | |
| inlineauto | polar (ParallelActiveType< Tape, Toolbox > const &argA, ParallelActiveType< Tape, Toolbox > const &argB) |
| Function overload for FUNCTION(ParallelActiveType, ParallelActiveType). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | pow (ExpressionInterface< std::complex< Real >, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(complex, real). | |
| template<typename Real, typename ArgA> | |
| inlineauto | pow (ExpressionInterface< std::complex< Real >, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION(complex, passive real). | |
| template<typename Real, typename ArgB> | |
| inlineauto | pow (std::complex< RealTraits::PassiveReal< Real > > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION(passive complex, real). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | pow (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(real, complex). | |
| template<typename Real, typename ArgA> | |
| inlineauto | pow (ExpressionInterface< Real, ArgA > const &argA, std::complex< RealTraits::PassiveReal< Real > > const &argB) |
| Function overload for FUNCTION(real, passive complex). | |
| template<typename Real, typename ArgB> | |
| inlineauto | pow (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for FUNCTION(passive real, complex). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | atan2 (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | atan2 (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | atan2 (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | atan2f (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | atan2f (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | atan2f (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | atan2l (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | atan2l (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | atan2l (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | copysign (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | copysign (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | copysign (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | copysignf (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | copysignf (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | copysignf (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | copysignl (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | copysignl (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | copysignl (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fmod (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fmod (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fmod (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fmodf (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fmodf (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fmodf (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fmodl (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fmodl (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fmodl (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | frexp (ExpressionInterface< Real, ArgA > const &argA, int *const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | frexpf (ExpressionInterface< Real, ArgA > const &argA, int *const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | frexpl (ExpressionInterface< Real, ArgA > const &argA, int *const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | hypot (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | hypot (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | hypot (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | hypotf (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | hypotf (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | hypotf (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | hypotl (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | hypotl (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | hypotl (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | ldexp (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | ldexpl (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | ldexpf (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | max (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | max (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | max (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fmax (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fmax (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fmax (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fmaxf (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fmaxf (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fmaxf (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fmaxl (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fmaxl (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fmaxl (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | min (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | min (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | min (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fmin (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fmin (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fmin (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fminf (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fminf (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fminf (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | fminl (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | fminl (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | fminl (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | pow (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | pow (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | pow (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | powf (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | powf (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | powf (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | powl (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | powl (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | powl (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | remainder (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | remainder (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | remainder (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | remainderf (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | remainderf (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | remainderf (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| inlineauto | remainderl (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgA> | |
| inlineauto | remainderl (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Real, typename ArgB> | |
| inlineauto | remainderl (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for FUNCTION. | |
| template<typename Tape> | |
| inlineauto | pow (complex< codi::ActiveType< Tape > > const &argA, complex< codi::ActiveType< Tape > > const &argB) |
| Function overload for FUNCTION(complex, complex). | |
Builtin binary comparison operators | |
| template<typename Real, typename ArgA> | |
| inlinebool | operator== (ExpressionInterface< std::complex< Real >, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for OPERATOR(complex, passive real). | |
| template<typename Real, typename ArgB> | |
| inlinebool | operator== (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for OPERATOR(passive real, complex). | |
| template<typename Real, typename ArgA> | |
| inlinebool | operator!= (ExpressionInterface< std::complex< Real >, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for OPERATOR(complex, passive real). | |
| template<typename Real, typename ArgB> | |
| inlinebool | operator!= (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< std::complex< Real >, ArgB > const &argB) |
| Function overload for OPERATOR(passive real, complex). | |
| template<typename Real, typename ArgA, typename ArgB> | |
| bool | operator== (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator== (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator== (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator== (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator== (int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator== (ExpressionInterface< Real, ArgA > const &argA, unsigned int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator== (unsigned int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator== (ExpressionInterface< Real, ArgA > const &argA, long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator== (long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator== (ExpressionInterface< Real, ArgA > const &argA, unsigned long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator== (unsigned long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator== (ExpressionInterface< Real, ArgA > const &argA, long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator== (long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator== (ExpressionInterface< Real, ArgA > const &argA, unsigned long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator== (unsigned long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| bool | operator!= (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator!= (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator!= (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator!= (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator!= (int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator!= (ExpressionInterface< Real, ArgA > const &argA, unsigned int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator!= (unsigned int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator!= (ExpressionInterface< Real, ArgA > const &argA, long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator!= (long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator!= (ExpressionInterface< Real, ArgA > const &argA, unsigned long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator!= (unsigned long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator!= (ExpressionInterface< Real, ArgA > const &argA, long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator!= (long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator!= (ExpressionInterface< Real, ArgA > const &argA, unsigned long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator!= (unsigned long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| bool | operator> (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator> (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator> (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator> (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator> (int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator> (ExpressionInterface< Real, ArgA > const &argA, unsigned int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator> (unsigned int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator> (ExpressionInterface< Real, ArgA > const &argA, long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator> (long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator> (ExpressionInterface< Real, ArgA > const &argA, unsigned long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator> (unsigned long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator> (ExpressionInterface< Real, ArgA > const &argA, long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator> (long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator> (ExpressionInterface< Real, ArgA > const &argA, unsigned long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator> (unsigned long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| bool | operator< (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator< (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator< (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator< (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator< (int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator< (ExpressionInterface< Real, ArgA > const &argA, unsigned int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator< (unsigned int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator< (ExpressionInterface< Real, ArgA > const &argA, long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator< (long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator< (ExpressionInterface< Real, ArgA > const &argA, unsigned long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator< (unsigned long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator< (ExpressionInterface< Real, ArgA > const &argA, long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator< (long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator< (ExpressionInterface< Real, ArgA > const &argA, unsigned long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator< (unsigned long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| bool | operator>= (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator>= (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator>= (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator>= (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator>= (int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator>= (ExpressionInterface< Real, ArgA > const &argA, unsigned int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator>= (unsigned int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator>= (ExpressionInterface< Real, ArgA > const &argA, long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator>= (long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator>= (ExpressionInterface< Real, ArgA > const &argA, unsigned long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator>= (unsigned long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator>= (ExpressionInterface< Real, ArgA > const &argA, long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator>= (long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator>= (ExpressionInterface< Real, ArgA > const &argA, unsigned long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator>= (unsigned long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| bool | operator<= (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator<= (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator<= (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator<= (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator<= (int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator<= (ExpressionInterface< Real, ArgA > const &argA, unsigned int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator<= (unsigned int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator<= (ExpressionInterface< Real, ArgA > const &argA, long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator<= (long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator<= (ExpressionInterface< Real, ArgA > const &argA, unsigned long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator<= (unsigned long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator<= (ExpressionInterface< Real, ArgA > const &argA, long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator<= (long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator<= (ExpressionInterface< Real, ArgA > const &argA, unsigned long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator<= (unsigned long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| bool | operator&& (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator&& (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator&& (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator&& (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator&& (int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator&& (ExpressionInterface< Real, ArgA > const &argA, unsigned int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator&& (unsigned int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator&& (ExpressionInterface< Real, ArgA > const &argA, long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator&& (long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator&& (ExpressionInterface< Real, ArgA > const &argA, unsigned long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator&& (unsigned long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator&& (ExpressionInterface< Real, ArgA > const &argA, long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator&& (long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator&& (ExpressionInterface< Real, ArgA > const &argA, unsigned long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator&& (unsigned long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA, typename ArgB> | |
| bool | operator|| (ExpressionInterface< Real, ArgA > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator|| (ExpressionInterface< Real, ArgA > const &argA, RealTraits::PassiveReal< Real > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator|| (RealTraits::PassiveReal< Real > const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator|| (ExpressionInterface< Real, ArgA > const &argA, int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator|| (int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator|| (ExpressionInterface< Real, ArgA > const &argA, unsigned int const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator|| (unsigned int const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator|| (ExpressionInterface< Real, ArgA > const &argA, long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator|| (long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator|| (ExpressionInterface< Real, ArgA > const &argA, unsigned long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator|| (unsigned long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator|| (ExpressionInterface< Real, ArgA > const &argA, long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator|| (long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgA> | |
| bool | operator|| (ExpressionInterface< Real, ArgA > const &argA, unsigned long long const &argB) |
| Function overload for operator OPERATOR. | |
| template<typename Real, typename ArgB> | |
| bool | operator|| (unsigned long long const &argA, ExpressionInterface< Real, ArgB > const &argB) |
| Function overload for operator OPERATOR. | |
Standard math library unary operators | |
| template<typename Real, typename Arg> | |
| inlineauto | abs (ExpressionInterface< std::complex< Real >, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | arg (ExpressionInterface< std::complex< Real >, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | conj (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | imag (ExpressionInterface< std::complex< Real >, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | norm (ExpressionInterface< std::complex< Real >, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | proj (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | real (ExpressionInterface< std::complex< Real >, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | abs (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | fabs (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | fabsf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | fabsl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | acos (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | acosf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | acosl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | acosh (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | acoshf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | acoshl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | asin (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | asinf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | asinl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | asinh (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | asinhf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | asinhl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | atan (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | atanf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | atanl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | atanh (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | atanhf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | atanhl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | cbrt (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | cbrtf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | cbrtl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | ceil (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for ceil. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | ceilf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for ceilf. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | ceill (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for ceill. | |
| template<typename Real, typename Arg> | |
| inlineauto | cos (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | cosf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | cosl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | cosh (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | coshf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | coshl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | erf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | erff (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | erfl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | erfc (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | erfcf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | erfcl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | exp (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | expf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | expl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | floor (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for floor. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | floorf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for floorf. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | floorl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for floorl. | |
| template<typename Real, typename Arg> | |
| inlinebool | isfinite (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for isfinite. | |
| template<typename Real, typename Arg> | |
| inlinebool | isinf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for isinf. | |
| template<typename Real, typename Arg> | |
| inlinebool | isnan (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for isnan. | |
| template<typename Real, typename Arg> | |
| inlinebool | isnormal (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for isnormal. | |
| template<typename Real, typename Arg> | |
| inlineauto | log (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | logf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | logl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log10 (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log10f (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log10l (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log1p (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log1pf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log1pl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log2 (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log2f (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | log2l (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | round (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for round. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | roundf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for roundf. | |
| template<typename Real, typename Arg> | |
| inlineRealTraits::PassiveReal< Real > | roundl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for roundl. | |
| template<typename Real, typename Arg> | |
| inlineauto | sin (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | sinf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | sinl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | sinh (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | sinhf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | sinhl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | sqrt (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | sqrtf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | sqrtl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tan (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tanf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tanl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tanh (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tanhf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tanhl (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tgamma (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tgammaf (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineauto | tgammal (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Tape> | |
| inlineauto | abs (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | acos (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | acosh (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | asin (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | asinh (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | atan (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | atanh (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | cos (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | cosh (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | exp (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Real> | |
| bool | isfinite (std::complex< Real > arg) |
| isfinite implementation for complex numbers. | |
| template<typename Tape> | |
| inlineauto | log (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | log10 (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | sin (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | sinh (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | sqrt (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | tan (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
| template<typename Tape> | |
| inlineauto | tanh (complex< codi::ActiveType< Tape > > const &arg) |
| Function overload for FUNCTION(complex<ActiveType>). | |
Additional standard library binary operators | |
/*******************************************************************************/ | |
| template<typename Real, typename Gradient, typename Tape, typename Impl> | |
| void | swap (LhsExpressionInterface< Real, Gradient, Tape, Impl > &lhs, LhsExpressionInterface< Real, Gradient, Tape, Impl > &rhs) |
| Optimized swap for lhs expressions that does not call the copy constructor. | |
Builtin unary comparison operators | |
| template<typename Real, typename Arg> | |
| inlinebool | operator! (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for operator OPERATOR. | |
Builtin unary operators | |
| template<typename Real, typename Arg> | |
| inlineauto | operator- (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for FUNCTION. | |
| template<typename Real, typename Arg> | |
| inlineExpressionInterface< Real, Arg > const & | operator+ (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for operator +. | |
Additional standard library unary operators | |
| template<typename Real, typename Arg> | |
| inlinestd::string | to_string (ExpressionInterface< Real, Arg > const &arg) |
| Function overload for to_string. | |
Variables | |
| template<typename Tape> | |
| Tape | ActiveType< Tape >::tape {} |
| template<typename ImplTapeTypes, typename Impl> | |
| std::vector< LowLevelFunctionEntry< Impl, typename ImplTapeTypes::Real, typename ImplTapeTypes::Identifier > > * | CommonTapeImplementation< ImplTapeTypes, Impl >::lowLevelFunctionLookup = nullptr |
| template<typename Real, size_t dim> | |
| size_t constexpr | Direction< Real, dim >::dim |
| template<typename Generator, typename Stmt> | |
| PrimalTapeStatementFunctions const | DirectStatementEvaluatorStaticStore< Generator, Stmt >::staticStore |
| template<typename Tape> | |
| EventSystemBase< Tape >::Handle | EventSystemBase< Tape >::nextHandle = 0 |
| template<Eigen::StorageOptions eigenStore, typename Type> | |
| codi::Config::LowLevelFunctionToken | ExtFunc_matrixMatrixMultiplication< eigenStore, Type >::ID |
| template<typename Index> | |
| Index constexpr | IndexManagerInterface< Index >::InactiveIndex |
| template<typename Index> | |
| Index constexpr | IndexManagerInterface< Index >::InvalidIndex |
| template<typename Generator, typename Stmt> | |
| InnerPrimalTapeStatementData const | InnerStatementEvaluatorStaticStore< Generator, Stmt >::staticStore |
| template<typename Tape, typename ParallelToolbox> | |
| ParallelActiveType< Tape, ParallelToolbox >::ThreadLocalTapePointer | ParallelActiveType< Tape, ParallelToolbox >::tape |
| template<typename TapeTypes, typename Impl> | |
| const TapeTypes::EvalHandle | PrimalValueBaseTape< TapeTypes, Impl >::jacobianExpressions [Config::MaxArgumentSize] |
| Expressions for manual statement pushes. | |
| template<typename Gradient, typename Identifier, typename Tape, typename ParallelToolbox> | |
| ParallelToolbox::ReadWriteMutex | ThreadSafeGlobalAdjoints< Gradient, Identifier, Tape, ParallelToolbox >::adjointsMutex |
CoDiPack - Code Differentiation Package.
Web: https://scicomp.rptu.de/software/codi Git: https://github.com/scicompkl/codipack Doc: https://scicomp.rptu.de/codi
A regular CoDiPack type that can be used for Hessian computations in the TapeHelper.
This is the scalar version which does not use a vector mode.
A regular CoDiPack type that can be used for Jacobian computations in the TapeHelper.
This is the scalar version which does not use a vector mode.
| using codi::OpenMPAtomic = OpenMPAtomicImpl<Type> |
Wrapper for atomics for OpenMP.
| Type | An arithmetic type or CoDiPack forward type. |
| using codi::OpenMPReverseAtomic = OpenMPReverseAtomicImpl<Type> |
Wrapper for reverse atomics for OpenMP.
| Type | An arithmetic type or CoDiPack forward type. |
| using codi::OpenMPToolbox |
Parallel toolbox for OpenMP.
| using codi::RealForward = RealForwardGen<double, double> |
Default forward AD type. See Forward AD Equation for a forward mode AD explanation or Active type definitions for a list of all types.
| using codi::RealForwardGen = ActiveType<ForwardEvaluation<Real, Gradient>> |
General forward AD type. See Forward AD Equation for a forward mode AD explanation or Active type definitions for a list of all types.
| using codi::RealForwardTag = ActiveType<TagTapeForward<double, int>> |
Type for checking errors of the application with respect to other CoDiPack types. Resembles a CoDiPack forward type.
| using codi::RealForwardVec = RealForwardGen<double, Direction<double, dim>> |
General vector forward AD type. See Forward AD Equation for a forward mode AD explanation or Active type definitions for a list of all types.
| using codi::RealReverse = RealReverseGen<double> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with linear index handling.
| using codi::RealReverseGen |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with linear index handling.
| using codi::RealReverseIndex = RealReverseIndexGen<double> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with reuse index handling.
| using codi::RealReverseIndexGen |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with reuse index handling.
| using codi::RealReverseIndexOpenMP = RealReverseIndexOpenMPGen<double> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with reuse index handling.
This a thread-safe implementation for use with OpenMP. See Example 23 - OpenMP Parallel Codes for an example.
| using codi::RealReverseIndexOpenMPGen |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with reuse index handling.
This a thread-safe implementation for use with OpenMP. See Example 23 - OpenMP Parallel Codes for an example.
| using codi::RealReverseIndexUnchecked = RealReverseIndexUncheckedGen<double> |
General unchecked reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Requires preallocation of data. See DataManagementTapeInterface.
Jacobian taping approach with reuse index handling.
| using codi::RealReverseIndexUncheckedGen |
General unchecked reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Requires preallocation of data. See DataManagementTapeInterface.
Jacobian taping approach with reuse index handling.
| using codi::RealReverseIndexVec = RealReverseIndexGen<double, Direction<double, dim>> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with reuse index handling.
| using codi::RealReverseIndexVecOpenMP = RealReverseIndexOpenMPGen<double, Direction<OpenMPReverseAtomic<double>, dim>> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with reuse index handling.
This a thread-safe implementation for use with OpenMP. See Example 23 - OpenMP Parallel Codes for an example.
| using codi::RealReversePrimal = RealReversePrimalGen<double> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Primal value taping approach with linear index handling.
| using codi::RealReversePrimalGen |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Primal value taping approach with linear index handling.
| using codi::RealReversePrimalIndex = RealReversePrimalIndexGen<double> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Primal value taping approach with reuse index handling.
| using codi::RealReversePrimalIndexGen |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Primal value taping approach with reuse index handling.
General unchecked reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Requires preallocation of data. See DataManagementTapeInterface.
Primal value taping approach with reuse index handling.
| using codi::RealReversePrimalIndexUncheckedGen |
General unchecked reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Requires preallocation of data. See DataManagementTapeInterface.
Primal value taping approach with reuse index handling.
| using codi::RealReversePrimalIndexVec = RealReversePrimalIndexGen<double, Direction<double, dim>> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Primal value taping approach with reuse index handling.
| using codi::RealReversePrimalUnchecked = RealReversePrimalUncheckedGen<double> |
General unchecked reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Requires preallocation of data. See DataManagementTapeInterface.
Primal value taping approach with linear index handling.
| using codi::RealReversePrimalUncheckedGen |
General unchecked reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Requires preallocation of data. See DataManagementTapeInterface.
Primal value taping approach with linear index handling.
| using codi::RealReversePrimalVec = RealReversePrimalGen<double, Direction<double, dim>> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Primal value taping approach with linear index handling.
| using codi::RealReverseTag = ActiveType<TagTapeReverse<double, int>> |
Type for checking errors of the application with respect to other CoDiPack types. Resembles a CoDiPack reverse type.
| using codi::RealReverseUnchecked = RealReverseUncheckedGen<double> |
General unchecked reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Requires preallocation of data. See DataManagementTapeInterface.
Jacobian taping approach with linear index handling.
| using codi::RealReverseUncheckedGen |
General unchecked reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Requires preallocation of data. See DataManagementTapeInterface.
Jacobian taping approach with linear index handling.
| using codi::RealReverseVec = RealReverseGen<double, Direction<double, dim>> |
General reverse AD type. See Reverse AD Equation for a reverse mode AD explanation or Active type definitions for a list of all types.
Jacobian taping approach with linear index handling.
| using codi::RealToComplexCast = ComputeExpression<std::complex<T_Real>, OperationRealToComplexCast, T_Arg> |
Expression that converts in the adjoint evaluation a complex to the real part. See OperationRealToComplexCast for details.
| using codi::remove_all |
Removes all reference, constant and volatile modifiers.
| using codi::ResolveSelf |
If Impl == Self return SelfType else return Impl
|
strong |
Policies for management of the tape's interal adjoints.
For the convenience of the user, tapes manage their internal adjoints automatically, which involves multiple tasks. AdjointsManagement::Manual indicates that non of these tasks is performed - they are the responsibility of the caller instead. Functions that take an AdjointsManagement parameter default to AdjointsManagement::Automatic and document the individual effects of AdjointsManagement::Manual. An overview over all possible effects is given below.
Bounds checking. The function accesses the adjoints. In the automatic mode, it checks whether the adjoints are sufficiently large. If they are not, they might be resized or the function might work on or return dummy values. To optimize the memory usage and/or reduce the number of reallocations, AdjointsManagement::Manual can be used to skip bounds checking and resizing. It is the responsibility of the caller to ensure sufficient adjoints size, for example by calls to DataManagementTapeInterface::resizeAdjointVector.
Declaration of adjoints usage (locking). If a tape implements it adjoints against InternalAdjointsInterface, it keeps track of whether the adjoint vector is in use, which is for example the case during tape evaluations. This is to ensure mutual exclusion with reallocations, this is particularly important in shared-memory parallel taping, see also ThreadSafeGlobalAdjoints. Declaration of usage involves setting a lock, which can become a bottleneck if it is done frequently. To optimize the performance, multiple operations can be grouped into a single usage declaration, by surrounding them by manual DataManagementTapeInterface::beginUseAdjoints and DataManagementTapeInterface::endUseAdjoints calls and invoking them with AdjointsManagement::Manual. Note that any method that results in adjoint vector resizing must be called outside usage declarations, otherwise there would be a deadlock.
| Enumerator | |
|---|---|
| Manual | Do not perform any bounds checking, locking, or resizing. |
| Automatic | Manage internal adjoints automatically, including locking, bounds checking, and resizing. |
|
strong |
Defines all the operations which can be evaluated on a statement by a tape.
|
strong |
Properties for values.
|
strong |
Configuration options for a tape.
See DataManagementTapeInterface for details.
Access is defined by [A: "access"]. Options are:
| Enumerator | |
|---|---|
| AdjointSize | [A: RW] Current number of adjoint vector entries, not the maximum possible size. See LargestIdentifier. |
| ConstantValuesSize | [A: RW] Allocated number of entries in the constant value vector in primal value tapes. [Deprecated] |
| ExternalFunctionsSize | [A: RW] (Deprecated, will be removed on 31.12.2024) Allocated number of entries in the external function vector. |
| JacobianSize | [A: RW] Allocated number of entries in the argument Jacobian vector in Jacobian tapes. |
| LargestIdentifier | [A: R] Largest identifier distributed by the index manger. |
| PassiveValuesSize | [A: RW] Allocated number of entries in the passive value vector in primal value tapes. [Deprecated] |
| PrimalSize | [A: RW] Number of primal vector entries in primal value tapes. |
| IdentifiersSize | [A: RW] Allocated number of entries in the right hand side identifiers vector in primal value tapes. [Deprecated] |
| StatementSize | [A: RW] Allocated number of entries in the statement vector in all tapes. |
| StatementByteSize | [A: RW] Allocated size of the byte data for the statement data. |
| LLFInfoDataSize | [A: RW] Allocated number of entries in the low level function info vector in all tapes. |
| LLFByteDataSize | [A: RW] Allocated number of entries in the the byte data vecotor of low level functions in all tapes. |
|
constexpr |
Binomial coefficient computation.
Recursive implementation of
![\[ \binom{n}{k} = \frac{n!}{k!(n-k)!} = \binom{n-1}{k} + \binom{n-1}{k-1}
\]](../../form_13_dark.png)
| [in] | n | Number of choices. |
| [in] | k | Number of draws. |
|
inline |
Checks the assert statement and aborts the program if the statement is false.
The method prints an error message that contains the failed expression, the function name, the file, and the line. This method is usually accessed via the codiAssert macro, see codi::Config::EnableAssert.
| [in] | condition | The evaluated value of the condition. |
| [in] | conditionString | The condition as a string value. |
| [in] | function | The name of the function that caused the assert. |
| [in] | file | The file were the function is defined. |
| [in] | line | The line in the file were the assert is defined. |
| std::unique_ptr< TapeWriterInterface< T_Type > > codi::createWriter | ( | const std::string & | fileName, |
| std::vector< typename T_Type::Identifier > & | inputVariables, | ||
| std::vector< typename T_Type::Identifier > & | outputVariables, | ||
| FileType | selectedType ) |
The createWriter() function is used to generate an automatic writer using the FileType and the TapeTraits.
The method uses default values for the writers with parameters, such as printJacobians for the graphWriter.
Smart Pointers are used to avoid manual memory management.
See codi::TapeWriterInterface for a general description on how to use tape writers.
| T_Type | The CoDiPack type of the tape that is to be written out. |
< The evaluation type.
< The tape type that is to be written out.
| IntegralType codi::getNextMultiple | ( | IntegralType const & | targetSize, |
| IntegralType const & | chunkSize ) |
Helper function for overallocation in multiples of a given chunk size.
| IntegralType | An integral type, usually size_t. |
| targetSize | Minimum returned size. |
| chunkSize | Returned size is a multiple of chunkSize. |
| void codi::matrixMatrixMultiplication | ( | Type const * | A, |
| Type const * | B, | ||
| Type * | R, | ||
| int | n, | ||
| int | k, | ||
| int | m ) |
Low level function for 
| eigenStore | One of Eigen::StorageOptions. |
| void codi::matrixMatrixMultiplicationColMajor | ( | Type const * | A, |
| Type const * | B, | ||
| Type * | R, | ||
| int | n, | ||
| int | k, | ||
| int | m ) |
Low level function for
| void codi::matrixMatrixMultiplicationRowMajor | ( | Type const * | A, |
| Type const * | B, | ||
| Type * | R, | ||
| int | n, | ||
| int | k, | ||
| int | m ) |
Low level function for
| Stream & codi::operator<< | ( | Stream & | out, |
| Jac const & | jacobian ) |
Output a Jacobian on the data stream.
The format is (Matlab): [1, 2, 3; 4, 5, 6; 7, 8, 8]
|
inline |
Prints the positions and the message of the exception.
The position and function where the exceptions occurred are printed. The message will be handled and formatted by a printf like function.
| [in] | function | Name of the function from which the exception is generated. |
| [in] | file | File where the exception was generated. |
| [in] | line | Line inside the file where the exception was generated. |
| [in] | warning | If this is a warning or an exception. |
| [in] | message | The exception message and the arguments for the formatting in the message. |
| std::unique_ptr< TapeReaderInterface< T_Type > > codi::readTapeFile | ( | std::string const & | fileName | ) |
Uses the fileName to read and restore a Jacobian tape. The file extension is used to determine wether the tape file is a binary (.dat) or text (.txt) file.
This overload is specifically for a Jacobian tape, where the EvalHandles are not required.
| T_Type | The CoDiPack type of the tape that is to be restored. |
The reader that will contain the read IO and restored tape.
< The extension is used to determine the file type.
| std::unique_ptr< TapeReaderInterface< T_Type > > codi::readTapeFile | ( | std::string const & | fileName, |
| std::vector< typename T_Type::Tape::EvalHandle > const & | evalHandles ) |
Uses the fileName to read and restore a primal value tape. The file extension is used to determine whether the tape file is a binary (.dat) or text (.txt) file.
This overload is specifically for a primal value tape, which requires the EvalHandles as an argument. They can be created with a call to createEvalHandles from the generated header file. See TapeReaderInterface for an example.
| T_Type | The CoDiPack type of the tape that is to be restored. |
The reader that will contain the read IO and restored tape.
< The extension is used to determine the file type.
| void codi::solveLinearSystem | ( | LSInterface | lsi, |
| typename LSInterface::Matrix & | A, | ||
| typename LSInterface::Vector & | b, | ||
| typename LSInterface::Vector & | x, | ||
| LinearSystemSolverHints | hints = LinearSystemSolverHints::ALL() ) |
Solve Ax=b and add an external function to the tape such that the appropriate AD modes are also solved.
| lsi | The implementation of LinearSystemInterface which defines the linear system solution algorithm. |
| A | The matrix. |
| b | The right hand side. |
| x | The solution. |
| hints | Hints for the AD algorithm. See function description. |
| PrimalTapeStatementFunctions const codi::DirectStatementEvaluatorStaticStore< Generator, Stmt >::staticStore |
| codi::Config::LowLevelFunctionToken codi::ExtFunc_matrixMatrixMultiplication< eigenStore, Type >::ID |
| InnerPrimalTapeStatementData const codi::InnerStatementEvaluatorStaticStore< Generator, Stmt >::staticStore |
1.13.2