jade::basic_controller< TValue > Class Template Reference

A template for a class that performs the Nelder-Mead optimization. This class implements shared features of the two concrete controllers of this module, one that uses a Newick tree as input and another that does not. More...

#include <jade.controller.hpp>

Inheritance diagram for jade::basic_controller< TValue >:

Collaboration diagram for jade::basic_controller< TValue >:

Public Types
typedef TValue	value_type
	The value type. More...
typedef basic_likelihood< value_type >	likelihood_type
	The likelihood type. More...
typedef basic_matrix< value_type >	matrix_type
	The matrix type. More...
typedef basic_options< value_type >	options_type
	The options type. More...
typedef basic_settings< value_type >	settings_type
	The settings type. More...
typedef basic_simplex< value_type >	simplex_type
	The simplex type. More...
typedef simplex_type::container_type	container_type
	The container type for the simplex. 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
virtual	~basic_controller ()
	Reclaims resources, if any, used by the instance. 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
virtual container_type	init_parameters ()=0
	Creates and returns the initial set of parameters for the Nelder- Mead algorithm. More...
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
	basic_controller (const settings_type &settings)
	Initializes a new instance of the class based on the specified settings. More...
virtual bool	_decode_lower (matrix_type &dst, const container_type &src)=0
	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_controller< TValue >

A template for a class that performs the Nelder-Mead optimization. This class implements shared features of the two concrete controllers of this module, one that uses a Newick tree as input and another that does not.

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

Member Typedef Documentation

container_type

template<typename TValue >

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

The container type for the simplex.

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

exit_condition_type

template<typename TValue >

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

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

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

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_controller< TValue >::matrix_type

The matrix type.

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

options_type

template<typename TValue >

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

The options type.

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

settings_type

template<typename TValue >

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

The settings type.

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

simplex_type

template<typename TValue >

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

The simplex type.

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

value_type

template<typename TValue >

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

The value type.

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

Constructor & Destructor Documentation

~basic_controller()

template<typename TValue >

virtual jade::basic_controller< TValue >::~basic_controller ( )

inlinevirtual

Reclaims resources, if any, used by the instance.

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

        {
        }

basic_controller()

template<typename TValue >

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

inlineexplicitprotected

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

Parameters

settings

The algorithm settings.

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

            : _rk             (settings.get_rf().get_height())
            , _c              (settings.get_c())
            , _lle            (0)
            , _likelihood     (settings.get_rf(), settings.get_mu())
            , _iteration_time ()
        {
            assert(_rk > 0);
            assert(_c.is_size(_rk, _rk));
        }

Here is the call graph for this function:

Member Function Documentation

_decode_lower()

template<typename TValue >

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

protectedpure virtual

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

Returns

True if successful; otherwise, false.

Parameters

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

Implemented in jade::basic_treeless_controller< TValue >, jade::basic_tree_controller< TValue >, and jade::basic_agi_controller< TValue >.

Here is the caller graph for this function:

compute_objfunc()

template<typename TValue >

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

inline

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 &    )

inlinevirtual

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

inline

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

inline

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_controller< TValue >::init_parameters ( )

pure virtual

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

Returns

The initial parameters for the Nelder-Mead algorithm.

Implemented in jade::basic_treeless_controller< TValue >, jade::basic_tree_controller< TValue >, and jade::basic_agi_controller< TValue >.

Here is the caller graph for this function:

log_iteration()

template<typename TValue >

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

inline

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.controller.hpp