CppAD: A C++ Algorithmic Differentiation Package  20130918
CppAD Namespace Reference

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)

Detailed Description

contains all the variables and functions defined by the CppAD package.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines