base_class¶

cppad_mixed: Public Declarations¶

These cppad_mixed class declarations are public . They are part of the user API and can be used by a derived class object mixed_object .

Cppad Mixed Types¶

The following Cppad Mixed types are extended into the cppad_mixed class:

   // scalar types
   typedef CppAD::mixed::a1_double      a1_double;
   // vector types
   typedef CppAD::mixed::s_vector       s_vector;
   typedef CppAD::mixed::d_vector       d_vector;
   typedef CppAD::mixed::a1_vector      a1_vector;
   // sparse types
   typedef CppAD::mixed::sparse_rc      sparse_rc;
   typedef CppAD::mixed::d_sparse_rcv   d_sparse_rcv;
   typedef CppAD::mixed::a1_sparse_rcv  a1_sparse_rcv;

User Defined Functions¶

The following are cppad_mixed pure virtual functions. Each one has a default definition that may be replaced by the user’s derived class:

ran_likelihood¶

This function is necessary if there are random effects in the model.

   virtual a1_vector ran_likelihood(
      const a1_vector& fixed_vec  ,
      const a1_vector& random_vec )
   {  return a1_vector(0); }

See ran_likelihood .

fix_likelihood¶

This function should be used if there is a prior on the fixed effects, or there is data that does not depend on the random effects.

   virtual a1_vector fix_likelihood(
      const a1_vector& fixed_vec )
   {  return a1_vector(0); }

See fix_likelihood .

fix_constraint¶

This function is used to define constraints that only depend on the fixed effects.

   virtual a1_vector fix_constraint(
      const a1_vector& fixed_vec )
   {  return a1_vector(0); }

See fix_constraint .

fatal_error¶

This routine displays an error message and then exits the program. Its default definition below can be replaced by a user definition. Note that if NDEBUG is not defined, this generates an assert, otherwise it exits.

   virtual void fatal_error(const std::string& error_message)
   {  std::cerr << "cppad_mixed error: " << error_message << std::endl;
      assert(false);
      exit(1);
   }

warning¶

This routine displays a warning message and then returns. Its default definition below can be replaced by a user definition.

   virtual void warning(const std::string& warning_message)
   {  std::cerr << "cppad_mixed warning: " << warning_message << std::endl;
   }

constructor¶

User Defined Class Derived From cppad_mixed.

   // BEGIN_CPPAD_MIXED_CTOR
   cppad_mixed(
      size_t               n_fixed       ,
      size_t               n_random      ,
      bool                 quasi_fixed   = false           ,
      bool                 bool_sparsity = false           ,
      const d_sparse_rcv&  A_rcv         = d_sparse_rcv()  ,
      bool                 trace_init    = false
   );
   // END_CPPAD_MIXED_CTOR

destructor¶

   virtual ~cppad_mixed(void);

initialize¶

Initialization After Constructor

   std::map<std::string, size_t> initialize(
      const d_vector&  fixed_vec   ,
      const d_vector&  random_vec
   );

optimize_random¶

Optimize Random Effects.

   d_vector optimize_random(
      const std::string& options      ,
      const d_vector&    fixed_vec    ,
      const d_vector&    random_lower ,
      const d_vector&    random_upper ,
      const d_vector&    random_in
   );

optimize_fixed¶

Optimize Fixed Effects.

   CppAD::mixed::fixed_solution optimize_fixed(
      const std::string& fixed_ipopt_options   ,
      const std::string& random_ipopt_options  ,
      const d_vector&    fixed_lower           ,
      const d_vector&    fixed_upper           ,
      const d_vector&    fix_constraint_lower  ,
      const d_vector&    fix_constraint_upper  ,
      const d_vector&    fixed_scale           ,
      const d_vector&    fixed_in              ,
      const d_vector&    random_lower          ,
      const d_vector&    random_upper          ,
      const d_vector&    random_in             ,
      const CppAD::mixed::warm_start_struct&  warm_start =
         CppAD::mixed::warm_start_struct()
   );

hes_fixed_obj¶

Compute the Hessian of The Fixed Effects Objective.

   d_sparse_rcv hes_fixed_obj(
      const d_vector& fixed_vec  ,
      const d_vector& random_opt
   );

hes_random_obj¶

Compute the Hessian of The Random Effects Objective.

   d_sparse_rcv hes_random_obj(
      const d_vector& fixed_vec  ,
      const d_vector& random_vec
   );

sample_fixed¶

Sample Posterior for Fixed Effects.

   std::string sample_fixed(
      d_vector&                            sample               ,
      const d_sparse_rcv&                  information_rcv      ,
      const CppAD::mixed::fixed_solution&  solution             ,
      const d_vector&                      fixed_lower          ,
      const d_vector&                      fixed_upper          ,
      double&                              rcond                ,
      double                               cov_factor = 1.0
   );
   std::string sample_fixed(
      d_vector&                            sample               ,
      const d_sparse_rcv&                  information_rcv      ,
      const CppAD::mixed::fixed_solution&  solution             ,
      const d_vector&                      fixed_lower          ,
      const d_vector&                      fixed_upper          )
   {  double rcond;
      return sample_fixed(
         sample, information_rcv, solution, fixed_lower, fixed_upper, rcond
      );
   }

sample_random¶

Simulation the Posterior Distribution for Random Effects.

   std::string sample_random(
      d_vector&            sample               ,
      const std::string&   random_ipopt_options ,
      const d_vector&      fixed_vec            ,
      const d_vector&      random_lower         ,
      const d_vector&      random_upper         ,
      const d_vector&      random_in            ,
      double               cov_factor = 1.0
   );

information_mat, Deprecated 2020-03-22¶

Compute the Observed Information For Fixed Effects.

   d_sparse_rcv information_mat(
      const CppAD::mixed::fixed_solution&  solution             ,
      const d_vector&                      random_opt
   );

Contents¶

Name	Title
derived_ctor	User Defined Class Derived From cppad_mixed
ran_likelihood	User Defined Random Likelihood Function
fix_likelihood	User Defined Fixed Likelihood Function
fix_constraint	User Defined Fixed Effects Constraint Function
initialize	Initialization After Constructor
optimize_random	Optimize Random Effects
optimize_fixed	Optimize Fixed Effects
hes_fixed_obj	Compute the Hessian of The Fixed Effects Objective
hes_random_obj	Compute the Hessian of The Random Effects Objective
sample_fixed	Sample Posterior for Fixed Effects
sample_random	Simulation the Posterior Distribution for Random Effects
information_mat	Compute the Observed Information For Fixed Effects