jade::basic_tree_controller< TValue > Class Template Reference

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

#include <jade.tree_controller.hpp>

Inheritance diagram for jade::basic_tree_controller< TValue >:

Collaboration diagram for jade::basic_tree_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_options< value_type >	options_type
	The options type. More...
typedef basic_settings< value_type >	settings_type
	The settings type. More...
typedef basic_tree_path< value_type >	path_type
	The path type. More...
typedef basic_simplex< value_type >	simplex_type
	The simplex type. More...
typedef basic_rerooted_tree< value_type >	rerooted_tree_type
	The rerooted tree type. More...
typedef basic_newick_node< value_type >	unrooted_tree_type
	The unrooted tree type. More...
typedef std::unique_ptr< unrooted_tree_type >	unrooted_tree_ptr_type
	The pointer to an unrooted tree 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 type for the simplex. More...
typedef basic_likelihood< value_type >	likelihood_type
	The likelihood type. More...
typedef simplex_type::log_args	log_args_type
	The loc arguments for the simplex. More...

Public Member Functions
	basic_tree_controller (const settings_type &settings)
	Initializes a new instance of the class based on the specified program settings. More...
virtual void	emit_results (const options_type &opts, const simplex_type &simplex, const exit_condition_type &condition) override
	Writes results to standard output and files. 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...
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_tree_controller< TValue >

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

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

Member Typedef Documentation

container_type

template<typename TValue >

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

The container type for the simplex.

Definition at line 52 of file jade.tree_controller.hpp.

exit_condition_type

template<typename TValue >

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

The exit condition type for the simplex.

Definition at line 55 of file jade.tree_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_tree_controller< TValue >::matrix_type

The matrix type.

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

options_type

template<typename TValue >

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

The options type.

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

path_type

template<typename TValue >

typedef basic_tree_path<value_type> jade::basic_tree_controller< TValue >::path_type

The path type.

Definition at line 37 of file jade.tree_controller.hpp.

rerooted_tree_type

template<typename TValue >

typedef basic_rerooted_tree<value_type> jade::basic_tree_controller< TValue >::rerooted_tree_type

The rerooted tree type.

Definition at line 43 of file jade.tree_controller.hpp.

settings_type

template<typename TValue >

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

The settings type.

Definition at line 34 of file jade.tree_controller.hpp.

simplex_type

template<typename TValue >

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

The simplex type.

Definition at line 40 of file jade.tree_controller.hpp.

unrooted_tree_ptr_type

template<typename TValue >

typedef std::unique_ptr<unrooted_tree_type> jade::basic_tree_controller< TValue >::unrooted_tree_ptr_type

The pointer to an unrooted tree type.

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

unrooted_tree_type

template<typename TValue >

typedef basic_newick_node<value_type> jade::basic_tree_controller< TValue >::unrooted_tree_type

The unrooted tree type.

Definition at line 46 of file jade.tree_controller.hpp.

value_type

template<typename TValue >

typedef TValue jade::basic_tree_controller< TValue >::value_type

The value type.

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

Constructor & Destructor Documentation

basic_tree_controller()

template<typename TValue >

jade::basic_tree_controller< TValue >::basic_tree_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 61 of file jade.tree_controller.hpp.

            : basic_controller<TValue> (settings)
            , _settings          (settings)
            , _table             ()
            , _unrooted_tree_ptr ()
            , _rerooted_tree     ()
        {
            const auto rk = this->get_rk();
 
            //
            // Parse the Newick-formatted file into a tree structure.
            //
            _unrooted_tree_ptr.reset(
                unrooted_tree_type::from_file(
                    settings.get_options().get_tin()));
 
            //
            // Initialize the rerooted tree.
            //
            _rerooted_tree.reset(*_unrooted_tree_ptr);
 
            //
            // Loop over the rows and columns of the lower triangle, and for
            // each cell in the covariance matrix, create a corresponding
            // table entry.
            //
            for (size_t r = 0; r < rk; r++)
                for (size_t c = 0; c <= r; c++)
                    _table.emplace_back(_rerooted_tree, r, c);
        }

Here is the call graph for this function:

Member Function Documentation

_decode_lower()

template<typename TValue >

virtual bool jade::basic_tree_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 153 of file jade.tree_controller.hpp.

        {
            //
            // Copy the container values into the tree, which will be used to
            // build the covariance matrix.
            //
            auto iterator = src.begin();
            _copy_container_to_tree(_rerooted_tree.get_tree(), iterator);
 
            //
            // Loop over every table entry, which corresponds to the lower
            // triangle of the covariance matrix; compute and store the sum
            // of the lengths from the nodes that contribute to its value.
            //
            for (const auto & entry : _table)
                dst[entry.i] = entry.p.get_length();
 
            //
            // 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_tree_controller< TValue >::emit_results ( const options_type &  opts, const simplex_type &  simplex, const exit_condition_type &  condition  )

inlineoverridevirtual

Writes results to standard output and files.

Parameters

opts	The options.
simplex	The simplex.
condition	The context.

Reimplemented from jade::basic_controller< TValue >.

Definition at line 96 of file jade.tree_controller.hpp.

        {
            //
            // The base class emits the C matrix; this also has the effect of
            // updating the tree with the optimized lengths.
            //
            basic_controller<TValue>::emit_results(opts, simplex, condition);
 
            //
            // Copy values back to the original tree. First reroot the tree to
            // its original structure so the order of the children is
            // consistent with the file specified by the user.
            //
            const auto root_id = _unrooted_tree_ptr->get_id();
            unrooted_tree_ptr_type source_root (
                _rerooted_tree.get_tree().find_id(root_id)->reroot());
            _unrooted_tree_ptr->for_each([&](node_type * const target) -> void
            {
                const auto id     = target->get_id();
                const auto source = source_root->find_id(id);
                if (source->has_length())
                    target->set_length(source->get_length());
                else
                    target->erase_length();
            });
 
            if (opts.is_tout_specified())
            {
                const auto & tout = opts.get_tout();
                std::cout << "Writing tree to " << tout << std::endl;
                _unrooted_tree_ptr->write(tout);
            }
            else
            {
                std::cout << "\n[Tree]\n" << *_unrooted_tree_ptr << std::endl;
            }
        }

Here is the call 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_tree_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 139 of file jade.tree_controller.hpp.

        {
            container_type container;
            _copy_tree_to_container(container, _rerooted_tree.get_tree());
            return container;
        }

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