fvar.hpp File Reference

#include <dos.h>
#include <pc.h>
#include <fstream.h>
#include <stdio.h>
#include <math.h>
#include <iomanip.h>
#include <dfpool.h>
#include <stdlib.h>
#include <adstring.hpp>
#include <windows.h>

Include dependency graph for fvar.hpp:

Go to the source code of this file.

Classes

class smart_counter

class double_and_int

class preshowpoint

class prefixed

class prescientific

class kkludge_object

class humungous_pointer

class vector_shape_pool

class vector_shape

class ptr_vector

class preivector

class ivector

class lvector_position

class lvector

class dependent_variables_information

class gradient_structure

class gradient_structure::arrmemblerr

class dvect_ptr_ptr

class dlink

class dlist

class grad_stack_entry

class grad_stack

class indvar_offset_list

class prevariable

class dvariable

class funnel_dvariable

class vector_shapex

class predvector

class predvar_vector

class dvector

Fundamental container class for a vector of double precision floating point numbers. More...

class independent_variables

class mat_shape

class mat_shapex

class arr_list

class arr_link

class dvar_vector

class fvar_ptr

class dvar_matrix

class dmatrix

class imatrix_position

class imatrix

class fmm_control

class sdmatrix

class dfsdmat

class fmm

class fmmt1

class uostream

class uistream

class fmmc

class three_array_shape

class dmatrix_ptr

class dvar_matrix_ptr

class d3_array

class i3_array

class dvar3_array

class prevariable_position

class dvar_vector_position

class dvar_matrix_position

class dmatrix_position

class d3_array_position

class dvector_position

class ivector_position

class DF_FILE

class fmmq

class vcubic_spline_function

class cubic_spline_function

class function_tweaker

class dfunction_tweaker

class four_array_shape

class d4_array

class dvar4_array

class fmmt

class i4_array

class i5_array

class d5_array

class dvar5_array

class d6_array

class dvar6_array

class d7_array

class dvar7_array

class lmatrix_position

class lmatrix

class adkludge

class pre_index_type

class ad_integer

class index_guts

class index_type

class number_index

class vector_index

class matrix_index

class i3_index

class i4_index

class vector_range_exception

class spdll_exception

class random_number_generator

class banded_symmetric_dmatrix

class banded_symmetric_dvar_matrix

class banded_lower_triangular_dmatrix

class banded_lower_triangular_dvar_matrix

class pre_column_print

class pre_zero_print

class pre_double_index_type

class ad_double

class double_index_guts

class double_index_type

class double_index

class dvector_index

class dmatrix_index

class d3_index

class function_minimizer_exception

class ad_comm

class adtimer

class lower_triangular_dmatrix

class sing_val_decomp

class multi_index

Defines

#define USE_VECTOR_SHAPE_POOL

#define __NUMBERVECTOR__

#define ADUNCONST(type, obj)   type & obj = (type&) _##obj;

#define my_off_t   long int

#define my_u_off_t   unsigned long int

#define MFCL2_CONSTRUCTORS

#define DOS386

#define __USE_IOSTREAM__

#define BOR_CONST

#define USE_HIGHER_ARRAYS

#define BOR_CONST   const

#define AD_LONG_INT   long int

#define AD_VERSION   7

#define CGNU_DOUBLE   double

#define USE_CONST

#define _CONST   const

#define BEGIN_MINIMIZATION(nvar, objective_function, ind_vars, gradient, cntrl)

#define END_MINIMIZATION(nvar, gradient)

#define AD_SET_DERIVATIVES1(depvar, indvar, df)

#define AD_SET_DERIVATIVES2(depvar, indvar1, df1, indvar2, df2)

#define AD_SET_DERIVATIVES3(depvar, indvar1, df1, indvar2, df2, indvar3, df3)

#define AD_SET_DERIVATIVES4(depvar, indvar1, df1, indvar2, df2, indvar3, df3, indvar4, df4)

#define ADJOINT_CODE(x)   gradient_structure::GRAD_STACK1->set_gradient_stack(x);

Typedefs

typedef int(* fptr )(const char *format,...)

typedef void(* exitptr )(int)

Functions

void spdll_exit (int)

dvector restore_dvar_vector_derivatives (void)

void default_evaluation (void)

void default_evaluation0 (void)

void default_evaluation1 (void)

void default_evaluation1m (void)

void default_evaluation2 (void)

void default_evaluation3 (void)

void default_evaluation4 (void)

void default_evaluation4m (void)

void myheapcheck (char *)

void RETURN_ARRAYS_INCREMENT (void)

void RETURN_ARRAYS_DECREMENT (void)

void * farptr_norm (void *)

long int farptr_tolong (void *)

long int _farptr_tolong (void *)

void denormalize_ptr (void *, unsigned int byte_offset)

ostream & operator<< (const ostream &ostr, const dmatrix &z)

istream & operator>> (const istream &istr, const dmatrix &z)

uostream & operator<< (const uostream &ostr, const dmatrix &z)

uistream & operator>> (const uistream &istr, const dmatrix &z)

ostream & operator<< (const ostream &ostr, const d3_array &z)

istream & operator>> (const istream &istr, const d3_array &z)

uostream & operator<< (const uostream &ostr, const d3_array &z)

uistream & operator>> (const uistream &istr, const d3_array &z)

ostream & operator<< (const ostream &ostr, const dvar3_array &z)

istream & operator>> (const istream &istr, const dvar3_array &z)

uostream & operator<< (const uostream &ostr, const dvar3_array &z)

uistream & operator>> (const uistream &istr, const dvar3_array &z)

ostream & operator<< (const ostream &ostr, const ivector &z)

istream & operator>> (const istream &istr, const ivector &z)

uostream & operator<< (const uostream &ostr, const ivector &z)

uistream & operator>> (const uistream &istr, const ivector &z)

ostream & operator<< (const ostream &ostr, const lvector &z)

istream & operator>> (const istream &istr, const lvector &z)

uostream & operator<< (const uostream &ostr, const lvector &z)

uistream & operator>> (const uistream &istr, const lvector &z)

ostream & operator<< (const ostream &ostr, const dvector &z)

istream & operator>> (const istream &istr, const dvector &z)

uostream & operator<< (const uostream &ostr, const dvector &z)

uistream & operator>> (const uistream &istr, const dvector &z)

ostream & operator<< (const ostream &ostr, const dvar_vector &z)

istream & operator>> (const istream &istr, const dvar_vector &z)

uostream & operator<< (const uostream &ostr, const dvar_vector &z)

uistream & operator>> (const uistream &istr, const dvar_vector &z)

ostream & operator<< (const ostream &ostr, const dvar_matrix &z)

istream & operator>> (const istream &istr, const dvar_matrix &z)

uostream & operator<< (const uostream &ostr, const dvar_matrix &z)

uistream & operator>> (const uistream &istr, const dvar_matrix &z)

ostream & operator<< (const ostream &ostr, const prevariable &z)

istream & operator>> (const istream &istr, const prevariable &z)

uostream & operator<< (const uostream &ostr, const prevariable &z)

uistream & operator>> (const uistream &istr, const prevariable &z)

ostream & setscientific (const ostream &s)

preshowpoint setshowpoint (void)

ostream & operator<< (const ostream &, preshowpoint)

ostream & setfixed (const ostream &s)

prefixed setfixed (void)

ostream & operator<< (const ostream &, prefixed)

prescientific setscientific (void)

ostream & operator<< (const ostream &, prescientific)

istream & operator>> (const istream &istr, const imatrix &z)

ostream & operator<< (const ostream &istr, const imatrix &z)

istream & operator>> (const istream &istr, const i3_array &z)

ostream & operator<< (const ostream &istr, const i3_array &z)

ivector operator+ (const ivector &v, const ivector &w)

ivector operator- (const ivector &v, const ivector &w)

ivector operator+ (const ivector &v, int w)

ivector operator- (const ivector &v, int w)

ivector operator+ (int v, const ivector &w)

ivector operator- (int v, const ivector &w)

long int sum (const lvector &)

dvar_vector_position restore_dvar_vector_position (void)

dvector restore_dvar_vector_value (const dvar_vector_position &tmp)

void arr_free (double_and_int *)

double_and_int * arr_new (unsigned int sz)

void jacobcalc (int nvar, const dmatrix &g)

void jacobcalc (int nvar, const ofstream &ofs)

void jacobcalc (int nvar, const uostream &ofs)

void default_evaluation3ind (void)

void gradfree (dlink *)

double & value (const prevariable &v1)

double * address (const prevariable &v1)

prevariable & operator<< (const prevariable &v1, const prevariable &v2)

dvar_vector & operator<< (const dvar_vector &v1, const dvar_vector &v2)

dvar_matrix & operator<< (const dvar_matrix &v1, const dvar_matrix &v2)

dvar_vector operator* (const dvar_vector &t1, double x)

dvar_vector operator/ (double x, const dvar_vector &t1)

dvar_vector operator/ (const dvar_vector &t1, double x)

dvar_vector operator+ (double x, const dvar_vector &t1)

dvar_vector operator+ (const dvar_vector &t1, double x)

dvar_vector operator- (double x, const dvar_vector &t1)

dvar_vector operator- (const dvar_vector &t1, double x)

dvar_vector operator- (const dvar_vector &t1)

dvar_vector operator* (const dvar_vector &t1, const prevariable &x)

dvar_vector operator/ (const prevariable &x, const dvar_vector &t1)

dvar_vector operator/ (const dvar_vector &t1, const prevariable &x)

dvar_vector operator+ (const prevariable &x, const dvar_vector &t1)

dvar_vector operator+ (const dvar_vector &t1, const prevariable &x)

dvar_vector operator- (const prevariable &x, const dvar_vector &t1)

dvar_vector operator- (const dvar_vector &t1, const prevariable &x)

dvar_vector operator- (const dvector &t1, const prevariable &x)

dvar_vector operator* (const dvector &t1, const prevariable &x)

dvar_vector operator* (const prevariable &x, const dvector &t1)

dvector operator* (const dvector &t1, double x)

dvector operator/ (double x, const dvector &t1)

dvector operator/ (const dvector &t1, double x)

dvector operator+ (double x, const dvector &t1)

dvector operator+ (const dvector &t1, double x)

dvector operator- (double x, const dvector &t1)

dvector operator- (const dvector &t1, double x)

dvector operator- (const dvector &t1)

double max (const dmatrix &)

int max (const imatrix &)

double max (const dvector &)

dvariable max (const dvar_vector &)

dvariable min (const dvar_vector &)

dmatrix symmetrize (const dmatrix &m1)

dvector eigenvalues (const dmatrix &m1)

dmatrix eigenvectors (const dmatrix &m1)

dmatrix eigenvectors (const dmatrix &m1, const dvector &eigenvalues)

dvar_matrix symmetrize (const dvar_matrix &m1)

dvar_vector eigenvalues (const dvar_matrix &m1)

dvar_matrix eigenvectors (const dvar_matrix &m1)

dmatrix outer_prod (const dvector &t1, const dvector &t2)

dvar_matrix outer_prod (const dvar_vector &t1, const dvar_vector &t2)

dvar_matrix outer_prod (const dvector &t1, const dvar_vector &t2)

dvar_matrix outer_prod (const dvar_vector &t1, const dvector &t2)

dmatrix operator* (double x, const dmatrix &m)

dmatrix operator* (const dmatrix &m, double d)

dmatrix operator/ (const dmatrix &m, double d)

dmatrix operator/ (double d, const dmatrix &m)

dmatrix operator+ (double x, const dmatrix &m)

dvar_matrix operator+ (const dvariable &x, const dmatrix &m)

dvar_matrix operator- (const dvariable &x, const dmatrix &m)

dmatrix operator+ (const dmatrix &m, double d)

dmatrix operator- (double x, const dmatrix &m)

dmatrix operator- (const dmatrix &m, double d)

dvar_matrix operator/ (const dvar_matrix &m, const prevariable &x)

dvar_matrix operator/ (const dmatrix &m, const prevariable &x)

dvar_matrix operator/ (const dvar_matrix &m, double x)

dvar_matrix operator/ (double x, const dvar_matrix &m)

dvar_matrix operator/ (const prevariable &x, const dvar_matrix &m)

dvar_matrix operator* (const prevariable &x, const dmatrix &m)

dvar_matrix operator* (const dvar_matrix &m, const prevariable &x)

dvar_matrix operator* (const prevariable &x, const dvar_matrix &m)

dvar_matrix operator* (double x, const dvar_matrix &m)

dvector operator & (const dvector &t1, const dvector &t2)

dvar_vector operator & (const dvar_vector &t1, const dvar_vector &t2)

ivector column (const imatrix &m, int i)

dvector extract_column (const dmatrix &m, int i)

dvector column (const dmatrix &m, int i)

dvector extract_row (const dmatrix &m, int j)

dvector row (const dmatrix &m, int j)

dvar_vector extract_column (const dvar_matrix &m, int i)

dvar_vector column (const dvar_matrix &m, int i)

dvector column_value (const dvar_matrix &m, int i)

dvar_vector extract_row (const dvar_matrix &m, int j)

dvar_vector row (const dvar_matrix &m, int j)

dvector sin (const dvector &t1)

dvector sqrt (const dvector &t1)

dvector sqr (const dvector &t1)

dvector exp (const dvector &t1)

dvector mfexp (const dvector &t1)

dvector mfexp (const dvector &t1, double d)

dvector atan (const dvector &t1)

dvector tan (const dvector &t1)

dvector tanh (const dvector &t1)

dvector atan2 (const dvector &t1, const dvector &t2)

dvector atan2 (const dvector &t1, double t2)

dvector atan2 (double t1, const dvector &t2)

dvector acos (const dvector &t1)

dvector asin (const dvector &t1)

dvector cos (const dvector &t1)

dvector sinh (const dvector &t1)

dvector cosh (const dvector &t1)

dvector log (const dvector &t1)

dvector log10 (const dvector &t1)

dvector pow (const dvector &t1, double)

dvector pow (const dvector &t1, int)

dvector pow (double, const dvector &t1)

ivector pow (const ivector &v1, int x)

ivector pow (int x, const ivector &v1)

dvar_vector sin (const dvar_vector &t1)

dvar_vector sqrt (const dvar_vector &t1)

dvar_vector sqr (const dvar_vector &t1)

dvar_vector exp (const dvar_vector &t1)

dvar_vector mfexp (const dvar_vector &t1)

dvar_vector mfexp (const dvar_vector &t1, double d)

dvar_vector atan (const dvar_vector &t1)

dvar_vector tan (const dvar_vector &t1)

dvar_vector tanh (const dvar_vector &t1)

dvar_vector atan2 (const dvar_vector &t1, const dvar_vector &t2)

dvar_vector atan2 (const dvar_vector &t1, double t2)

dvar_vector atan2 (double t1, const dvar_vector &t2)

dvar_vector acos (const dvar_vector &t1)

dvar_vector asin (const dvar_vector &t1)

dvar_vector cos (const dvar_vector &t1)

dvar_vector sinh (const dvar_vector &t1)

dvar_vector cosh (const dvar_vector &t1)

dvar_vector log (const dvar_vector &t1)

dvar_vector log10 (const dvar_vector &t1)

dvar_vector pow (const dvar_vector &, const dvar_vector &t1)

dvar_vector pow (const dvar_vector &, const dvector &t1)

dvar_vector pow (const dvector &, const dvar_vector &t1)

dvar_vector pow (const dvar_vector &t1, double)

dvar_vector pow (const dvar_vector &t1, int)

dvar_vector pow (const dvar_vector &t1, const prevariable &)

dvar_vector pow (const dvector &t1, const prevariable &)

dvar_vector pow (const prevariable &, const dvar_vector &t1)

dmatrix exp (const dmatrix &m)

dmatrix mfexp (const dmatrix &m)

dmatrix mfexp (const dmatrix &m, double d)

dmatrix sqrt (const dmatrix &m)

dmatrix sqr (const dmatrix &m)

dmatrix pow (const dmatrix &m, double e)

dmatrix pow (const dmatrix &m, int e)

dmatrix log (const dmatrix &m)

dmatrix sin (const dmatrix &m)

dmatrix cos (const dmatrix &m)

dmatrix tan (const dmatrix &m)

dmatrix elem_div (const dmatrix &m, const dmatrix &m2)

dmatrix elem_prod (const dmatrix &m, const dmatrix &m2)

dvar_matrix exp (const dvar_matrix &m)

dvar_matrix mfexp (const dvar_matrix &m)

dvar_matrix mfexp (const dvar_matrix &m, double d)

dvar_matrix sqrt (const dvar_matrix &m)

dvar_matrix sqr (const dvar_matrix &m)

dvar_matrix log (const dvar_matrix &m)

dvar_matrix sin (const dvar_matrix &m)

dvar_matrix cos (const dvar_matrix &m)

dvar_matrix tan (const dvar_matrix &m)

dvar_matrix pow (const dvar_matrix &m, double e)

dvar_matrix pow (const dvar_matrix &m, const prevariable &e)

dvar_matrix pow (const dmatrix &m, const prevariable &e)

dvar_matrix pow (const dvar_matrix &m, int e)

dvar_matrix elem_prod (const dvar_matrix &m, const dvar_matrix &m2)

dvar_matrix elem_prod (const dvar_matrix &m, const dmatrix &m2)

dvar_matrix elem_prod (const dmatrix &m, const dvar_matrix &m2)

dvar_matrix elem_div (const dvar_matrix &m, const dvar_matrix &m2)

dvar_matrix elem_div (const dvar_matrix &m, const dmatrix &m2)

dvar_matrix elem_div (const dmatrix &m, const dvar_matrix &m2)

int min (const ivector &t1)

int max (const ivector &t1)

int Max (const ivector &t1)

double mfexp (double)

double mfexp (double, double bound)

dvariable mfexp (const prevariable &)

dvariable mfexp (const prevariable &, double bound)

dvariable dfatan1 (dvariable, double, double, const prevariable &fpen)

double boundp (double x, double fmin, double fmax, const double &fpen)

double boundp (double x, double fmin, double fmax)

dvariable boundp (const prevariable &x, double fmin, double fmax, const prevariable &fpen)

dvariable boundp (const prevariable &x, double fmin, double fmax, const prevariable &fpen, double s)

double nd2fboundp (double x, double minb, double maxb, const double &pen)

double boundpin (double x, double fmin, double fmax)

double boundpin (const prevariable &x, double fmin, double fmax)

double boundpin (const prevariable &x, double fmin, double fmax, double s)

double dmin (double, double)

double dmax (double i, double j)

double sigmoid (double t1)

dvariable ln_det (const dvar_matrix &)

dvar_matrix operator* (const dvar_matrix &t1, double x)

dmatrix value (const dvar_matrix &m)

d3_array value (const dvar3_array &a)

dvar_vector sort (const dvar_vector &, int NSTACK=60)

dvector sort (const dvector &, int NSTACK=60)

ivector sort (const ivector &, int NSTACK=60)

dvector sort (const dvector &, const ivector &index, int NSTACK=60)

ivector sort (const ivector &, const ivector &index, int NSTACK=60)

dmatrix sort (const dmatrix &, int column, int NSTACK=60)

imatrix sort (const imatrix &, int column, int NSTACK=60)

void gradcalc (int nvar, const dvector &g)

void slave_gradcalc (void)

dmatrix trans (const dmatrix &m1)

imatrix trans (const imatrix &m1)

dvariable dfatan1 (dvariable, double, double, double *)

double dftinv (double, double, double)

dvariable boundp (double, double, double, double *)

dvariable dfboundp (double, double, double, double *)

dvariable dfboundp (const prevariable &, double, double)

double mean (const dvector &)

double mean (const dmatrix &)

double mean (const d3_array &)

double std_dev (const dvector &)

double var (const dvector &)

dvariable mean (const dvar_vector &)

dvariable mean (const dvar_matrix &)

dvariable mean (const dvar3_array &)

dvariable std_dev (const dvar_vector &)

dvariable var (const dvar_vector &)

dvariable sum (const dvar_vector &)

double sum (const dvector &)

int sum (const ivector &)

dvar_vector rowsum (const dvar_matrix &)

dvar_vector colsum (const dvar_matrix &)

dvector colsum (const dmatrix &)

dvector rowsum (const dmatrix &)

ivector colsum (const imatrix &)

ivector rowsum (const imatrix &)

int colsum (const imatrix &, int column)

double colsum (const dmatrix &, int column)

dvariable colsum (const dvar_matrix &, int column)

double sfabs (double t1)

dvector sfabs (const dvector &t1)

imatrix_position restore_imatrix_position (void)

imatrix restore_imatrix_value (const imatrix_position &)

dvariable regression (const dvector &obs, const dvar_vector &pred)

double regression (const dvector &obs, const dvector &pred)

dvariable robust_regression_fixed (const dvector &obs, const dvar_vector &pred, double a=0.7)

dvariable robust_regression (const dvector &obs, const dvar_vector &pred, double a=0.7)

dvariable robust_regression (const dvector &obs, const dvar_vector &pred, const dvariable &cutoff)

dmatrix column_vector (const dvector &)

dmatrix row_vector (const dvector &)

dvar_matrix column_vector (const dvar_vector &)

dvar_matrix row_vector (const dvar_vector &)

dmatrix identity_matrix (int min, int max)

istream & operator>> (const istream &s, const ptr_vector &v)

ostream & operator<< (const ostream &s, const ptr_vector &v)

uistream & operator>> (const uistream &, const dfsdmat &)

uostream & operator<< (const uostream &, const dfsdmat &)

void derch (const double &f, const independent_variables &x, const dvector &g, int n, const int &ireturn)

void fmin (double f, const independent_variables &x, const dvector &g, const int &n, const dvector &w, const dvector &h, const fmm_control &fmc)

void fmmdisp (const dvector &x, const dvector &g, const int &nvar, int scroll_flag, int noprintx=0)

void fmmdisp (const double *x, const double *g, const int &nvar, int scroll_flag, int noprintx=0)

ostream & operator<< (const ostream &s, const fmm_control &fmc)

void derch (const double &f, const dvector &x, const dvector &gg, int n, const int &ireturn)

dvariable inv_cumd_exponential (const prevariable &y)

dvariable cumd_exponential (const prevariable &x)

double inv_cumd_exponential (double y)

double cumd_exponential (double x)

double cumd_logistic (const double &x)

double inv_cumd_logistic (const double &x)

dvariable cumd_logistic (const prevariable &x)

dvariable inv_cumd_logistic (const prevariable &x)

double inv_cumd_norm (const double &x)

double cumd_norm (const double &x)

double cumd_norm (const double &x, double)

dvariable inv_cumd_norm (const prevariable &x)

prevariable & cumd_norm (const prevariable &x)

prevariable & bounded_cumd_norm (const prevariable &x, double)

double bounded_cumd_norm (double x, double)

double normal_tail_right (const double &x)

dvariable inv_cumd_norm_logistic (const prevariable &x, double)

prevariable & cumd_norm_logistic (const prevariable &x, double)

double inv_cumd_norm_logistic (double x, double)

double cumd_norm_logistic (double x, double)

double restore_prevariable_derivative (const prevariable_position &pre)

double restore_prevariable_derivative (void)

prevariable_position restore_prevariable_position (void)

void save_double_derivative (double x, const prevariable_position &pos)

double restore_prevariable_value (void)

void save_double_value (double x)

int sum (const imatrix &)

double sum (const dmatrix &)

double sum (const d3_array &)

double sum (const d4_array &)

double sum (const d5_array &)

double sum (const d6_array &)

double sum (const d7_array &)

dvariable sum (const dvar_matrix &)

dvariable sum (const dvar3_array &)

dvariable sum (const dvar4_array &)

dvariable sum (const dvar5_array &)

dvariable sum (const dvar6_array &)

dvariable sum (const dvar7_array &)

dmatrix fabs (const dmatrix &m)

double norm (const d3_array &)

double norm2 (const d3_array &)

d3_array exp (const d3_array &m)

d3_array mfexp (const d3_array &m)

d3_array mfexp (const d3_array &m, double d)

d3_array log (const d3_array &m)

d3_array fabs (const d3_array &m)

d3_array sin (const d3_array &m)

d3_array cos (const d3_array &m)

d3_array tan (const d3_array &m)

d3_array sqrt (const d3_array &m)

d3_array sqr (const d3_array &m)

d3_array elem_prod (const d3_array &m1, const d3_array &m2)

d3_array elem_div (const d3_array &m1, const d3_array &m2)

d3_array operator+ (const d3_array &m1, const d3_array &m2)

d3_array operator+ (const d3_array &m1, double m2)

d3_array operator/ (const d3_array &m1, double m2)

d3_array operator/ (double m2, const d3_array &m1)

d3_array operator+ (double m1, const d3_array &m2)

d3_array operator- (const d3_array &m1, const d3_array &m2)

d3_array operator- (const d3_array &m1, double m2)

d3_array operator- (double m1, const d3_array &m2)

d3_array operator* (const d3_array &m1, const d3_array &m2)

dmatrix operator* (const d3_array &m1, const dvector &m2)

d3_array operator* (const d3_array &m1, double m2)

d3_array operator* (double m1, const d3_array &m2)

dvariable norm (const dvar3_array &m)

dvariable norm2 (const dvar3_array &m)

dvar3_array exp (const dvar3_array &m)

dvar3_array mfexp (const dvar3_array &m)

dvar3_array mfexp (const dvar3_array &m, double d)

dvar3_array log (const dvar3_array &m)

dvar3_array fabs (const dvar3_array &m)

dvar3_array sin (const dvar3_array &m)

dvar3_array cos (const dvar3_array &m)

dvar3_array tan (const dvar3_array &m)

dvar3_array sqrt (const dvar3_array &m)

dvar3_array sqr (const dvar3_array &m)

dvar3_array elem_prod (const dvar3_array &m1, const dvar3_array &m2)

dvar3_array elem_div (const dvar3_array &m1, const dvar3_array &m2)

dvar3_array operator+ (const dvar3_array &m1, const dvar3_array &m2)

dvar3_array operator- (const dvar3_array &m1, const dvar3_array &m2)

dvar3_array elem_prod (const d3_array &m1, const dvar3_array &m2)

dvar3_array elem_div (const d3_array &m1, const dvar3_array &m2)

dvar3_array operator+ (const d3_array &m1, const dvar3_array &m2)

dvar3_array operator- (const d3_array &m1, const dvar3_array &m2)

dvar3_array elem_prod (const dvar3_array &m1, const d3_array &m2)

dvar3_array elem_div (const dvar3_array &m1, const d3_array &m2)

dvar3_array operator+ (const dvar3_array &m1, const d3_array &m2)

dvar3_array operator+ (const dvar3_array &m1, const dvariable &m2)

dvar3_array operator/ (const prevariable &m2, const dvar3_array &m1)

dvar3_array operator/ (const prevariable &m2, const d3_array &m1)

dvar3_array operator/ (double m2, const dvar3_array &m1)

dvar3_array operator/ (const dvar3_array &m1, const prevariable &m2)

dvar3_array operator/ (const d3_array &m1, const prevariable &m2)

dvar3_array operator/ (const dvar3_array &m1, double m2)

dvar3_array operator+ (const dvariable &m1, const d3_array &m2)

dvar3_array operator+ (double m1, const dvar3_array &m2)

dvar3_array operator- (const dvar3_array &m1, const d3_array &m2)

dvar3_array operator- (const dvar3_array &m1, const dvariable &m2)

dvar3_array operator- (const dvariable &m1, const d3_array &m2)

dvar3_array operator- (const dvariable &m1, const dvar3_array &m2)

dvar3_array operator- (double m1, const dvar3_array &m2)

dvar3_array operator* (const dvar3_array &m1, const d3_array &m2)

dvar3_array operator* (const dvar3_array &m1, const dvariable &m2)

dvar3_array operator* (const dvariable &m1, const d3_array &m2)

dvar3_array operator* (const dvariable &m1, const dvar3_array &m2)

dvar3_array operator* (double m1, const dvar3_array &m2)

double square (double x)

dvector square (const dvector &x)

dmatrix square (const dmatrix &x)

d3_array square (const d3_array &x)

dvariable & square (const prevariable &x)

dvar_vector square (const dvar_vector &x)

dvar_matrix square (const dvar_matrix &x)

dvar3_array square (const dvar3_array &x)

double cube (double x)

dvector cube (const dvector &x)

dmatrix cube (const dmatrix &x)

d3_array cube (const d3_array &x)

d3_array pow (const d3_array &x, int e)

dvar3_array pow (const dvar3_array &x, int e)

prevariable & cube (const prevariable &x)

dvar_vector cube (const dvar_vector &x)

dvar_matrix cube (const dvar_matrix &x)

dvar3_array cube (const dvar3_array &x)

void set_value (const dvar_matrix &x, const dvar_vector &v, const int &_ii, double s)

void set_value (const dvar_matrix &x, const dvar_vector &v, const int &ii, double fmin, double fmax, const dvariable &fpen, double s)

void set_value_inv (const dvar_matrix &x, const dvector &v, const int &ii, double s)

void set_value_inv (const dvar_matrix &x, const dvector &v, const int &ii, double fmin, double fmax, double s)

void set_value (const dvar_vector &x, const dvar_vector &v, const int &_ii, double s)

void set_value (const dvar_vector &_x, const dvar_vector &v, const int &_ii, double fmin, double fmax, const dvariable &fpen, double s)

void set_value_inv (const dvar_vector &x, const dvector &_v, const int &_ii, double s)

void set_value_inv (const dvar_vector &x, const dvector &_v, const int &_ii, double fmin, double fmax, double s)

void set_value_inv (const dvar_matrix &x, const dvector &v, const int &ii)

void set_value_inv (const prevariable &x, const dvector &v, const int &ii, double s)

void set_value_inv (const prevariable &x, const dvector &v, const int &ii)

void set_value_inv (const dvar_matrix &u, const dvector &x, const int &ii, double fmin, double fmax)

void set_value_inv (const dvar3_array &u, const dvector &x, const int &ii, double fmin, double fmax)

void set_value_inv (const dvar3_array &u, const dvector &x, const int &ii)

void set_value_inv (double x, const dvector &v, const int &ii)

void set_value_inv (const prevariable &x, const dvector &_v, const int &_ii, double fmin, double fmax, double s)

void set_value_inv (const prevariable &u, const dvector &x, const int &ii, double fmin, double fmax)

void set_value_inv (double u, const dvector &x, const int &ii, double fmin, double fmax)

void set_value_inv (const dvector &x, const dvector &v, const int &ii)

void set_value_inv (const dvar_vector &x, const dvector &v, const int &ii)

void set_value_inv (const dvar_vector &x, const dvector &v, const int &ii, double fmin, double fmax)

void set_value_inv (const dvector &x, const dvector &v, const int &ii, double fmin, double fmax)

void set_value_inv (const dmatrix &x, const dvector &v, const int &ii)

void set_value_inv (const dmatrix &x, const dvector &v, const int &ii, double fmin, double fmax)

void set_value_inv (const d3_array &x, const dvector &v, const int &ii)

void set_value_inv (const d3_array &x, const dvector &v, const int &ii, double fmin, double fmax)

void set_value (const prevariable &x, const dvar_vector &v, const int &ii)

void set_value (const prevariable &x, const dvar_vector &v, const int &ii, double s)

void set_value (const dvar_vector &x, const dvar_vector &v, const int &ii)

void set_value (const prevariable &_x, const dvar_vector &v, const int &_ii, double fmin, double fmax, const dvariable &fpen, double s)

void set_value (const prevariable &x, const dvar_vector &v, const int &ii, double fmin, double fmax, const dvariable &fpen)

void set_value (const dvar_vector &x, const dvar_vector &v, const int &ii, double fmin, double fmax, const dvariable &fpen)

void set_value (const dvar_matrix &x, const dvar_vector &v, const int &ii)

void set_value (const dvar_matrix &x, const dvar_vector &v, const int &ii, double fmin, double fmax, const dvariable &fpen)

void set_value (dvar3_array &x, const dvar_vector &v, const int &ii)

void set_value (dvar3_array &x, const dvar_vector &v, const int &ii, double fmin, double fmax, const dvariable &fpen)

void set_value_inv_partial (const dvector &x, const dvector &v, const int &ii, int n)

void set_value_inv_partial (const dvector &x, const dvector &v, const int &ii, int n, double fmin, double fmax)

void set_value_inv_partial (const dmatrix &x, const dvector &v, const int &ii, int n)

void set_value_inv_partial (const dvar_matrix &x, const dvector &v, const int &ii, int n)

void set_value_inv_partial (const d3_array &x, const dvector &v, const int &ii, int n)

void set_value_inv_partial (const dvar_vector &x, const dvector &v, const int &ii, int n)

void set_value_inv_partial (const dvar_vector &x, const dvector &v, const int &ii, int n, double fmin, double fmax)

void set_value_partial (const dvar_vector &x, const dvar_vector &v, const int &ii, int n)

void set_value_partial (const dvar_vector &x, const dvar_vector &v, const int &ii, int n, double fmin, double fmax, const dvariable &fpen)

void set_value_partial (const dvar_matrix &x, const dvar_vector &v, const int &ii, int n)

void set_value_partial (dvar3_array &x, const dvar_vector &v, const int &ii, int n)

int size_count (const dvar_vector &x)

int size_count (const dvar_matrix &x)

int size_count (const dvar3_array &x)

int size_count (const dvar4_array &x)

int size_count (const dvector &x)

int size_count (const dmatrix &x)

int size_count (const d3_array &x)

int size_count (const d4_array &x)

int size_count_partial (const dvar_vector &x, int)

int size_count_partial (const dvar_matrix &x, int)

int size_count_partial (const dvar3_array &x, int)

int size_count_partial (const dvector &x, int)

int size_count_partial (const dmatrix &x, int)

int size_count_partial (const d3_array &x, int)

int min (int, int)

void dfinvpret (void)

void dvdv_dot (void)

void dmdm_prod (void)

void dv_init (void)

int save_identifier_string (char *)

void insert_identifier_string (const char *s)

void verify_identifier_string (char *)

ivector restore_ivector_value (const ivector_position &)

ivector_position restore_ivector_position (void)

dvar_matrix_position restore_dvar_matrix_position (void)

dvector restore_dvar_matrix_derivative_row (const dvar_matrix_position &pos, const int &ii)

dvector restore_dvar_matrix_derivative_column (const dvar_matrix_position &pos, const int &ii)

dmatrix restore_dvar_matrix_derivatives (const dvar_matrix_position &pos)

dmatrix restore_dvar_matrix_derivatives (void)

double restore_double_value (void)

int restore_int_value (void)

void save_int_value (int x)

dvar_matrix nograd_assign_trans (const dmatrix &m)

dvar_matrix nograd_assign (const dmatrix &)

dvariable nograd_assign (double tmp)

dvar_vector nograd_assign (dvector tmp)

dmatrix restore_dvar_matrix_value (const dvar_matrix_position &mpos)

dmatrix_position restore_dmatrix_position (void)

dvector_position restore_dvector_position (void)

dvector restore_dvector_value (const dvector_position &)

dmatrix restore_dmatrix_value (const dmatrix_position &)

dvector restore_dvar_matrix_derivatives (const dvar_matrix_position &pos, const int &ii)

dvector restore_dvar_vector_derivatives (const dvar_vector_position &tmp)

void save_dmatrix_derivatives (const dvar_matrix_position &pos, double x, const int &i, int &j)

dmatrix restore_dvar_matrix_der_nozero (const dvar_matrix_position &pos)

dvector restore_dvar_vector_der_nozero (const dvar_vector_position &tmp)

d3_array_position restore_d3_array_position (void)

d3_array restore_d3_array_value (const d3_array_position &)

void nograd_assign_row (const dvar_matrix &m, const dvector &v, const int &ii)

void nograd_assign_column (const dvar_matrix &m, const dvector &v, const int &ii)

long int reset_gs_stack (void)

void reset_gs_stack (long int)

dvar_vector solve (const dvar_matrix &aa, const dvar_vector &z)

dvar_vector solve (const dvar_matrix &aa, const dvar_vector &z, prevariable &ln_unsigned_det, const prevariable &sign)

dvector csolve (const dmatrix &aa, const dvector &z)

dvector solve (const dmatrix &aa, const dvector &z)

dvector solve (const dmatrix &aa, const dvector &z, const double &ln_unsigned_det, double &sign)

dmatrix choleski_decomp (const dmatrix &M)

dmatrix choleski_decomp_error (const dmatrix &M, int &ierror)

dmatrix choleski_decomp_neghess_error (const dmatrix &M, int &ierror)

dmatrix choleski_decomp_positive (const dmatrix &MM, const int &ierr)

dmatrix choleski_decomp_positive (const dmatrix &MM, double bound)

dvar_matrix choleski_decomp (const dvar_matrix &M)

dvariable factln (const dvariable &n)

double factln (double n)

dvar_vector factln (const dvar_vector &n)

dvector factln (const dvector &n)

dvar_vector posfun (const dvar_vector &x, double eps, const prevariable &pen)

dvariable posfun (const dvariable &x, const double eps, const prevariable &pen)

dvariable posfun2 (const dvariable &x, const double eps, const prevariable &pen)

double posfun (const double &x, const double eps, const double &_pen)

double posfun2 (const double &x, const double eps, const double &_pen)

double dfposfun (const double &x, const double eps)

dvariable dfposfun (const prevariable &x, const double eps)

double dfposfun1 (const double &x, const double eps)

dvar_vector log_comb (const dvar_vector &n, const dvector &k)

dvariable log_comb (double n, const dvariable &k)

dvar_vector log_comb (const dvar_vector &n, const dvar_vector &k)

dvar_vector log_comb (const dvector &n, const dvar_vector &k)

dvar_vector log_comb (double n, const dvar_vector &k)

dvar_vector log_comb (const dvariable &n, const dvector &k)

dvar_vector log_comb (const dvariable &n, const dvar_vector &k)

dvariable log_comb (const dvariable &n, double k)

dvariable log_comb (const dvariable &n, const dvariable &k)

dvector log_comb (const dvector &n, const dvector &k)

dvector log_comb (double n, const dvector &k)

double log_comb (double n, double k)

dmatrix orthpoly (int n, int deg)

dmatrix orthpoly (int n, int deg, int skip)

dvar_vector gammln (const dvar_vector &n)

dvector gammln (const dvector &n)

dvar_matrix use_shape (const dvar_matrix &m)

dmatrix use_shape (const dmatrix &m)

ostream & operator<< (const ostream &, const dvar_matrix_position &)

char which_library ()

void ludcmp_index (const dmatrix &a, const ivector &indx, const double &d)

void ludcmp (const dmatrix &a, const ivector &indx, const double &d)

d4_array operator/ (const d4_array &m, double d)

d4_array operator/ (double d, const d4_array &m)

dvar4_array operator/ (const d4_array &m, const prevariable &d)

dvar4_array operator/ (const dvar4_array &m, double d)

dvar4_array operator/ (const dvar4_array &m, const prevariable &d)

dvar5_array operator/ (const d5_array &m, const prevariable &d)

dvar5_array operator/ (const dvar5_array &m, double d)

dvar5_array operator/ (const dvar5_array &m, const prevariable &d)

d4_array log (const d4_array &x)

dvar4_array log (const dvar4_array &x)

d4_array mfexp (const d4_array &x)

dvar4_array mfexp (const dvar4_array &x)

d4_array exp (const d4_array &x)

dvar4_array exp (const dvar4_array &x)

d4_array sqrt (const d4_array &x)

dvar4_array sqrt (const dvar4_array &x)

d5_array log (const d5_array &x)

dvar5_array log (const dvar5_array &x)

d5_array mfexp (const d5_array &x)

dvar5_array mfexp (const dvar5_array &x)

d5_array exp (const d5_array &x)

dvar5_array exp (const dvar5_array &x)

d5_array sqrt (const d5_array &x)

dvar5_array sqrt (const dvar5_array &x)

ostream & operator<< (const ostream &ostr, const d4_array &z)

ostream & operator<< (const ostream &ostr, const d5_array &z)

ostream & operator<< (const ostream &ostr, const d6_array &z)

istream & operator>> (const istream &istr, const d4_array &z)

istream & operator>> (const istream &istr, const d5_array &z)

istream & operator>> (const istream &istr, const d6_array &z)

ostream & operator<< (const ostream &ostr, const dvar4_array &z)

ostream & operator<< (const ostream &ostr, const dvar5_array &z)

ostream & operator<< (const ostream &ostr, const dvar6_array &z)

istream & operator>> (const istream &istr, const dvar4_array &z)

istream & operator>> (const istream &istr, const dvar5_array &z)

istream & operator>> (const istream &istr, const dvar6_array &z)

ostream & operator<< (const ostream &istr, const i5_array &z)

istream & operator>> (const istream &istr, const i5_array &z)

ostream & operator<< (const ostream &istr, const i4_array &z)

istream & operator>> (const istream &istr, const i4_array &z)

d5_array operator/ (const d5_array &m, double d)

d6_array operator/ (const d6_array &m, double d)

dvar6_array operator/ (const d6_array &m, const prevariable &d)

dvar6_array operator/ (const dvar6_array &m, double d)

dvar6_array operator/ (const dvar6_array &m, const prevariable &d)

d7_array operator/ (const d7_array &m, double d)

dvar7_array operator/ (const d7_array &m, const prevariable &d)

dvar7_array operator/ (const dvar7_array &m, double d)

dvar7_array operator/ (const dvar7_array &m, const prevariable &d)

lmatrix_position restore_lmatrix_position (void)

lmatrix restore_lmatrix_value (const lmatrix_position &)

void ad_begin_funnel (void)

double randpoisson (double lambda, const random_number_generator &rng)

double randnegbinomial (double mu, double tau, const random_number_generator &rng)

double randn (const random_number_generator &rng)

double randu (const random_number_generator &rng)

double gasdev (const random_number_generator &_rng)

double expdev (const random_number_generator &_rng)

double sgamma (double a, const random_number_generator &_rng)

banded_symmetric_dmatrix value (const banded_symmetric_dvar_matrix &v)

banded_symmetric_dmatrix restore_banded_symmetric_dvar_matrix_value (const dvar_matrix_position &mpos)

ostream & operator<< (const ostream &ofs, const banded_symmetric_dmatrix &S)

ostream & operator<< (const ostream &ofs, const banded_symmetric_dvar_matrix &S)

ostream & operator<< (const ostream &ofs, const banded_lower_triangular_dmatrix &S)

ostream & operator<< (const ostream &ofs, const banded_lower_triangular_dvar_matrix &S)

dmatrix solve (const banded_symmetric_dmatrix &m, const dmatrix &M)

dmatrix solve (const dmatrix &m, const dmatrix &M)

dvector solve (const banded_symmetric_dmatrix &m, const dvector &v)

banded_lower_triangular_dmatrix choleski_decomp (const banded_symmetric_dmatrix &S, const int &ierr)

banded_lower_triangular_dvar_matrix choleski_decomp_positive (const banded_symmetric_dvar_matrix &S, double eps, dvariable &fpen)

dvariable ln_det_choleski (const banded_symmetric_dvar_matrix &S, const int &ierr)

double ln_det_choleski (const banded_symmetric_dmatrix &S, const int &ierr)

banded_lower_triangular_dvar_matrix choleski_decomp (const banded_symmetric_dvar_matrix &S, const int &ierr)

banded_lower_triangular_dmatrix restore_banded_lower_triangular_dvar_matrix_derivatives (const dvar_matrix_position &pos)

banded_lower_triangular_dmatrix restore_banded_lower_triangular_dvar_matrix_value (const dvar_matrix_position &pos)

banded_symmetric_dmatrix restore_bounded_symmetric_dvar_matrix_derivatives (const dvar_matrix_position &pos)

int max (int i, int j, int k)

int max (int i, int j)

dvar_vector solve (const banded_lower_triangular_dvar_matrix &m, const dvar_vector &v)

void check_choleski_decomp (const banded_symmetric_dvar_matrix &MM, int &ierr)

dvector solve (const banded_lower_triangular_dmatrix &m, const dvector &v)

dvector solve_trans (const banded_lower_triangular_dmatrix &m, const dvector &v)

int admax (int i, int j)

dmatrix diagonal_matrix (const dvector &v)

dvar_matrix diagonal_matrix (const dvar_vector &v)

dvector diagonal (const dmatrix &)

dvar_vector diagonal (const dvar_matrix &)

double gammln (double xx)

dvariable gammln (const prevariable &xx)

ivector histogram (double min, double max, int nbin, const dvector &input)

double cumd_cauchy (const double &x)

double density_cauchy (const double &x)

double log_density_cauchy (const double &x)

double inv_cumd_cauchy (const double &x)

dvariable inv_cumd_cauchy (const prevariable &x)

dvariable cumd_cauchy (const prevariable &x)

dvariable kludge_cumd_cauchy (const prevariable &x)

double log_negbinomial_density (double x, double mu, double tau)

dvariable log_negbinomial_density (double x, const prevariable &mu, const prevariable &tau)

dvariable log_density_poisson (double x, const prevariable &mu)

double log_density_poisson (double x, double mu)

ostream & operator<< (const ostream &, const pre_column_print &)

ostream & operator<< (const ostream &, const pre_zero_print &)

pre_column_print column_print (const dvector &v)

pre_zero_print zero_print (const dvector &v)

dvector VEC (const dmatrix &)

dmatrix MAT (const dvector &, int i, int j)

dvar_vector VEC (const dvar_matrix &)

dvar_matrix MAT (const dvar_vector &, int i, int j)

dmatrix operator- (const dmatrix &m)

dvar_matrix operator- (const dvar_matrix &m)

ivector sgn (const dvector &)

ivector sgn (const dvar_vector &)

int allocated (const ivector &v)

int allocated (const lvector &v)

int allocated (const dvector &v)

int allocated (const dvar_vector &v)

int allocated (const imatrix &v)

int allocated (const dmatrix &v)

int allocated (const dvar_matrix &v)

int allocated (const i3_array &v)

int allocated (const d3_array &v)

int allocated (const dvar3_array &v)

int allocated (const i4_array &v)

int allocated (const d4_array &v)

int allocated (const dvar4_array &v)

int allocated (const d5_array &v)

int allocated (const dvar5_array &v)

int allocated (const d6_array &v)

int allocated (const dvar6_array &v)

int allocated (const d7_array &v)

int allocated (const dvar7_array &v)

dvar_matrix positive_definite_matrix (const dvar_matrix &MM, double eps, dvariable &fpen)

dvar_matrix empirical_covariance (const dvar_matrix &v1)

dvar_matrix empirical_covariance (const dvar_matrix &v1, const imatrix &missflags)

void gauss_hermite (const dvector &_x, const dvector &_w)

void normalized_gauss_hermite (const dvector &_x, const dvector &_w)

void gauss_legendre (double x1, double x2, const dvector &_x, const dvector &_w)

void gauss_legendre (const dvector &_x, const dvector &_w)

dvariable beta (const prevariable &, const prevariable &)

dvariable betacf (const dvariable &_a, const dvariable &_b, const dvariable &_x, int maxit=100)

double betacf (const double &_a, const double &_b, const double &_x, int maxit=100)

dvariable betai (const dvariable a, const dvariable b, const dvariable x, int maxit=100)

double betai (const double a, const double b, const double x, int maxit=100)

dvar_matrix tensor_prod (const dvar_matrix &a, const dvar_matrix &b)

void exit_handler (int k)

dvariable mf_upper_bound (const prevariable &x, double M, prevariable &fpen)

double mf_upper_bound (const double &x, double M, prevariable &fpen)

int operator== (double v0, const prevariable &v1)

int operator<= (double v0, const prevariable &v1)

int operator>= (double v0, const prevariable &v1)

int operator> (double v0, const prevariable &v1)

int operator< (double v0, const prevariable &v1)

int operator!= (double v0, const prevariable &v1)

dvariable cumd_bivariate_normal (const prevariable &xu, const prevariable &yu, const prevariable &rho, int nbox)

dvariable cumbvn (const dvariable &x, const dvariable &y, const dvariable &rho)

dvariable cumbvn (const dvariable &xl, const dvariable &yl, const dvariable &xu, const dvariable &yu, const dvariable &rho)

double ghk (const dvector &lower, const dvector &upper, const dmatrix &Sigma, const dmatrix &eps)

double ghk_choleski (const dvector &lower, const dvector &upper, const dmatrix &ch, const dmatrix &eps)

dvariable ghk_choleski_m (const dvar_vector &upper, const dvar_matrix &ch, const dmatrix &eps)

double ghk (const dvector &lower, const dvector &upper, const dmatrix &Sigma, const dmatrix &eps, int i)

dvariable ghk (const dvar_vector &lower, const dvar_vector &upper, const dvar_matrix &Sigma, const dmatrix &eps)

dvariable ghk (const dvar_vector &lower, const dvar_vector &upper, const dvar_matrix &Sigma, const dmatrix &eps, int i)

dvariable ghk_choleski_m_cauchy (const dvar_vector &upper, const dvar_matrix &ch, const dmatrix &eps)

dvariable ghk_choleski_m_logistic (const dvar_vector &upper, const dvar_matrix &ch, const dmatrix &eps)

void tracing_message (int traceflag, const char *s)

void tracing_message (int traceflag, const char *s, int *pn)

void tracing_message (int traceflag, const char *s, double *pd)

void tracing_message (int traceflag, const char *s, double d)

int sub_unallocated (const dvar_vector &m)

int sub_unallocated (const dvar_matrix &m)

int sub_unallocated (const dvar3_array &m)

int sub_unallocated (const dvar4_array &m)

int sub_unallocated (const dvar5_array &m)

int sub_unallocated (const dvector &m)

int sub_unallocated (const dmatrix &m)

int sub_unallocated (const d3_array &m)

int sub_unallocated (const d4_array &m)

int sub_unallocated (const d5_array &m)

int sub_unallocated (const ivector &m)

int sub_unallocated (const imatrix &m)

int sub_unallocated (const i3_array &m)

int sub_unallocated (const i4_array &m)

void check_derivative_values (const char *s)

void check_derivative_values (const char *s, int i)

void check_derivative_values_break (const char *s, int i, int b)

void df_check_derivative_values (void)

void df_check_derivative_values_indexed (void)

void df_check_derivative_values_indexed_break (void)

void reset_gradient_stack (void)

int make_sub_directory (const char *s)

adstring get_string_marker (void)

int option_match (int argc, char *argv[], const char *string)

int option_match (int argc, char *argv[], const char *string, const int &nopt)

int option_match (char *s, const char *string, const int &_nopt)

int option_match (char *s, const char *string)

int ad_chdir (const char *s)

void ad_getcd (const adstring &s)

void grad_chk (void)

void send_dv3_to_master (const dvar3_array &v)

dvariable inv (const prevariable &x)

double gamma_density (double _x, double r, double mu)

dvariable gamma_density (const prevariable &_x, double r, double mu)

dvariable gamma_density (const dvariable &_x, const dvariable &_r, const dvariable &_mu)

double log_gamma_density (double _x, double r, double mu)

dvariable log_gamma_density (const prevariable &_x, double r, double mu)

dvariable log_gamma_density (const dvariable &_x, const dvariable &_r, const dvariable &_mu)

dvariable ln_det_choleski (const dvar_matrix &M)

dvariable ln_det_choleski_error (const dvar_matrix &, int &ierr)

dvector atlas_solve_spd (const dmatrix &M, const dvector &x)

dvector atlas_solve_spd (const dmatrix &M, const dvector &x, int &ierr)

dmatrix atlas_solve_spd (const dmatrix &M, const dmatrix &x)

dmatrix atlas_solve_spd_trans (const dmatrix &M, const dmatrix &x)

dmatrix symmetrize (const lower_triangular_dmatrix &M)

dvector solve (const lower_triangular_dmatrix &M, const dvector &v)

dvector lower_triangular_solve (const dmatrix &M, const dvector &v)

dvar_vector lower_triangular_solve (const dvar_matrix &M, const dvar_vector &v)

dvector solve_trans (const lower_triangular_dmatrix &M, const dvector &v)

dmatrix fillout (const lower_triangular_dmatrix &M)

dmatrix fillout_trans (const lower_triangular_dmatrix &M)

lower_triangular_dmatrix lower_triangular_choleski_decomp_positive (const dmatrix &MM, const int &_ierr)

dvar_vector solve_trans (const banded_lower_triangular_dvar_matrix &M, const dvector &y)

int admin (int i, int j)

d4_array orthpoly2 (int n, int m, int d1, int d2)

double dot (const dmatrix &M, const dmatrix &d2)

double norm (const banded_symmetric_dmatrix &B)

double norm2 (const banded_symmetric_dmatrix &B)

dvariable norm (const banded_symmetric_dvar_matrix &B)

dvariable norm2 (const banded_symmetric_dvar_matrix &B)

double lower_triangular_ln_det (const dmatrix &m)

double lower_triangular_ln_det (const dmatrix &m, int &sgn)

dvariable lower_triangular_ln_det (const dvar_matrix &m)

dvariable lower_triangular_ln_det (const dvar_matrix &m, int &sgn)

double bounder (double x, double min, double max, double scale)

dvariable bounder (const prevariable &x, double min, double max, double scale)

dmatrix inv (const dmatrix &m1, const double &_ln_det, const int &_sgn)

double gamma_deviate (double _x, double _a)

dvariable gamma_deviate (const prevariable &_x, const prevariable &_a)

void ad_set_new_handler (void)

dvariable inv_cumd_gamma (const prevariable &_y, const prevariable &_a)

double inv_cumd_gamma (double _y, double _a)

double robust_normal_logistic_mixture_deviate (double x, double spread=3.0)

double robust_normal_mixture_deviate (double x, double spread=3.0)

dvariable robust_normal_mixture_deviate (const prevariable &x, double spread=3.0)

dvector lower_triagnular_solve_trans (const dmatrix &M, const dvector &y)

dvector lower_triagular_solve (const dmatrix &m, const dvector &v)

dvector choleski_solve_error (dmatrix M, dvector &v, int &ierror)

dvector choleski_solve_neghess_error (dmatrix M, dvector &v, int &ierror)

dvariable cumd_gamma (const dvariable &x, const dvariable &a)

double cumd_gamma (double x, double a)

dvariable inv_cumd_normal_mixture (const prevariable &_x, double _a)

dvariable inv_cumd_normal_logistic_mixture (const prevariable &_x, double _a)

double inv_cumd_normal_mixture (double _x, double _a)

double inv_cumd_normal_logistic_mixture (double _x, double _a)

double inv_cumd_t (double n, double y, double eps=1.e-7)

dvariable inv_cumd_t (const prevariable &n, const prevariable &y, double eps=1.e-7)

double inv_cumd_beta_stable (double a, double b, double y, double eps=1.e-7)

dvariable inv_cumd_beta_stable (const prevariable &_a, const prevariable &_b, const prevariable &_y, double eps=1.e-7)

dvariable norm_to_gamma (const prevariable &v, const prevariable &alpha, double bound=0.999999)

double norm_to_gamma (double v, double alpha, double bound=0.999999)

dmatrix eigenvectors (const banded_symmetric_dmatrix &_S, const dvector &e)

dvector eigenvalues (const banded_symmetric_dmatrix &_S)

dvector get_eigen_values (const dvector &_d, const dvector &_e)

dvar_vector get_eigen_values (const dvar_vector &_d, const dvar_vector &_e)

dvector get_eigen_values (const dvector &_d, const dvector &_e, const dmatrix &_z)

dvariable beta_deviate (const prevariable &_x, const prevariable &_a, const prevariable &_b, double eps=1.e-7)

double beta_deviate (double x, double a, double b, double eps=1.e-7)

int smbfct_ (int *neqns, ivector &xadj, ivector &adjncy, ivector &perm, ivector &invp, ivector &xlnz, int *maxlnz, ivector &xnzsub, ivector &nzsub, int *maxsub, ivector &rchlnk, ivector &mrglnk, ivector &marker, int *flag__)

dmatrix orthpoly_constant_begin (int n, int deg, int nconst)

dmatrix orthpoly_constant_begin_end (int n, int deg, int nconst_begin, int enddeg, int nconst_end)

void test_the_pointer (void)

void set_gradstack_flag (char *str, int i, int j)

void set_gradstack_flag (char *str)

void report_gradstack_flag (void)

dvariable log_der_logistic (double a, double b, const prevariable &x)

double logistic (double a, double b, const double &x)

double dflogistic (double a, double b, const double &x)

dvariable logistic (double a, double b, const prevariable &x)

dvariable dflogistic (double a, double b, const prevariable &x)

double log_density_negbinomial (double x, double mu, double tau)

sing_val_decomp singval_decomp (const dmatrix &_a)

banded_lower_triangular_dmatrix choleski_decomp_trust_bound (const banded_symmetric_dmatrix &_M, const int &_ierr)

dvariable avg (const prevariable &x, const prevariable &y)

double avg (double x, double y)

void ADMB_getcallindex (int x)

void ADMB_getcallindex (double x)

void ADMB_getcallindex (const dvector &v)

void ADMB_getcallindex (const dmatrix &v)

void ADMB_getcallindex (const d3_array &v)

void ADMB_getcallindex (const d4_array &v)

void ADMB_getcallindex (const prevariable &)

void ADMB_getcallindex (const dvar_vector &v)

void ADMB_getcallindex (const dvar_matrix &v)

void ADMB_getcallindex (const dvar3_array &v)

void ADMB_getcallindex (dvar4_array &v)

void clean (ivector &v, int level)

Variables

fptr ad_printf

exitptr ad_exit

int ad_kill_flag

int just_to_link_fvar1

Define Documentation

#define USE_VECTOR_SHAPE_POOL

#define __NUMBERVECTOR__

#define ADUNCONST	(	type,
		obj		)	type & obj = (type&) _##obj;

#define my_off_t long int

#define my_u_off_t unsigned long int

#define MFCL2_CONSTRUCTORS

#define DOS386

#define __USE_IOSTREAM__

#define BOR_CONST

#define USE_HIGHER_ARRAYS

#define BOR_CONST const

#define AD_LONG_INT long int

#define AD_VERSION 7

#define CGNU_DOUBLE double

#define USE_CONST

#define _CONST const

#define BEGIN_MINIMIZATION	(	nvar,
		objective_function,
		ind_vars,
		gradient,
		cntrl	)

Value:

gradient_structure gs; \
while (cntrl.ireturn >= 0) \
{ \
  cntrl.fmin(objective_function,ind_vars,gradient ); \
  if (cntrl.ireturn > 0) \
  {

#define END_MINIMIZATION	(	nvar,
		gradient		)

Value:

gradcalc(nvar, gradient); \
  } \
}

#define AD_SET_DERIVATIVES1	(	depvar,
		indvar,
		df	)

Value:

gradient_structure::GRAD_STACK1->set_gradient_stack2(default_evaluation2,\
       &(value(depvar)), &(value(indvar)),df);

#define AD_SET_DERIVATIVES2	(	depvar,
		indvar1,
		df1,
		indvar2,
		df2	)

Value:

gradient_structure::GRAD_STACK1->set_gradient_stack(default_evaluation3,\
       &(value(depvar)), &(value(indvar1)),df1,&(value(indvar2)),df2);

#define AD_SET_DERIVATIVES3	(	depvar,
		indvar1,
		df1,
		indvar2,
		df2,
		indvar3,
		df3	)

Value:

gradient_structure::GRAD_STACK1->set_gradient_stack(default_evaluation3ind,\
      &(value(depvar)), &(value(indvar1)),df1,&(value(indvar2)),df2, \
      &(value(indvar3)),df3);

#define AD_SET_DERIVATIVES4	(	depvar,
		indvar1,
		df1,
		indvar2,
		df2,
		indvar3,
		df3,
		indvar4,
		df4	)

Value:

gradient_structure::GRAD_STACK1->set_gradient_stack(default_evaluation4ind,\
      &(value(depvar)), &(value(indvar1)),df1,&(value(indvar2)),df2, \
      &(value(indvar3)),df3, \
      &(value(indvar4)),df4);

#define ADJOINT_CODE ( x ) gradient_structure::GRAD_STACK1->set_gradient_stack(x);

Typedef Documentation

typedef int(* fptr)(const char *format,...)

typedef void(* exitptr)(int)

Function Documentation

void spdll_exit ( int )

dvector restore_dvar_vector_derivatives ( void )

void default_evaluation ( void )

void default_evaluation0 ( void )

void default_evaluation1 ( void )

void default_evaluation1m ( void )

void default_evaluation2 ( void )

void default_evaluation3 ( void )

void default_evaluation4 ( void )

void default_evaluation4m ( void )

void myheapcheck ( char * )

void RETURN_ARRAYS_INCREMENT ( void )

void RETURN_ARRAYS_DECREMENT ( void )

void* farptr_norm ( void * )

long int farptr_tolong ( void * )

long int _farptr_tolong ( void * )

void denormalize_ptr	(	void *	,
		unsigned int	byte_offset
	)

ostream& operator<<	(	const ostream &	ostr,
		const dmatrix &	z
	)

istream& operator>>	(	const istream &	istr,
		const dmatrix &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const dmatrix &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const dmatrix &	z
	)

ostream& operator<<	(	const ostream &	ostr,
		const d3_array &	z
	)

istream& operator>>	(	const istream &	istr,
		const d3_array &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const d3_array &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const d3_array &	z
	)

ostream& operator<<	(	const ostream &	ostr,
		const dvar3_array &	z
	)

istream& operator>>	(	const istream &	istr,
		const dvar3_array &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const dvar3_array &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const dvar3_array &	z
	)

ostream& operator<<	(	const ostream &	ostr,
		const ivector &	z
	)

istream& operator>>	(	const istream &	istr,
		const ivector &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const ivector &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const ivector &	z
	)

ostream& operator<<	(	const ostream &	ostr,
		const lvector &	z
	)

istream& operator>>	(	const istream &	istr,
		const lvector &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const lvector &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const lvector &	z
	)

ostream& operator<<	(	const ostream &	ostr,
		const dvector &	z
	)

istream& operator>>	(	const istream &	istr,
		const dvector &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const dvector &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const dvector &	z
	)

ostream& operator<<	(	const ostream &	ostr,
		const dvar_vector &	z
	)

istream& operator>>	(	const istream &	istr,
		const dvar_vector &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const dvar_vector &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const dvar_vector &	z
	)

ostream& operator<<	(	const ostream &	ostr,
		const dvar_matrix &	z
	)

istream& operator>>	(	const istream &	istr,
		const dvar_matrix &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const dvar_matrix &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const dvar_matrix &	z
	)

ostream& operator<<	(	const ostream &	ostr,
		const prevariable &	z
	)

istream& operator>>	(	const istream &	istr,
		const prevariable &	z
	)

uostream& operator<<	(	const uostream &	ostr,
		const prevariable &	z
	)

uistream& operator>>	(	const uistream &	istr,
		const prevariable &	z
	)

ostream& setscientific ( const ostream & s )

preshowpoint setshowpoint ( void )

ostream& operator<<	(	const ostream &	,
		preshowpoint
	)

ostream& setfixed ( const ostream & s )

prefixed setfixed ( void )

ostream& operator<<	(	const ostream &	,
		prefixed
	)

prescientific setscientific ( void )

ostream& operator<<	(	const ostream &	,
		prescientific
	)

istream& operator>>	(	const istream &	istr,
		const imatrix &	z
	)

ostream& operator<<	(	const ostream &	istr,
		const imatrix &	z
	)

istream& operator>>	(	const istream &	istr,
		const i3_array &	z
	)

ostream& operator<<	(	const ostream &	istr,
		const i3_array &	z
	)

ivector operator+	(	const ivector &	v,
		const ivector &	w
	)

ivector operator-	(	const ivector &	v,
		const ivector &	w
	)

ivector operator+	(	const ivector &	v,
		int	w
	)

ivector operator-	(	const ivector &	v,
		int	w
	)

ivector operator+	(	int	v,
		const ivector &	w
	)

ivector operator-	(	int	v,
		const ivector &	w
	)

long int sum ( const lvector & )

dvar_vector_position restore_dvar_vector_position ( void )

dvector restore_dvar_vector_value ( const dvar_vector_position & tmp )

void arr_free ( double_and_int * )

double_and_int* arr_new ( unsigned int sz )

void jacobcalc	(	int	nvar,
		const dmatrix &	g
	)

void jacobcalc	(	int	nvar,
		const ofstream &	ofs
	)

void jacobcalc	(	int	nvar,
		const uostream &	ofs
	)

void default_evaluation3ind ( void )

void gradfree ( dlink * )

double& value ( const prevariable & v1 ) [inline]

double* address ( const prevariable & v1 ) [inline]

Referenced by indvar_offset_list::get_address(), and indvar_offset_list::put_address().

prevariable& operator<<	(	const prevariable &	v1,
		const prevariable &	v2
	)

dvar_vector& operator<<	(	const dvar_vector &	v1,
		const dvar_vector &	v2
	)

dvar_matrix& operator<<	(	const dvar_matrix &	v1,
		const dvar_matrix &	v2
	)

dvar_vector operator*	(	const dvar_vector &	t1,
		double	x
	)

dvar_vector operator/	(	double	x,
		const dvar_vector &	t1
	)

dvar_vector operator/	(	const dvar_vector &	t1,
		double	x
	)

dvar_vector operator+	(	double	x,
		const dvar_vector &	t1
	)

dvar_vector operator+	(	const dvar_vector &	t1,
		double	x
	)

dvar_vector operator-	(	double	x,
		const dvar_vector &	t1
	)

dvar_vector operator-	(	const dvar_vector &	t1,
		double	x
	)

dvar_vector operator- ( const dvar_vector & t1 )

dvar_vector operator*	(	const dvar_vector &	t1,
		const prevariable &	x
	)

dvar_vector operator/	(	const prevariable &	x,
		const dvar_vector &	t1
	)

dvar_vector operator/	(	const dvar_vector &	t1,
		const prevariable &	x
	)

dvar_vector operator+	(	const prevariable &	x,
		const dvar_vector &	t1
	)

dvar_vector operator+	(	const dvar_vector &	t1,
		const prevariable &	x
	)

dvar_vector operator-	(	const prevariable &	x,
		const dvar_vector &	t1
	)

dvar_vector operator-	(	const dvar_vector &	t1,
		const prevariable &	x
	)

dvar_vector operator-	(	const dvector &	t1,
		const prevariable &	x
	)

dvar_vector operator*	(	const dvector &	t1,
		const prevariable &	x
	)

dvar_vector operator*	(	const prevariable &	x,
		const dvector &	t1
	)

dvector operator*	(	const dvector &	t1,
		double	x
	)

dvector operator/	(	double	x,
		const dvector &	t1
	)

dvector operator/	(	const dvector &	t1,
		double	x
	)

dvector operator+	(	double	x,
		const dvector &	t1
	)

dvector operator+	(	const dvector &	t1,
		double	x
	)

dvector operator-	(	double	x,
		const dvector &	t1
	)

dvector operator-	(	const dvector &	t1,
		double	x
	)

dvector operator- ( const dvector & t1 )

double max ( const dmatrix & )

Referenced by ivector_position::indexmax(), dvector_position::indexmax(), d3_array_position::indexmax(), and dvar_vector_position::indexmax().

int max ( const imatrix & )

double max ( const dvector & )

dvariable max ( const dvar_vector & )

dvariable min ( const dvar_vector & )

Referenced by ivector_position::indexmin(), dvector_position::indexmin(), d3_array_position::indexmin(), and dvar_vector_position::indexmin().

dmatrix symmetrize ( const dmatrix & m1 )

dvector eigenvalues ( const dmatrix & m1 )

dmatrix eigenvectors ( const dmatrix & m1 )

dmatrix eigenvectors	(	const dmatrix &	m1,
		const dvector &	eigenvalues
	)

dvar_matrix symmetrize ( const dvar_matrix & m1 )

dvar_vector eigenvalues ( const dvar_matrix & m1 )

dvar_matrix eigenvectors ( const dvar_matrix & m1 )

dmatrix outer_prod	(	const dvector &	t1,
		const dvector &	t2
	)

dvar_matrix outer_prod	(	const dvar_vector &	t1,
		const dvar_vector &	t2
	)

dvar_matrix outer_prod	(	const dvector &	t1,
		const dvar_vector &	t2
	)

dvar_matrix outer_prod	(	const dvar_vector &	t1,
		const dvector &	t2
	)

dmatrix operator*	(	double	x,
		const dmatrix &	m
	)

dmatrix operator*	(	const dmatrix &	m,
		double	d
	)

dmatrix operator/	(	const dmatrix &	m,
		double	d
	)

dmatrix operator/	(	double	d,
		const dmatrix &	m
	)

dmatrix operator+	(	double	x,
		const dmatrix &	m
	)

dvar_matrix operator+	(	const dvariable &	x,
		const dmatrix &	m
	)

dvar_matrix operator-	(	const dvariable &	x,
		const dmatrix &	m
	)

dmatrix operator+	(	const dmatrix &	m,
		double	d
	)

dmatrix operator-	(	double	x,
		const dmatrix &	m
	)

dmatrix operator-	(	const dmatrix &	m,
		double	d
	)

dvar_matrix operator/	(	const dvar_matrix &	m,
		const prevariable &	x
	)

dvar_matrix operator/	(	const dmatrix &	m,
		const prevariable &	x
	)

dvar_matrix operator/	(	const dvar_matrix &	m,
		double	x
	)

dvar_matrix operator/	(	double	x,
		const dvar_matrix &	m
	)

dvar_matrix operator/	(	const prevariable &	x,
		const dvar_matrix &	m
	)

dvar_matrix operator*	(	const prevariable &	x,
		const dmatrix &	m
	)

dvar_matrix operator*	(	const dvar_matrix &	m,
		const prevariable &	x
	)

dvar_matrix operator*	(	const prevariable &	x,
		const dvar_matrix &	m
	)

dvar_matrix operator*	(	double	x,
		const dvar_matrix &	m
	)

dvector operator &	(	const dvector &	t1,
		const dvector &	t2
	)

dvar_vector operator &	(	const dvar_vector &	t1,
		const dvar_vector &	t2
	)

ivector column	(	const imatrix &	m,
		int	i
	)

dvector extract_column	(	const dmatrix &	m,
		int	i
	)

dvector column	(	const dmatrix &	m,
		int	i
	)

dvector extract_row	(	const dmatrix &	m,
		int	j
	)

dvector row	(	const dmatrix &	m,
		int	j
	)

dvar_vector extract_column	(	const dvar_matrix &	m,
		int	i
	)

dvar_vector column	(	const dvar_matrix &	m,
		int	i
	)

dvector column_value	(	const dvar_matrix &	m,
		int	i
	)

dvar_vector extract_row	(	const dvar_matrix &	m,
		int	j
	)

dvar_vector row	(	const dvar_matrix &	m,
		int	j
	)

dvector sin ( const dvector & t1 )

dvector sqrt ( const dvector & t1 )

dvector sqr ( const dvector & t1 )

dvector exp ( const dvector & t1 )

dvector mfexp ( const dvector & t1 )

dvector mfexp	(	const dvector &	t1,
		double	d
	)

dvector atan ( const dvector & t1 )

dvector tan ( const dvector & t1 )

dvector tanh ( const dvector & t1 )

dvector atan2	(	const dvector &	t1,
		const dvector &	t2
	)

dvector atan2	(	const dvector &	t1,
		double	t2
	)

dvector atan2	(	double	t1,
		const dvector &	t2
	)

dvector acos ( const dvector & t1 )

dvector asin ( const dvector & t1 )

dvector cos ( const dvector & t1 )

dvector sinh ( const dvector & t1 )

dvector cosh ( const dvector & t1 )

dvector log ( const dvector & t1 )

dvector log10 ( const dvector & t1 )

dvector pow	(	const dvector &	t1,
		double
	)

dvector pow	(	const dvector &	t1,
		int
	)

dvector pow	(	double	,
		const dvector &	t1
	)

ivector pow	(	const ivector &	v1,
		int	x
	)

ivector pow	(	int	x,
		const ivector &	v1
	)

dvar_vector sin ( const dvar_vector & t1 )

dvar_vector sqrt ( const dvar_vector & t1 )

dvar_vector sqr ( const dvar_vector & t1 )

dvar_vector exp ( const dvar_vector & t1 )

dvar_vector mfexp ( const dvar_vector & t1 )

dvar_vector mfexp	(	const dvar_vector &	t1,
		double	d
	)

dvar_vector atan ( const dvar_vector & t1 )

dvar_vector tan ( const dvar_vector & t1 )

dvar_vector tanh ( const dvar_vector & t1 )

dvar_vector atan2	(	const dvar_vector &	t1,
		const dvar_vector &	t2
	)

dvar_vector atan2	(	const dvar_vector &	t1,
		double	t2
	)

dvar_vector atan2 ( double t1,