derived_ctor.cpp¶

mixed_cppad Derived Class: Example and Test¶

# include <cppad/cppad.hpp>
# include <cppad/mixed/cppad_mixed.hpp>


namespace {
   using CppAD::log;
   using CppAD::AD;
   //
   using CppAD::mixed::d_sparse_rcv;
   using CppAD::mixed::d_vector;
   //
   class mixed_derived : public cppad_mixed {
   public:
      CppAD::vector<std::string> warning_message_;
      //
      // constructor
      mixed_derived(
         size_t                 n_fixed        ,
         size_t                 n_random       ,
         bool                   quasi_fixed    ,
         bool                   bool_sparsity  )
         :
         cppad_mixed(n_fixed, n_random, quasi_fixed, bool_sparsity)
      { }
      // example changing fatal error handler
      virtual void fatal_error(const std::string& error_message)
      {  // throw a std:string
         throw error_message;
      }
      //
      // example changing warning handler
      virtual void warning(const std::string& warning_message)
      {  warning_message_.push_back( warning_message );
      }
   };
}

bool derived_ctor_xam(void)
{
   //
   size_t n_fixed     = 1;
   size_t n_random    = 0;
   bool quasi_fixed   = true;
   bool bool_sparsity = true;
   //
   d_vector fixed_vec(n_fixed), random_vec(n_random);
   fixed_vec[0] = 0.0;
   //
   mixed_derived mixed_object(
      n_fixed, n_random, quasi_fixed, bool_sparsity
   );
   // One normally does not store the return value of initialize
   // (size_map is included here to show how it can be displayed).
   std::map<std::string, size_t> size_map;
   size_map = mixed_object.initialize(fixed_vec, random_vec);
   //
   bool ok = false;
   try
   {  // warnings
      mixed_object.warning("first warning");
      mixed_object.warning("second warning");

      // fatal error
      mixed_object.fatal_error("only fatal error");
   }
   catch ( std::string error_message)
   {  ok  = true;
      ok &= error_message == "only fatal error";
      //
      ok &= mixed_object.warning_message_.size() == 2;
      ok &= mixed_object.warning_message_[0] == "first warning";
      ok &= mixed_object.warning_message_[1] == "second warning";
   }
   //
   // check that the specified fields are in size_map
   const char* key_list[] = {
      "n_fixed",
      "n_random",
      "quasi_fixed",
      "A_nr",
      "A_nnz",
      "ran_like_fun.size_var",
      "fix_like_fun.size_var"
   };
   size_t n_list = sizeof(key_list) / sizeof(key_list[0]);
   for(size_t i = 0; i < n_list; ++i)
   {  std::string key = key_list[i];
      std::map<std::string, size_t>::iterator itr;
      itr = size_map.find(key);
      ok &= itr != size_map.end();
   }
   // The following code can be used to display size_map
   // std::map<std::string, size_t>::iterator itr;
   // for(itr = size_map.begin(); itr != size_map.end(); itr++)
   //  std::cout << itr->first << " = " << itr->second << "\n";
   //
   return ok;
}