CppAD: A C++ Algorithmic Differentiation Package
20130918
|
contains all the variables and functions defined by the CppAD package. More...
Namespaces | |
namespace | ipopt |
namespace | optimize |
Classes | |
class | AD |
class | ADFun |
Class used to hold function objects. More... | |
class | ADTape |
Class used to hold tape that records AD<Base> operations. More... | |
class | atomic_base |
class | checkpoint |
class | discrete |
class | ErrorHandler |
class | index_sort_element |
Helper class used by index_sort. More... | |
class | IntegrateLast |
struct | internal_sparsity< bool > |
Specilization for bool elements. More... | |
struct | internal_sparsity< std::set< size_t > > |
Specilization for std::set<size_t> elements. More... | |
class | numeric_limits |
Default value for all undefined numeric_limits types. More... | |
class | numeric_limits< AD< Base > > |
Partial specialization that defines limits for for all AD types. More... | |
class | numeric_limits< double > |
class | numeric_limits< float > |
class | numeric_limits< std::complex< double > > |
class | numeric_limits< std::complex< float > > |
struct | ok_if_S_same_as_T |
struct | ok_if_S_same_as_T< T, T > |
class | old_atomic |
Class that actually implements the afun(id, ax, ay) calls. More... | |
class | omp_alloc |
class | player |
Class used to store and play back an operation sequence recording. More... | |
class | pod_vector |
A vector class with Type element that does not use element constructors or destructors when Type is Plain Old Data (pod). More... | |
class | recorder |
Class used to store an operation sequence while it is being recorded (the operation sequence is copied to the player class for playback). More... | |
class | RombergMul |
class | RombergMul< Fun, SizeVector, FloatVector, 1 > |
class | SliceLast |
class | sparse_hessian_work |
class used by SparseHessian to hold information so it does not need to be recomputed. More... | |
class | sparse_jacobian_work |
class used by SparseJacobian to hold information so it does not need to be recomputed. More... | |
class | sparse_list |
Vector of sets of positive integers, each set stored as a singly linked list. More... | |
class | sparse_pack |
Vector of sets of postivie integers, each set stored as a packed boolean array. More... | |
class | sparse_set |
Vector of sets of positive integers, each set stored as a standard set. More... | |
class | thread_alloc |
Capacity vector for memory allocation block sizes. More... | |
class | TrackElement |
class | user_atomic |
link so that user_atomic<Base>::clear() still works More... | |
class | VecAD |
Vector of AD objects that tracks indexing operations on the tape. More... | |
class | VecAD_reference |
Class used to hold a reference to an element of a VecAD object. More... | |
class | vector |
The CppAD Simple Vector template class. More... | |
class | vectorBool |
class | vectorBoolElement |
Class that is used to hold a non-constant element of a vector. More... | |
Typedefs | |
typedef CPPAD_TAPE_ADDR_TYPE | addr_t |
typedef CPPAD_TAPE_ID_TYPE | tape_id_t |
Enumerations | |
enum | CompareOp { CompareLt, CompareLe, CompareEq, CompareGe, CompareGt, CompareNe } |
enum | OpCode { AbsOp, AcosOp, AddpvOp, AddvvOp, AsinOp, AtanOp, BeginOp, CExpOp, ComOp, CosOp, CoshOp, CSkipOp, CSumOp, DisOp, DivpvOp, DivvpOp, DivvvOp, EndOp, ExpOp, InvOp, LdpOp, LdvOp, LogOp, MulpvOp, MulvvOp, ParOp, PowpvOp, PowvpOp, PowvvOp, PriOp, SignOp, SinOp, SinhOp, SqrtOp, StppOp, StpvOp, StvpOp, StvvOp, SubpvOp, SubvpOp, SubvvOp, TanOp, TanhOp, UserOp, UsrapOp, UsravOp, UsrrpOp, UsrrvOp, NumberOp } |
Type used to distinguish different AD< Base > atomic operations. More... | |
enum | tape_manage_job { tape_manage_new, tape_manage_delete, tape_manage_clear } |
Functions | |
double | abs (const double &x) |
float | abs (const float &x) |
template<class Base > | |
AD< Base > | abs (const AD< Base > &x) |
template<class Base > | |
AD< Base > | abs (const VecAD_reference< Base > &x) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | abs_geq (const AD< Base > &x, const AD< Base > &y) |
Check if absolute value of one AD<Base> is greater or equal another. | |
bool | abs_geq (const float &x, const float &y) |
bool | abs_geq (const double &x, const double &y) |
bool | abs_geq (const std::complex< double > &x, const std::complex< double > &y) |
bool | abs_geq (const std::complex< float > &x, const std::complex< float > &y) |
template<typename Float > | |
bool | AbsGeq (const Float &x, const Float &y) |
bool | AbsGeq (const std::complex< double > &x, const std::complex< double > &y) |
bool | AbsGeq (const std::complex< float > &x, const std::complex< float > &y) |
template<class Base > | |
AD< Base > | acos (const AD< Base > &u) |
template<class Base > | |
AD< Base > | asin (const AD< Base > &u) |
template<class Base > | |
AD< Base > | atan (const AD< Base > &u) |
float | atan2 (float x, float y) |
double | atan2 (double x, double y) |
template<class Base > | |
AD< Base > | atan2 (const AD< Base > &y, const AD< Base > &x) |
template<class Base > | |
AD< Base > | atan2 (const VecAD_reference< Base > &y, const AD< Base > &x) |
template<class Base > | |
AD< Base > | atan2 (const AD< Base > &y, const VecAD_reference< Base > &x) |
template<class Base > | |
AD< Base > | atan2 (const VecAD_reference< Base > &y, const VecAD_reference< Base > &x) |
template<class BAvector , class Fun > | |
void | BenderQuad (const BAvector &x, const BAvector &y, Fun fun, BAvector &g, BAvector &gx, BAvector &gxx) |
template<class NumericType > | |
NumericType | CheckNumericType (void) |
template<class Scalar , class Vector > | |
void | CheckSimpleVector (const Scalar &x, const Scalar &y) |
template<class Scalar , class Vector > | |
void | CheckSimpleVector (void) |
template<class VectorSet , class VectorSize > | |
void | color_general_cppad (VectorSet &pattern, const VectorSize &row, const VectorSize &col, CppAD::vector< size_t > &color) |
Determine which rows of a general sparse matrix can be computed together; i.e., do not have non-zero overlapping values. | |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION AD< Base > | CondExp (const AD< Base > &flag, const AD< Base > &if_true, const AD< Base > &if_false) |
double | CondExpOp (enum CompareOp cop, const double &left, const double &right, const double &exp_if_true, const double &exp_if_false) |
float | CondExpOp (enum CompareOp cop, const float &left, const float &right, const float &exp_if_true, const float &exp_if_false) |
std::complex< double > | CondExpOp (enum CppAD::CompareOp cop, const std::complex< double > &left, const std::complex< double > &right, const std::complex< double > &trueCase, const std::complex< double > &falseCase) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION AD< Base > | CondExpOp (enum CompareOp cop, const AD< Base > &left, const AD< Base > &right, const AD< Base > &if_true, const AD< Base > &if_false) |
std::complex< float > | CondExpOp (enum CppAD::CompareOp cop, const std::complex< float > &left, const std::complex< float > &right, const std::complex< float > &trueCase, const std::complex< float > &falseCase) |
template<class CompareType , class ResultType > | |
ResultType | CondExpTemplate (enum CompareOp cop, const CompareType &left, const CompareType &right, const ResultType &exp_if_true, const ResultType &exp_if_false) |
Template function to implement Conditional Expressions for simple types that have comparision operators. | |
template<class Base > | |
void | conditional_exp_op (size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t nc_taylor) |
Shared documentation for conditional expressions (not called). | |
template<class Base > | |
AD< Base > | cos (const AD< Base > &u) |
template<class Base > | |
AD< Base > | cosh (const AD< Base > &u) |
void | cppad_colpack_general (CppAD::vector< size_t > &color, size_t m, size_t n, const CppAD::vector< unsigned int * > &adolc_pattern) |
void | cppad_colpack_symmetric (CppAD::vector< size_t > &color, size_t n, const CppAD::vector< unsigned int * > &adolc_pattern) |
double | elapsed_seconds (void) |
Returns the elapsed number since the first call to this function. | |
template<class ADtype > | |
ADtype | epsilon (void) |
template<> | |
double | epsilon< double > (void) |
template<> | |
float | epsilon< float > (void) |
template<> | |
std::complex< double > | epsilon< std::complex< double > > (void) |
template<> | |
std::complex< float > | epsilon< std::complex< float > > (void) |
bool | EqualOpSeq (const double &x, const double &y) |
bool | EqualOpSeq (const float &x, const float &y) |
bool | EqualOpSeq (const std::complex< double > &x, const std::complex< double > &y) |
template<class Base > | |
bool | EqualOpSeq (const AD< Base > &u, const AD< Base > &v) |
bool | EqualOpSeq (const std::complex< float > &x, const std::complex< float > &y) |
float | erf (const float &x) |
double | erf (const double &x) |
template<class Base > | |
AD< Base > | erf (const AD< Base > &x) |
template<class Base > | |
AD< Base > | erf (const VecAD_reference< Base > &x) |
template<class Type > | |
Type | erf_template (const Type &x) |
template<class Base > | |
AD< Base > | exp (const AD< Base > &u) |
template<class Base , class Vector_set > | |
void | ForJacSweep (size_t n, size_t numvar, player< Base > *play, Vector_set &var_sparsity) |
Given the sparsity pattern for the independent variables, ForJacSweep computes the sparsity pattern for all the other variables. | |
template<class Base , class VectorSet > | |
void | ForSparseJacBool (bool transpose, size_t q, const VectorSet &r, VectorSet &s, size_t total_num_var, CppAD::vector< size_t > &dep_taddr, CppAD::vector< size_t > &ind_taddr, CppAD::player< Base > &play, sparse_pack &for_jac_sparsity) |
Calculate Jacobian vector of bools sparsity patterns using forward mode. | |
template<class Base , class VectorSet > | |
void | ForSparseJacSet (bool transpose, size_t q, const VectorSet &r, VectorSet &s, size_t total_num_var, CppAD::vector< size_t > &dep_taddr, CppAD::vector< size_t > &ind_taddr, CppAD::player< Base > &play, CPPAD_INTERNAL_SPARSE_SET &for_jac_sparsity) |
Calculate Jacobian vector of sets sparsity patterns using forward mode. | |
template<class Base > | |
size_t | forward0sweep (std::ostream &s_out, bool print, size_t n, size_t numvar, player< Base > *play, size_t J, Base *taylor, bool *cskip_op, pod_vector< addr_t > &var_by_load_op) |
Compute zero order forward mode Taylor coefficients. | |
template<class Base > | |
size_t | forward1sweep (std::ostream &s_out, const bool print, const size_t p, const size_t q, const size_t n, const size_t numvar, player< Base > *play, const size_t J, Base *taylor, bool *cskip_op, pod_vector< addr_t > &var_by_load_op) |
Compute arbitrary order forward mode Taylor coefficients. | |
template<class Base > | |
void | forward_abs_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = AbsOp. | |
template<class Base > | |
void | forward_abs_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = AbsOp. | |
template<class Base > | |
void | forward_acos_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = AcosOp. | |
template<class Base > | |
void | forward_acos_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = AcosOp. | |
template<class Base > | |
void | forward_addpv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = AddpvOp. | |
template<class Base > | |
void | forward_addpv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = AddpvOp. | |
template<class Base > | |
void | forward_addvv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = AddvvOp. | |
template<class Base > | |
void | forward_addvv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for result of op = AddvvOp. | |
template<class Base > | |
void | forward_asin_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = AsinOp. | |
template<class Base > | |
void | forward_asin_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = AsinOp. | |
template<class Base > | |
void | forward_atan_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Forward mode Taylor coefficient for result of op = AtanOp. | |
template<class Base > | |
void | forward_atan_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Zero order forward mode Taylor coefficient for result of op = AtanOp. | |
template<class Base > | |
void | forward_binary_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Prototype forward mode x op y (not used) | |
template<class Base > | |
void | forward_binary_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Prototype zero order forward mode x op y (not used) | |
template<class Base > | |
void | forward_comp_op_0 (size_t &count, const addr_t *arg, size_t num_par, const Base *parameter, size_t nc_taylor, Base *taylor) |
Zero order forward mode execution of op = CompOp. | |
template<class Base > | |
void | forward_cond_op (size_t p, size_t q, size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for op = CExpOp. | |
template<class Base > | |
void | forward_cond_op_0 (size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for op = CExpOp. | |
template<class Base > | |
void | forward_cos_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = CosOp. | |
template<class Base > | |
void | forward_cos_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = CosOp. | |
template<class Base > | |
void | forward_cosh_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = CoshOp. | |
template<class Base > | |
void | forward_cosh_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = CoshOp. | |
template<class Base > | |
void | forward_cskip_op_0 (size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t nc_taylor, Base *taylor, bool *cskip_op) |
Zero order forward mode execution of op = CSkipOp. | |
template<class Base > | |
void | forward_csum_op (size_t p, size_t q, size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = CsumOp. | |
template<class Base > | |
void | forward_dis_op_0 (size_t i_z, const addr_t *arg, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = DisOp. | |
template<class Base > | |
void | forward_divpv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = DivpvOp. | |
template<class Base > | |
void | forward_divpv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = DivpvOp. | |
template<class Base > | |
void | forward_divvp_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = DivvvOp. | |
template<class Base > | |
void | forward_divvp_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for result of op = DivvvOp. | |
template<class Base > | |
void | forward_divvv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = DivvvOp. | |
template<class Base > | |
void | forward_divvv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for result of op = DivvvOp. | |
template<class Base > | |
void | forward_exp_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Forward mode Taylor coefficient for result of op = ExpOp. | |
template<class Base > | |
void | forward_exp_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Zero order forward mode Taylor coefficient for result of op = ExpOp. | |
template<class Base > | |
void | forward_load_op (OpCode op, size_t p, size_t q, size_t i_z, const addr_t *arg, size_t nc_taylor, Base *taylor, const addr_t *var_by_load_op) |
Forward mode, except for zero order, for op = LdpOp or op = LdvOp. | |
template<class Base > | |
void | forward_load_op_0 (player< Base > *play, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor, bool *isvar_by_ind, size_t *index_by_ind, addr_t *var_by_load_op) |
Shared documentation for zero order forward mode implementation of op = LdpOp or LdvOp (not called). | |
template<class Base > | |
void | forward_load_p_op_0 (player< Base > *play, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor, bool *isvar_by_ind, size_t *index_by_ind, addr_t *var_by_load_op) |
Zero order forward mode implementation of op = LdpOp. | |
template<class Base > | |
void | forward_load_v_op_0 (player< Base > *play, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor, bool *isvar_by_ind, size_t *index_by_ind, addr_t *var_by_load_op) |
Zero order forward mode implementation of op = LdvOp. | |
template<class Base > | |
void | forward_log_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = LogOp. | |
template<class Base > | |
void | forward_log_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = LogOp. | |
template<class Base > | |
void | forward_mulpv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = MulpvOp. | |
template<class Base > | |
void | forward_mulpv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = MulpvOp. | |
template<class Base > | |
void | forward_mulvv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = MulvvOp. | |
template<class Base > | |
void | forward_mulvv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for result of op = MulvvOp. | |
template<class Base > | |
void | forward_par_op_0 (size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = ParOp. | |
template<class Base > | |
void | forward_pow_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Prototype for forward mode z = pow(x, y) (not used). | |
template<class Base > | |
void | forward_pow_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Prototype for zero order forward mode z = pow(x, y) (not used). | |
template<class Base > | |
void | forward_powpv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = PowpvOp. | |
template<class Base > | |
void | forward_powpv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = PowpvOp. | |
template<class Base > | |
void | forward_powvp_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = PowvvOp. | |
template<class Base > | |
void | forward_powvp_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for result of op = PowvvOp. | |
template<class Base > | |
void | forward_powvv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = PowvvOp. | |
template<class Base > | |
void | forward_powvv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for result of op = PowvvOp. | |
template<class Base > | |
void | forward_pri_0 (std::ostream &s_out, size_t i_z, const addr_t *arg, size_t num_text, const char *text, size_t num_par, const Base *parameter, size_t nc_taylor, const Base *taylor) |
Print operation for parameters; i.e., op = PriOp. | |
template<class Base > | |
void | forward_sign_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = SignOp. | |
template<class Base > | |
void | forward_sign_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = SignOp. | |
template<class Base > | |
void | forward_sin_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = SinOp. | |
template<class Base > | |
void | forward_sin_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = SinOp. | |
template<class Base > | |
void | forward_sinh_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = SinhOp. | |
template<class Base > | |
void | forward_sinh_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = SinhOp. | |
template<class Vector_set > | |
void | forward_sparse_jacobian_binary_op (size_t i_z, const addr_t *arg, Vector_set &sparsity) |
Forward mode Jacobian sparsity pattern for all binary operators. | |
template<class Vector_set > | |
void | forward_sparse_jacobian_cond_op (size_t i_z, const addr_t *arg, size_t num_par, Vector_set &sparsity) |
Compute forward Jacobian sparsity patterns for op = CExpOp. | |
template<class Vector_set > | |
void | forward_sparse_jacobian_csum_op (size_t i_z, const addr_t *arg, Vector_set &sparsity) |
Forward mode Jacobian sparsity pattern for CSumOp operator. | |
template<class Vector_set > | |
void | forward_sparse_jacobian_unary_op (size_t i_z, size_t i_x, Vector_set &sparsity) |
Forward mode Jacobian sparsity pattern for all unary operators. | |
template<class Vector_set > | |
void | forward_sparse_load_op (OpCode op, size_t i_z, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity) |
Forward mode sparsity operations for LdpOp and LdvOp. | |
template<class Vector_set > | |
void | forward_sparse_store_op (OpCode op, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity) |
Forward mode sparsity operations for StpvOp and StvvOp. | |
template<class Base > | |
void | forward_sqrt_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = SqrtOp. | |
template<class Base > | |
void | forward_sqrt_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = SqrtOp. | |
template<class Base > | |
void | forward_store_op_0 (size_t i_z, const addr_t *arg, size_t num_par, size_t nc_taylor, Base *taylor, bool *isvar_by_ind, size_t *index_by_ind) |
Shared documentation for zero order forward implementation of op = StppOp, StpvOp, StvpOp, or StvvOp (not called). | |
template<class Base > | |
void | forward_store_pp_op_0 (size_t i_z, const addr_t *arg, size_t num_par, size_t nc_taylor, Base *taylor, bool *isvar_by_ind, size_t *index_by_ind) |
Zero order forward mode implementation of op = StppOp. | |
template<class Base > | |
void | forward_store_pv_op_0 (size_t i_z, const addr_t *arg, size_t num_par, size_t nc_taylor, Base *taylor, bool *isvar_by_ind, size_t *index_by_ind) |
Zero order forward mode implementation of op = StpvOp. | |
template<class Base > | |
void | forward_store_vp_op_0 (size_t i_z, const addr_t *arg, size_t num_par, size_t nc_taylor, Base *taylor, bool *isvar_by_ind, size_t *index_by_ind) |
Zero order forward mode implementation of op = StvpOp. | |
template<class Base > | |
void | forward_store_vv_op_0 (size_t i_z, const addr_t *arg, size_t num_par, size_t nc_taylor, Base *taylor, bool *isvar_by_ind, size_t *index_by_ind) |
Zero order forward mode implementation of op = StvvOp. | |
template<class Base > | |
void | forward_subpv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = SubpvOp. | |
template<class Base > | |
void | forward_subpv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = SubpvOp. | |
template<class Base > | |
void | forward_subvp_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = SubvvOp. | |
template<class Base > | |
void | forward_subvp_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for result of op = SubvvOp. | |
template<class Base > | |
void | forward_subvv_op (size_t p, size_t q, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficients for result of op = SubvvOp. | |
template<class Base > | |
void | forward_subvv_op_0 (size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficients for result of op = SubvvOp. | |
template<class Base > | |
void | forward_tan_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = TanOp. | |
template<class Base > | |
void | forward_tan_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = TanOp. | |
template<class Base > | |
void | forward_tanh_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute forward mode Taylor coefficient for result of op = TanOp. | |
template<class Base > | |
void | forward_tanh_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Compute zero order forward mode Taylor coefficient for result of op = TanOp. | |
template<class Base > | |
void | forward_unary1_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Prototype for forward mode unary operator with one result (not used). | |
template<class Base > | |
void | forward_unary1_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Prototype for zero order forward mode unary operator with one result (not used). | |
template<class Base > | |
void | forward_unary2_op (size_t p, size_t q, size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Prototype for forward mode unary operator with two results (not used). | |
template<class Base > | |
void | forward_unary2_op_0 (size_t i_z, size_t i_x, size_t nc_taylor, Base *taylor) |
Prototype for zero order forward mode unary operator with two results (not used). | |
template<class Base , class Fun , class Vector > | |
bool | FunCheck (ADFun< Base > &f, Fun &g, const Vector &x, const Base &r, const Base &a) |
template<class Base > | |
bool | GreaterThanOrZero (const AD< Base > &x) |
Check if an AD<Base> is greater than or equal zero. | |
bool | GreaterThanOrZero (const double &x) |
bool | GreaterThanOrZero (const float &x) |
template<class Base > | |
bool | GreaterThanZero (const AD< Base > &x) |
Check if an AD<Base> is greater than zero. | |
bool | GreaterThanZero (const double &x) |
bool | GreaterThanZero (const float &x) |
template<class Value > | |
unsigned short | hash_code (const Value &value) |
General purpose hash code for an arbitrary value. | |
template<class Base > | |
unsigned short | hash_code (OpCode op, const addr_t *arg, size_t npar, const Base *par) |
Specialized hash code for a CppAD operator and its arguments. | |
template<class Vector > | |
bool | hasnan (const Vector &v) |
bool | IdenticalEqualPar (const double &x, const double &y) |
bool | IdenticalEqualPar (const float &x, const float &y) |
template<class Base > | |
bool | IdenticalEqualPar (const AD< Base > &x, const AD< Base > &y) |
Determine if two AD<Base> objects are equal, and must be equal during any tape playback. | |
bool | IdenticalEqualPar (const std::complex< double > &x, const std::complex< double > &y) |
bool | IdenticalEqualPar (const std::complex< float > &x, const std::complex< float > &y) |
template<class Base > | |
bool | IdenticalOne (const AD< Base > &x) |
Determine if an AD<Base> is equal to one, and must be equal one during any tape playback. | |
bool | IdenticalOne (const double &x) |
bool | IdenticalOne (const float &x) |
bool | IdenticalOne (const std::complex< double > &x) |
bool | IdenticalOne (const std::complex< float > &x) |
template<class Base > | |
bool | IdenticalPar (const AD< Base > &x) |
Determine if an AD<Base> object is a parameter, and could never have a different value during any tape playback. | |
bool | IdenticalPar (const double &x) |
bool | IdenticalPar (const float &x) |
bool | IdenticalPar (const std::complex< double > &x) |
bool | IdenticalPar (const std::complex< float > &x) |
template<class Base > | |
bool | IdenticalZero (const AD< Base > &x) |
Determine if an AD<Base> is equal to zero, and must be equal zero during any tape playback. | |
bool | IdenticalZero (const double &x) |
bool | IdenticalZero (const float &x) |
bool | IdenticalZero (const std::complex< double > &x) |
bool | IdenticalZero (const std::complex< float > &x) |
template<typename VectorAD > | |
void | Independent (VectorAD &x) |
template<class VectorKey , class VectorSize > | |
void | index_sort (const VectorKey &keys, VectorSize &ind) |
Compute the indices that sort a vector of keys. | |
template<class Base > | |
int | Integer (const AD< Base > &u) |
int | Integer (const double &x) |
int | Integer (const float &x) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION int | Integer (const VecAD_reference< Base > &x) |
int | Integer (const std::complex< double > &x) |
int | Integer (const std::complex< float > &x) |
template<class Type > | |
bool | is_pod (void) |
default value is false | |
template<> | |
bool | is_pod< bool > (void) |
system pod types so far: | |
template<> | |
bool | is_pod< char > (void) |
template<> | |
bool | is_pod< double > (void) |
template<> | |
bool | is_pod< float > (void) |
template<> | |
bool | is_pod< OpCode > (void) |
CppAD pod types so far: | |
template<> | |
bool | is_pod< size_t > (void) |
template<> | |
bool | is_pod< unsigned char > (void) |
template<> | |
bool | is_pod< unsigned int > (void) |
template<> | |
bool | is_pod< unsigned short int > (void) |
template<class Scalar > | |
bool | isnan (const Scalar &s) |
bool | isnan (const std::complex< double > &z) |
bool | isnan (const std::complex< float > &z) |
template<typename Base , typename Vector > | |
void | JacobianFor (ADFun< Base > &f, const Vector &x, Vector &jac) |
template<typename Base , typename Vector > | |
void | JacobianRev (ADFun< Base > &f, const Vector &x, Vector &jac) |
template<typename Float > | |
bool | LeqZero (const Float &x) |
bool | LeqZero (const std::complex< double > &x) |
bool | LeqZero (const std::complex< float > &x) |
template<class Base > | |
bool | LessThanOrZero (const AD< Base > &x) |
Check if an AD<Base> is less than or equal zero. | |
bool | LessThanOrZero (const double &x) |
bool | LessThanOrZero (const float &x) |
template<class Base > | |
bool | LessThanZero (const AD< Base > &x) |
Check if an AD<Base> is less than zero. | |
bool | LessThanZero (const double &x) |
bool | LessThanZero (const float &x) |
template<class Base > | |
AD< Base > | log (const AD< Base > &u) |
template<class Base > | |
AD< Base > | log10 (const AD< Base > &x) |
Compute the log of base 10 of x where has type AD<Base> | |
template<class Base > | |
AD< Base > | log10 (const VecAD_reference< Base > &x) |
template<class SizeVector , class FloatVector > | |
int | LuFactor (SizeVector &ip, SizeVector &jp, FloatVector &LU) |
template<typename SizeVector , typename FloatVector > | |
void | LuInvert (const SizeVector &ip, const SizeVector &jp, const FloatVector &LU, FloatVector &B) |
template<class SizeVector , class ADvector , class Base > | |
int | LuRatio (SizeVector &ip, SizeVector &jp, ADvector &LU, AD< Base > &ratio) |
template<typename Float , typename FloatVector > | |
int | LuSolve (size_t n, size_t m, const FloatVector &A, const FloatVector &B, FloatVector &X, Float &logdet) |
bool | memory_leak (size_t add_static=0) |
Function that checks allocator thread_alloc for misuse that results in memory leaks. | |
template<class Scalar > | |
Scalar | nan (const Scalar &zero) |
template<class Type > | |
bool | near_equal_isfinite (const Type &z1, const Type &z2, const Type &x, const Type &y) |
template<class Base > | |
bool | NearEqual (const AD< Base > &x, const AD< Base > &y, const Base &r, const Base &a) |
template<class Base > | |
bool | NearEqual (const Base &x, const AD< Base > &y, const Base &r, const Base &a) |
template<class Base > | |
bool | NearEqual (const AD< Base > &x, const Base &y, const Base &r, const Base &a) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | NearEqual (const VecAD_reference< Base > &x, const VecAD_reference< Base > &y, const Base &r, const Base &a) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | NearEqual (const VecAD_reference< Base > &x, const AD< Base > &y, const Base &r, const Base &a) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | NearEqual (const VecAD_reference< Base > &x, const Base &y, const Base &r, const Base &a) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | NearEqual (const AD< Base > &x, const VecAD_reference< Base > &y, const Base &r, const Base &a) |
template<class Type > | |
bool | NearEqual (const Type &x, const Type &y, const Type &r, const Type &a) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | NearEqual (const Base &x, const VecAD_reference< Base > &y, const Base &r, const Base &a) |
template<class Type > | |
bool | NearEqual (const std::complex< Type > &x, const std::complex< Type > &y, const Type &r, const Type &a) |
template<class Type > | |
bool | NearEqual (const std::complex< Type > &x, const Type &y, const Type &r, const Type &a) |
template<class Type > | |
bool | NearEqual (const Type &x, const std::complex< Type > &y, const Type &r, const Type &a) |
size_t | NumArg (OpCode op) |
Number of arguments for a specified operator. | |
size_t | NumRes (OpCode op) |
Number of variables resulting from the specified operation. | |
template<typename Scalar , typename Vector , typename Method > | |
Vector | OdeErrControl (Method &method, const Scalar &ti, const Scalar &tf, const Vector &xi, const Scalar &smin, const Scalar &smax, Scalar &scur, const Vector &eabs, const Scalar &erel, Vector &ef, Vector &maxabs, size_t &nstep) |
template<typename Scalar , typename Vector , typename Method > | |
Vector | OdeErrControl (Method &method, const Scalar &ti, const Scalar &tf, const Vector &xi, const Scalar &smin, const Scalar &smax, Scalar &scur, const Vector &eabs, const Scalar &erel, Vector &ef) |
template<typename Scalar , typename Vector , typename Method > | |
Vector | OdeErrControl (Method &method, const Scalar &ti, const Scalar &tf, const Vector &xi, const Scalar &smin, const Scalar &smax, Scalar &scur, const Vector &eabs, const Scalar &erel, Vector &ef, Vector &maxabs) |
template<typename Vector , typename Fun > | |
void | OdeGear (Fun &F, size_t m, size_t n, const Vector &T, Vector &X, Vector &e) |
template<class Scalar , class Vector , class Fun > | |
Vector | OdeGearControl (Fun &F, size_t M, const Scalar &ti, const Scalar &tf, const Vector &xi, const Scalar &smin, const Scalar &smax, Scalar &sini, const Vector &eabs, const Scalar &erel, Vector &ef, Vector &maxabs, size_t &nstep) |
template<class Scalar > | |
const std::set< Scalar > & | one_element_std_set (void) |
A standard set with one element. | |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | operator!= (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
AD< Base > | operator* (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
AD< Base > | operator+ (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
AD< Base > | operator+ (const VecAD_reference< Base > &right) |
template<class Base > | |
AD< Base > | operator- (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
AD< Base > | operator- (const VecAD_reference< Base > &right) |
template<class Base > | |
AD< Base > | operator/ (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | operator< (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
std::ostream & | operator<< (std::ostream &os, const VecAD< Base > &vec) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION std::ostream & | operator<< (std::ostream &os, const AD< Base > &x) |
Write an AD<Base> object to an output stream. | |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION std::ostream & | operator<< (std::ostream &os, const VecAD_reference< Base > &x) |
Write a VecAD_reference<Base> object to an output stream. | |
template<class Type > | |
std::ostream & | operator<< (std::ostream &os, const CppAD::vector< Type > &vec) |
output a vector | |
std::ostream & | operator<< (std::ostream &os, const vectorBool &v) |
output a vector | |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | operator<= (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | operator== (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | operator> (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION bool | operator>= (const AD< Base > &left, const AD< Base > &right) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION std::istream & | operator>> (std::istream &is, AD< Base > &x) |
Read an AD<Base> object from an input stream. | |
const char * | OpName (OpCode op) |
Fetch the name for a specified operation. | |
template<class BaseVector , class Fun > | |
int | opt_val_hes (const BaseVector &x, const BaseVector &y, Fun fun, BaseVector &jac, BaseVector &hes) |
Computing Jabobians and Hessians of Optimal Values. | |
template<class Base > | |
void | parallel_ad (void) |
Enable parallel execution mode with AD<Base> by initializing static variables that my be used. | |
template<class Base > | |
bool | Parameter (const VecAD< Base > &u) |
template<class Base > | |
bool | Parameter (const AD< Base > &u) |
template<class Type , class Vector > | |
Type | Poly (size_t k, const Vector &a, const Type &z) |
template<class Base > | |
AD< Base > | pow (const AD< Base > &x, const AD< Base > &y) |
template<class Type > | |
Type | pow (const Type &x, const int &n) |
double | pow (const double &x, const double &y) |
float | pow (const float &x, const float &y) |
template<class Base > | |
AD< Base > | pow (const AD< Base > &x, const VecAD_reference< Base > &y) |
template<class Base > | |
AD< Base > | pow (const VecAD_reference< Base > &x, const VecAD_reference< Base > &y) |
template<class Base > | |
AD< Base > | pow (const VecAD_reference< Base > &x, const AD< Base > &y) |
template<class Base > | |
AD< Base > | pow (const Base &x, const AD< Base > &y) |
template<class Base > | |
AD< Base > | pow (const Base &x, const VecAD_reference< Base > &y) |
template<class Base > | |
AD< Base > | pow (const AD< Base > &x, const Base &y) |
template<class Base > | |
AD< Base > | pow (const VecAD_reference< Base > &x, const Base &y) |
template<class Base > | |
AD< Base > | pow (const double &x, const AD< Base > &y) |
template<class Base > | |
AD< Base > | pow (const double &x, const VecAD_reference< Base > &y) |
template<class Base > | |
AD< Base > | pow (const AD< Base > &x, const double &y) |
template<class Base > | |
AD< Base > | pow (const VecAD_reference< Base > &x, const double &y) |
AD< double > | pow (const double &x, const AD< double > &y) |
AD< double > | pow (const double &x, const VecAD_reference< double > &y) |
AD< double > | pow (const AD< double > &x, const double &y) |
AD< double > | pow (const VecAD_reference< double > &x, const double &y) |
std::complex< double > | pow (const std::complex< double > &x, const std::complex< double > &y) |
template<class Base > | |
AD< Base > | pow (const int &x, const VecAD_reference< Base > &y) |
template<class Base > | |
AD< Base > | pow (const int &x, const AD< Base > &y) |
std::complex< float > | pow (const std::complex< float > &x, const std::complex< float > &y) |
template<class Base > | |
void | PrintFor (const AD< Base > &flag, const char *before, const AD< Base > &var, const char *after) |
template<class Base > | |
void | PrintFor (const char *before, const AD< Base > &var) |
template<class Base > | |
void | PrintFor (const char *before, const VecAD_reference< Base > &var) |
template<class Base > | |
void | PrintFor (const VecAD_reference< Base > &pos, const char *before, const VecAD_reference< Base > &var, const char *after) |
template<class Base > | |
void | PrintFor (const VecAD_reference< Base > &pos, const char *before, const AD< Base > &var, const char *after) |
template<class Base > | |
void | PrintFor (const AD< Base > &pos, const char *before, const VecAD_reference< Base > &var, const char *after) |
template<class Base , class Value > | |
void | printOp (std::ostream &os, const player< Base > *Rec, size_t i_op, size_t i_var, OpCode op, const addr_t *ind, size_t nfz, const Value *fz, size_t nrz, const Value *rz) |
Prints a single operator, its operands, and the corresponding result values. | |
template<class Type > | |
void | printOpField (std::ostream &os, const char *leader, const Type &value, size_t width) |
Prints a single field corresponding to an operator. | |
void | prototype_put_arg (void) |
Prototype for putting operation argument indices in the recording. | |
template<class Base > | |
void | reverse_abs_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = AbsOp. | |
template<class Base > | |
void | reverse_acos_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = AcosOp. | |
template<class Base > | |
void | reverse_addpv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivative for result of op = AddpvOp. | |
template<class Base > | |
void | reverse_addvv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = AddvvOp. | |
template<class Base > | |
void | reverse_asin_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = AsinOp. | |
template<class Base > | |
void | reverse_atan_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Reverse mode partial derivatives for result of op = AtanOp. | |
template<class Base > | |
void | reverse_binary_op (size_t d, size_t i_z, addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Prototype for reverse mode binary operator x op y (not used). | |
template<class Base > | |
void | reverse_cond_op (size_t d, size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode Taylor coefficients for op = CExpOp. | |
template<class Base > | |
void | reverse_cos_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = CosOp. | |
template<class Base > | |
void | reverse_cosh_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = CoshOp. | |
template<class Base > | |
void | reverse_csum_op (size_t d, size_t i_z, const addr_t *arg, size_t nc_partial, Base *partial) |
Compute reverse mode Taylor coefficients for result of op = CsumOp. | |
template<class Base > | |
void | reverse_divpv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivative for result of op = DivpvOp. | |
template<class Base > | |
void | reverse_divvp_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivative for result of op = DivvpOp. | |
template<class Base > | |
void | reverse_divvv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = DivvvOp. | |
template<class Base > | |
void | reverse_exp_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Reverse mode partial derivatives for result of op = ExpOp. | |
template<class Base > | |
void | reverse_load_op (OpCode op, size_t d, size_t i_z, const addr_t *arg, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial, const addr_t *var_by_load_op) |
Reverse mode for op = LdpOp or LdvOp. | |
template<class Base > | |
void | reverse_log_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = LogOp. | |
template<class Base > | |
void | reverse_mulpv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivative for result of op = MulpvOp. | |
template<class Base > | |
void | reverse_mulvv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = MulvvOp. | |
template<class Base > | |
void | reverse_pow_op (size_t d, size_t i_z, addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Prototype for reverse mode z = pow(x, y) (not used). | |
template<class Base > | |
void | reverse_powpv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivative for result of op = PowpvOp. | |
template<class Base > | |
void | reverse_powvp_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivative for result of op = PowvpOp. | |
template<class Base > | |
void | reverse_powvv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = PowvvOp. | |
template<class Base > | |
void | reverse_sign_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = SignOp. | |
template<class Base > | |
void | reverse_sin_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = SinOp. | |
template<class Base > | |
void | reverse_sinh_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = SinhOp. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_addsub_op (size_t i_z, const addr_t *arg, bool *jac_reverse, Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity) |
Reverse mode Hessian sparsity pattern for add and subtract operators. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_binary_op (size_t i_z, const addr_t *arg, bool *jac_reverse, Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity) |
Prototype for reverse mode Hessian sparsity binary operators. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_cond_op (size_t i_z, const addr_t *arg, size_t num_par, bool *jac_reverse, Vector_set &hes_sparsity) |
Compute reverse Hessian sparsity patterns for op = CExpOp. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_csum_op (size_t i_z, const addr_t *arg, bool *rev_jacobian, Vector_set &rev_hes_sparsity) |
Reverse mode Hessian sparsity pattern for CSumOp operator. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_div_op (size_t i_z, const addr_t *arg, bool *jac_reverse, Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity) |
Reverse mode Hessian sparsity pattern for division operator. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_linear_unary_op (size_t i_z, size_t i_x, bool *rev_jacobian, Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity) |
Reverse mode Hessian sparsity pattern for linear unary operators. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_load_op (OpCode op, size_t i_z, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity, bool *var_jacobian, bool *vecad_jacobian) |
Reverse mode Hessian sparsity operations for LdpOp and LdvOp. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_mul_op (size_t i_z, const addr_t *arg, bool *jac_reverse, Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity) |
Reverse mode Hessian sparsity pattern for multiplication operator. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_nonlinear_unary_op (size_t i_z, size_t i_x, bool *rev_jacobian, Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity) |
Reverse mode Hessian sparsity pattern for non-linear unary operators. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_pow_op (size_t i_z, const addr_t *arg, bool *jac_reverse, Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity) |
Reverse mode Hessian sparsity pattern for power function. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_store_op (OpCode op, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity, bool *var_jacobian, bool *vecad_jacobian) |
Reverse mode sparsity operations for StpvOp and StvvOp. | |
template<class Vector_set > | |
void | reverse_sparse_hessian_unary_op (size_t i_z, size_t i_x, bool *rev_jacobian, Vector_set &for_jac_sparsity, Vector_set &rev_hes_sparsity) |
Prototype for reverse mode Hessian sparsity unary operators. | |
template<class Vector_set > | |
void | reverse_sparse_jacobian_binary_op (size_t i_z, const addr_t *arg, Vector_set &sparsity) |
Reverse mode Jacobian sparsity pattern for all binary operators. | |
template<class Vector_set > | |
void | reverse_sparse_jacobian_cond_op (bool nz_compare, size_t i_z, const addr_t *arg, size_t num_par, Vector_set &sparsity) |
Compute reverse Jacobian sparsity patterns for op = CExpOp. | |
template<class Vector_set > | |
void | reverse_sparse_jacobian_csum_op (size_t i_z, const addr_t *arg, Vector_set &sparsity) |
Reverse mode Jacobian sparsity pattern for CSumOp operator. | |
template<class Vector_set > | |
void | reverse_sparse_jacobian_load_op (OpCode op, size_t i_z, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity) |
Reverse mode Jacobian sparsity operations for LdpOp and LdvOp. | |
template<class Vector_set > | |
void | reverse_sparse_jacobian_store_op (OpCode op, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity) |
Reverse mode sparsity operations for StpvOp and StvvOp. | |
template<class Vector_set > | |
void | reverse_sparse_jacobian_unary_op (size_t i_z, size_t i_x, Vector_set &sparsity) |
Reverse mode Jacobian sparsity pattern for all unary operators. | |
template<class Base > | |
void | reverse_sqrt_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = SqrtOp. | |
template<class Base > | |
void | reverse_subpv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivative for result of op = SubpvOp. | |
template<class Base > | |
void | reverse_subvp_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivative for result of op = SubvpOp. | |
template<class Base > | |
void | reverse_subvv_op (size_t d, size_t i_z, const addr_t *arg, const Base *parameter, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = SubvvOp. | |
template<class Base > | |
void | reverse_tan_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = TanOp. | |
template<class Base > | |
void | reverse_tanh_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Compute reverse mode partial derivatives for result of op = TanOp. | |
template<class Base > | |
void | reverse_unary1_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Prototype for reverse mode unary operator with one result (not used). | |
template<class Base > | |
void | reverse_unary2_op (size_t d, size_t i_z, size_t i_x, size_t nc_taylor, const Base *taylor, size_t nc_partial, Base *partial) |
Prototype for reverse mode unary operator with two results (not used). | |
template<class Base > | |
void | ReverseSweep (size_t d, size_t n, size_t numvar, player< Base > *play, size_t J, const Base *Taylor, size_t K, Base *Partial, bool *cskip_op, const pod_vector< addr_t > &var_by_load_op) |
Compute derivative of arbitrary order forward mode Taylor coefficients. | |
template<class Base , class Vector_set > | |
void | RevHesSweep (size_t n, size_t numvar, player< Base > *play, Vector_set &for_jac_sparse, bool *RevJac, Vector_set &rev_hes_sparse) |
Given the forward Jacobian sparsity pattern for all the variables, and the reverse Jacobian sparsity pattern for the dependent variables, RevHesSweep computes the Hessian sparsity pattern for all the independent variables. | |
template<class Base , class Vector_set > | |
void | RevJacSweep (bool nz_compare, size_t n, size_t numvar, player< Base > *play, Vector_set &var_sparsity) |
Given the sparsity pattern for the dependent variables, RevJacSweep computes the sparsity pattern for all the independent variables. | |
template<class Base , class VectorSet , class Sparsity > | |
void | RevSparseHesBool (bool transpose, size_t q, const VectorSet &s, VectorSet &h, size_t total_num_var, CppAD::vector< size_t > &dep_taddr, CppAD::vector< size_t > &ind_taddr, CppAD::player< Base > &play, Sparsity &for_jac_sparsity) |
Calculate Hessian sparsity patterns using reverse mode. | |
template<class Base , class VectorSet , class Sparsity > | |
void | RevSparseHesSet (bool transpose, size_t q, const VectorSet &s, VectorSet &h, size_t total_num_var, CppAD::vector< size_t > &dep_taddr, CppAD::vector< size_t > &ind_taddr, CppAD::player< Base > &play, Sparsity &for_jac_sparsity) |
Calculate Hessian sparsity patterns using reverse mode. | |
template<class Base , class VectorSet > | |
void | RevSparseJacBool (bool transpose, bool nz_compare, size_t q, const VectorSet &r, VectorSet &s, size_t total_num_var, CppAD::vector< size_t > &dep_taddr, CppAD::vector< size_t > &ind_taddr, CppAD::player< Base > &play) |
Calculate Jacobian vector of bools sparsity patterns using reverse mode. | |
template<class Base , class VectorSet > | |
void | RevSparseJacSet (bool transpose, bool nz_compare, size_t q, const VectorSet &r, VectorSet &s, size_t total_num_var, CppAD::vector< size_t > &dep_taddr, CppAD::vector< size_t > &ind_taddr, CppAD::player< Base > &play) |
Calculate Jacobian vector of sets sparsity patterns using reverse mode. | |
template<class Fun , class Float > | |
Float | RombergOne (Fun &F, const Float &a, const Float &b, size_t n, size_t p, Float &e) |
template<typename Scalar , typename Vector , typename Fun > | |
Vector | Rosen34 (Fun &F, size_t M, const Scalar &ti, const Scalar &tf, const Vector &xi) |
template<typename Scalar , typename Vector , typename Fun > | |
Vector | Rosen34 (Fun &F, size_t M, const Scalar &ti, const Scalar &tf, const Vector &xi, Vector &e) |
template<typename Scalar , typename Vector , typename Fun > | |
Vector | Runge45 (Fun &F, size_t M, const Scalar &ti, const Scalar &tf, const Vector &xi) |
template<typename Scalar , typename Vector , typename Fun > | |
Vector | Runge45 (Fun &F, size_t M, const Scalar &ti, const Scalar &tf, const Vector &xi, Vector &e) |
template<class Base > | |
AD< Base > | sign (const AD< Base > &x) |
template<class Base > | |
AD< Base > | sign (const VecAD_reference< Base > &x) |
double | sign (const double &x) |
float | sign (const float &x) |
template<class Base > | |
AD< Base > | sin (const AD< Base > &u) |
template<class Base > | |
AD< Base > | sinh (const AD< Base > &u) |
template<class Vector_set > | |
void | sparse_conditional_exp_op (size_t i_z, const addr_t *arg, size_t num_par) |
Shared documentation for conditional expression sparse operations (not called). | |
template<class Vector_set > | |
void | sparse_load_op (OpCode op, size_t i_z, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity) |
Shared documentation for sparsity operations corresponding to op = LdpOp or LdvOp (not called). | |
template<class Vector_set > | |
void | sparse_store_op (OpCode op, const addr_t *arg, size_t num_combined, const size_t *combined, Vector_set &var_sparsity, Vector_set &vecad_sparsity) |
Shared documnetation for sparsity operations corresponding to op = StpvOp or StvvOp (not called). | |
template<class VectorSet > | |
void | sparsity_user2internal (sparse_set &internal, const VectorSet &user, size_t n_row, size_t n_col, bool transpose) |
Copy a user vector of sets sparsity pattern to an internal sparse_set object. | |
template<class VectorBool > | |
void | sparsity_user2internal (sparse_pack &internal, const VectorBool &user, size_t n_row, size_t n_col, bool transpose) |
Copy a user vector of bools sparsity pattern to an internal sparse_pack object. | |
template<class VectorSet > | |
void | sparsity_user2internal (sparse_list &internal, const VectorSet &user, size_t n_row, size_t n_col, bool transpose) |
Copy a user vector of sets sparsity pattern to an internal sparse_list object. | |
template<class Vector > | |
Vector | speed_test (void test(size_t size, size_t repeat), const Vector &size_vec, double time_min) |
void | SpeedTest (std::string Test(size_t size, size_t repeat), size_t first, int inc, size_t last) |
void | SpeedTestNdigit (size_t value, size_t &ndigit, size_t &pow10) |
template<class Base > | |
AD< Base > | sqrt (const AD< Base > &u) |
template<class Base > | |
AD< Base > | tan (const AD< Base > &u) |
template<class Test > | |
double | time_test (Test test, double time_min) |
Preform one wall clock execution timing test. | |
template<class Test > | |
double | time_test (Test test, double time_min, size_t test_size) |
Preform one wall clock execution timing test. | |
size_t | TrackCount (const char *file, int line) |
template<class Type > | |
void | TrackDelVec (const char *file, int line, Type *oldptr) |
void | TrackError (const char *routine, const char *file, int line, const char *msg) |
template<class Type > | |
Type * | TrackExtend (const char *file, int line, size_t newlen, size_t ncopy, Type *oldptr) |
template<class Type > | |
Type * | TrackNewVec (const char *file, int line, size_t len, Type *) |
template<class Scalar > | |
const std::set< Scalar > & | two_element_std_set (void) |
A standard set with a two elements. | |
template<class Base > | |
Base | Value (const AD< Base > &x) |
template<class Base > | |
AD< Base > | Var2Par (const AD< Base > &u) |
template<class Base > | |
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION AD< Base > | Var2Par (const VecAD_reference< Base > &x) |
template<class Base > | |
bool | Variable (const VecAD< Base > &u) |
template<class Base > | |
bool | Variable (const AD< Base > &u) |
contains all the variables and functions defined by the CppAD package.