jade::basic_agi_controller< TValue > Class Template Reference

A template for a class that encodes and decodes parameters for the Nelder-Mead algorithm. This class uses an admixture graph input file. More...

#include <jade.agi_controller.hpp>

Inheritance diagram for jade::basic_agi_controller< TValue >:

Collaboration diagram for jade::basic_agi_controller< TValue >:

Public Types
typedef TValue	value_type
	The value type. More...
typedef basic_agi_reader< value_type >	agi_reader_type
	The admixture graph input reader type. More...
typedef basic_shunting_yard< value_type >	shunting_yard_type
	The shunting-yard algorithm type. More...
typedef shunting_yard_type::args_type	args_type
	The arguments passed to the shunting-yard algorithm. 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 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_agi_controller (const settings_type &settings)
	Initializes a new instance of the class based on the specified program settings. More...
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...
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
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_agi_controller< TValue >

A template for a class that encodes and decodes parameters for the Nelder-Mead algorithm. This class uses an admixture graph input file.

Definition at line 19 of file jade.agi_controller.hpp.

Member Typedef Documentation

agi_reader_type

template<typename TValue >

typedef basic_agi_reader<value_type> jade::basic_agi_controller< TValue >::agi_reader_type

The admixture graph input reader type.

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

args_type

template<typename TValue >

typedef shunting_yard_type::args_type jade::basic_agi_controller< TValue >::args_type

The arguments passed to the shunting-yard algorithm.

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

container_type

template<typename TValue >

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

The container type for the simplex.

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

exit_condition_type

template<typename TValue >

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

The exit condition type for the simplex.

Definition at line 51 of file jade.agi_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_agi_controller< TValue >::matrix_type

The matrix type.

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

options_type

template<typename TValue >

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

The options type.

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

settings_type

template<typename TValue >

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

The settings type.

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

shunting_yard_type

template<typename TValue >

typedef basic_shunting_yard<value_type> jade::basic_agi_controller< TValue >::shunting_yard_type

The shunting-yard algorithm type.

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

simplex_type

template<typename TValue >

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

The simplex type.

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

value_type

template<typename TValue >

typedef TValue jade::basic_agi_controller< TValue >::value_type

The value type.

Definition at line 24 of file jade.agi_controller.hpp.

Constructor & Destructor Documentation

basic_agi_controller()

template<typename TValue >

jade::basic_agi_controller< TValue >::basic_agi_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 57 of file jade.agi_controller.hpp.

            : basic_controller<TValue> (settings)
            , _agi                     (settings.get_agi())
            , _args                    (_agi.get_args())
        {
        }

Member Function Documentation

_decode_lower()

template<typename TValue >

bool jade::basic_agi_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 if successful; otherwise, false.

Parameters

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

Implements jade::basic_controller< TValue >.

Definition at line 116 of file jade.agi_controller.hpp.

        {
            //
            // If any value in the container is not positive, then return false
            // to indicate these are unacceptable values.
            //
            for (const auto item : src)
                if (item <= value_type(0))
                    return false;
 
            //
            // If any value corresponding to a proportion is not less than one,
            // then return false to indicate these are unacceptable values.
            // Note the proportion variables are stored first in the container
            // (and are followed by the branch variables).
            //
            {
                const auto n = _agi.get_proportion_names().size();
                for (size_t i = 0; i < n; i++)
                    if (src[i] >= value_type(1))
                        return false;
            }
 
            //
            // Copy the values from the Nelder-Mead container into the table
            // of arguments used to evaluate the expression. Since these values
            // are the same for all expressions, the same container is used for
            // each expression evaluated.
            //
            {
                size_t i = 0;
                for (const auto & name : _agi.get_proportion_names())
                    _args[name] = src[i++];
                for (const auto & name : _agi.get_branch_names())
                    _args[name] = src[i++];
            }
 
            //
            // Copy the expression output to the lower-triangle of the
            // covariance matrix:
            //
            //  | 0 - - |
            //  | 1 2 - |
            //  | 3 4 5 |
            //
            // Each value in the matrix is determined by evaluating a
            // corresponding expression.
            //
            {
                const auto & entries = _agi.get_entries();
                const auto   rk      = _agi.get_k() - 1;
                size_t       i       = 0;
                for (size_t row = 0; row < rk; row++)
                    for (size_t col = 0; col <= row; col++)
                        dst(row, col) = entries[i++].evaluate(_args);
            }
 
            //
            // Return true to indicate the values are acceptable.
            //
            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 >

void jade::basic_agi_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 68 of file jade.agi_controller.hpp.

        {
            //
            // The base class emits the C matrix; this also has the effect of
            // updating the arguments used to evaluate the expressions.
            //
            basic_controller<TValue>::emit_results(opts, simplex, condition);
 
            //
            // Loop over each argument and display its value.
            //
            std::cout << "\n[Admixture Graph Output]\n";
            matrix_type::set_high_precision(std::cout);
            for (const auto & name : _agi.get_branch_names())
                std::cout << name << "\t" << _args[name] << "\n";
            for (const auto & name : _agi.get_proportion_names())
                std::cout << name << "\t" << _args[name] << "\n";
            std::cout.flush();
        }

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 >

container_type jade::basic_agi_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 98 of file jade.agi_controller.hpp.

        {
            //
            // Return a container initially filled with 0.5 for both branch and
            // proportion variables.
            //
            container_type out;
            out.resize(_args.size(), value_type(0.5));
            return out;
        }

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