A template for a class that encodes and decodes parameters for the Nelder-Mead algorithm. This class does not use a user-specified Newick tree. More...

#include <jade.treeless_controller.hpp>

Inheritance diagram for jade::basic_treeless_controller< TValue >:

Collaboration diagram for jade::basic_treeless_controller< TValue >:

Public Types
typedef TValue	value_type
	The value type. More...

typedef basic_matrix< value_type >	matrix_type
	The matrix type. More...

typedef basic_settings< value_type >	settings_type
	The settings type. More...

typedef basic_controller< TValue >::container_type	container_type
	The container type for the controller. More...

typedef basic_likelihood< value_type >	likelihood_type
	The likelihood type. More...

typedef basic_options< value_type >	options_type
	The options type. More...

typedef basic_simplex< value_type >	simplex_type
	The simplex type. More...

typedef simplex_type::exit_condition_type	exit_condition_type
	The exit condition for the simplex. More...

typedef simplex_type::log_args	log_args_type
	The loc arguments for the simplex. More...

Public Member Functions
	basic_treeless_controller (const settings_type &settings)
	Initializes a new instance of the class based on the specified program settings. More...

virtual container_type	init_parameters () override
	Creates and returns the initial set of parameters for the Nelder- Mead algorithm. More...

value_type	compute_objfunc (const container_type &params)
	Computes the objective function by decoding the specified Nelder- Mead parameters into a covariance matrix, performing a Cholskey square root, calculating the determinant, computing the inverse, and calling the likelihood function. More...

virtual void	emit_results (const options_type &opts, const simplex_type &simplex, const exit_condition_type &)
	Writes results to standard output and files. More...

const matrix_type &	get_c () const

size_t	get_rk () const

void	log_iteration (const log_args_type &log_args)
	Logs information about the specified context for one iteration of the Nelder-Mead algorithm. More...

Protected Member Functions
virtual bool	_decode_lower (matrix_type &dst, const container_type &src) override
	Decodes the specified Nelder-Mead container and stores the result into the lower triangle, including the diagonal, of the covariance matrix. More...

Detailed Description

template<typename TValue>
class jade::basic_treeless_controller< TValue >

A template for a class that encodes and decodes parameters for the Nelder-Mead algorithm. This class does not use a user-specified Newick tree.

Definition at line 20 of file jade.treeless_controller.hpp.

Member Typedef Documentation

◆ container_type

template<typename TValue >

typedef basic_controller<TValue>::container_type jade::basic_treeless_controller< TValue >::container_type

The container type for the controller.

Definition at line 36 of file jade.treeless_controller.hpp.

◆ exit_condition_type

template<typename TValue >

typedef simplex_type::exit_condition_type jade::basic_controller< TValue >::exit_condition_type

inherited

The exit condition for the simplex.

Definition at line 48 of file jade.controller.hpp.

◆ likelihood_type

template<typename TValue >

typedef basic_likelihood<value_type> jade::basic_controller< TValue >::likelihood_type

inherited

The likelihood type.

Definition at line 30 of file jade.controller.hpp.

◆ log_args_type

template<typename TValue >

typedef simplex_type::log_args jade::basic_controller< TValue >::log_args_type

inherited

The loc arguments for the simplex.

Definition at line 51 of file jade.controller.hpp.

◆ matrix_type

template<typename TValue >

typedef basic_matrix<value_type> jade::basic_treeless_controller< TValue >::matrix_type

The matrix type.

Definition at line 28 of file jade.treeless_controller.hpp.

◆ options_type

template<typename TValue >

typedef basic_options<value_type> jade::basic_controller< TValue >::options_type

inherited

The options type.

Definition at line 36 of file jade.controller.hpp.

◆ settings_type

template<typename TValue >

typedef basic_settings<value_type> jade::basic_treeless_controller< TValue >::settings_type

The settings type.

Definition at line 31 of file jade.treeless_controller.hpp.

◆ simplex_type

template<typename TValue >

typedef basic_simplex<value_type> jade::basic_controller< TValue >::simplex_type

inherited

The simplex type.

Definition at line 42 of file jade.controller.hpp.

◆ value_type

template<typename TValue >

typedef TValue jade::basic_treeless_controller< TValue >::value_type

The value type.

Definition at line 25 of file jade.treeless_controller.hpp.

Constructor & Destructor Documentation

◆ basic_treeless_controller()

template<typename TValue >

jade::basic_treeless_controller< TValue >::basic_treeless_controller ( const settings_type & settings )

inlineexplicit

Initializes a new instance of the class based on the specified program settings.

Parameters

settings The program settings.

Definition at line 42 of file jade.treeless_controller.hpp.

             : basic_controller<TValue> (settings)
         {
         }

Member Function Documentation

◆ _decode_lower()

template<typename TValue >

virtual bool jade::basic_treeless_controller< TValue >::_decode_lower	(	matrix_type &	dst,
		const container_type &	src
	)

inlineoverrideprotectedvirtual

Decodes the specified Nelder-Mead container and stores the result into the lower triangle, including the diagonal, of the covariance matrix.

Returns: True to indicate this method is successful.

Parameters

dst	The covariance matrix.
src	The Nelder-Mead container.

Implements jade::basic_controller< TValue >.

Definition at line 104 of file jade.treeless_controller.hpp.

         {
             const auto rk = this->get_rk();
  
             //
             // The container contains the lower-right triangle of data,
             // including the diagonal. This comes to RK * RK (the total number
             // of items in the matrix), subtract RK (the number of items in the
             // diagonal), divide by two (only half of these elements), plus RK
             // (the number of items in the diagonal).
             //
             assert(src.size() == rk + ((rk * rk) - rk) / 2);
  
             //
             // Pointers to the start and end of the first column.
             //
             auto       dst_ptr = dst.get_data();
             auto       dst_end = dst.get_data() + dst.get_length();
             auto       src_ptr = src.data();
             const auto src_end = src.data() + src.size();
  
             //
             // Loop over every row/column.
             //
             while (src_ptr != src_end)
             {
                 //
                 // Don't lose track of the start of the column data.
                 //
                 const auto anchor = dst_ptr;
  
                 //
                 // Copy the rows of the column from the diagonal to the end.
                 //
                 for (; dst_ptr != dst_end; dst_ptr += rk)
                     *dst_ptr = *src_ptr++;
  
                 //
                 // The next start-of-column is below and to the right of the
                 // previous one. The next end-of-column is one to the right.
                 //
                 dst_ptr = anchor + rk + 1;
                 dst_end++;
             }
  
             //
             // This method is always successful.
             //
             return true;
         }

Here is the call graph for this function:

◆ compute_objfunc()

template<typename TValue >

value_type jade::basic_controller< TValue >::compute_objfunc ( const container_type & params )

inlineinherited

Computes the objective function by decoding the specified Nelder- Mead parameters into a covariance matrix, performing a Cholskey square root, calculating the determinant, computing the inverse, and calling the likelihood function.

Returns: The negation of the log likelihood.

Parameters

params The parameters.

Definition at line 68 of file jade.controller.hpp.

         {
             static const auto inf = std::numeric_limits<value_type>::max();
  
             //
             // The LAPACK routines need only the lower triangle stored in
             // the matrix. If these routines are successful, the lower
             // triangle is copied to the upper triangle before calculating
             // the likelihood.
             //
             if (!_decode_lower(_c, params))
                 return inf;
  
             //
             // Variance and covariance values must be positive; if one is not,
             // return infinity to reject these parameters.
             //
             for (size_t row = 0; row < _rk; row++)
                 for (size_t col = 0; col <= row; col++)
                     if (_c(row, col) <= value_type(0))
                         return inf;
  
             //
             // Compute the inverse and the log of the determinant. If this
             // fails, the matrix is not positive semidefinite; return Infinity
             // to indicate these are unacceptable parameters.
             //
             value_type log_c_det;
             if (!_c.invert(log_c_det))
                 return inf;
  
             //
             // The Nelder-Mead algorithm minimizes the objective function, so
             // return the negation of the log-likelihood function.
             //
             return -_likelihood(_c, log_c_det);
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ emit_results()

template<typename TValue >

virtual void jade::basic_controller< TValue >::emit_results	(	const options_type &	opts,
		const simplex_type &	simplex,
		const exit_condition_type &
	)

inlinevirtualinherited

Writes results to standard output and files.

Parameters

opts	The options.
simplex	The simplex.

Reimplemented in jade::basic_tree_controller< TValue >, and jade::basic_agi_controller< TValue >.

Definition at line 110 of file jade.controller.hpp.

         {
             //
             // Decode the final set of parameters (the optimized matrix).
             //
             _decode_lower(_c, simplex.get_vertex());
             _c.copy_lower_to_upper();
  
             //
             // Display the log-likelihood, which is the negative of the last
             // value from the objective function.
             //
             std::cout
                 << "\nlog likelihood = "
                 << -simplex.get_objval()
                 << std::endl;
  
             //
             // Display or save the covariance matrix.
             //
             if (opts.is_cout_specified())
             {
                 const auto & cout = opts.get_cout();
                 std::cout << "Writing C matrix to " << cout << std::endl;
  
                 std::ofstream out (cout);
                 if (!out.good())
                     throw error() << "failed to create matrix '" << cout << "'";
  
                 matrix_type::set_high_precision(out);
                 out << _c;
             }
             else
             {
                 std::cout << "[C Matrix]\n";
                 matrix_type::set_high_precision(std::cout);
                 std::cout << _c << std::endl;
             }
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_c()

template<typename TValue >

const matrix_type& jade::basic_controller< TValue >::get_c ( ) const

inlineinherited

Returns: A reference to the covariance matrix.

Definition at line 156 of file jade.controller.hpp.

         {
             return _c;
         }

Here is the caller graph for this function:

◆ get_rk()

template<typename TValue >

size_t jade::basic_controller< TValue >::get_rk ( ) const

inlineinherited

Returns: The rooted K value for this instance.

Definition at line 164 of file jade.controller.hpp.

         {
             return _rk;
         }

Here is the caller graph for this function:

◆ init_parameters()

template<typename TValue >

virtual container_type jade::basic_treeless_controller< TValue >::init_parameters ( )

inlineoverridevirtual

Creates and returns the initial set of parameters for the Nelder- Mead algorithm.

Returns: The initial parameters for the Nelder-Mead algorithm.

Implements jade::basic_controller< TValue >.

Definition at line 49 of file jade.treeless_controller.hpp.

         {
             const auto & c  = this->get_c();
             const auto   rk = this->get_rk();
             assert(c.get_height() == rk);
  
             //
             // The container contains the lower-right triangle of data,
             // including the diagonal. This comes to RK * RK (the total number
             // of items in the matrix), subtract RK (the number of items in the
             // diagonal), divide by two (only half of these elements), plus RK
             // (the number of items in the diagonal).
             //
             container_type params;
             params.reserve(rk + ((rk * rk) - rk) / 2);
  
             //
             // Pointers to the start and end of the first row. Note the
             // covariance matrix is symmetric.
             //
             auto src_ptr = c.get_data();
             auto src_end = c.get_data() + rk;
  
             //
             // Loop over every row/column.
             //
             for (size_t i = 0; i < rk; i++)
             {
                 //
                 // Skip the columns before the diagonal.
                 //
                 src_ptr += i;
  
                 //
                 // Copy all columns from the diagonal to the end of the row.
                 //
                 while (src_ptr != src_end)
                     params.push_back(*src_ptr++);
  
                 //
                 // Advance the next end-of-row RK elements ahead.
                 //
                 src_end += rk;
             }
  
             return params;
         }

Here is the call graph for this function:

◆ log_iteration()

template<typename TValue >

void jade::basic_controller< TValue >::log_iteration ( const log_args_type & log_args )

inlineinherited

Logs information about the specified context for one iteration of the Nelder-Mead algorithm.

Parameters

log_args The Nelder-Mead arguments.

Definition at line 181 of file jade.controller.hpp.

         {
             const auto lle = -log_args.simplex->get_objval();
  
             const auto dlle = log_args.iteration == 1
                 ? value_type(0)
                 : lle - _lle;
  
             std::ostringstream line;
             line << log_args.iteration
                  << std::fixed << std::setprecision(6)
                  << '\t' << _iteration_time;
             matrix_type::set_high_precision(line);
             line << '\t' << dlle << '\t' << lle;
             std::cout << line.str() << std::endl;
  
             _lle = lle;
             _iteration_time = stopwatch();
         }

Here is the call graph for this function:

The documentation for this class was generated from the following file:

jade.treeless_controller.hpp

Public Types

Public Member Functions

Protected Member Functions

Detailed Description

template<typename TValue> class jade::basic_treeless_controller< TValue >

Member Typedef Documentation

◆ container_type

◆ exit_condition_type

◆ likelihood_type

◆ log_args_type

◆ matrix_type

◆ options_type

◆ settings_type

◆ simplex_type

◆ value_type

Constructor & Destructor Documentation

◆ basic_treeless_controller()

Member Function Documentation

◆ _decode_lower()

◆ compute_objfunc()

◆ emit_results()

◆ get_c()

◆ get_rk()

◆ init_parameters()

◆ log_iteration()

template<typename TValue>
class jade::basic_treeless_controller< TValue >