jade::basic_likelihood< TValue > Class Template Reference

A template for a class that efficiently computes a log-likelihood based on 1) the log of the determinant for a covariance matrix and 2) the inverse of the covariance matrix. The class caches values based on a [K-1 x J] rooted F matrix for major allele frequencies and a [J x 1] mu vector. More...

#include <jade.likelihood.hpp>

Inheritance diagram for jade::basic_likelihood< TValue >:

Collaboration diagram for jade::basic_likelihood< TValue >:

Public Types
typedef TValue	value_type
	The value type. More...
typedef basic_matrix< value_type >	matrix_type
	The matrix type. More...

Public Member Functions
	basic_likelihood (const matrix_type &rf, const matrix_type &mu)
	Initializes the class based on a rooted F matrix for major allele frequencies and a mu vector; the constructor caches values based on the supplied arguments. More...
value_type	operator() (const matrix_type &c_inv, const value_type log_c_det)

Detailed Description

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

A template for a class that efficiently computes a log-likelihood based on 1) the log of the determinant for a covariance matrix and 2) the inverse of the covariance matrix. The class caches values based on a [K-1 x J] rooted F matrix for major allele frequencies and a [J x 1] mu vector.

Definition at line 22 of file jade.likelihood.hpp.

Member Typedef Documentation

matrix_type

template<typename TValue >

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

The matrix type.

Definition at line 29 of file jade.likelihood.hpp.

value_type

template<typename TValue >

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

The value type.

Definition at line 26 of file jade.likelihood.hpp.

Constructor & Destructor Documentation

basic_likelihood()

template<typename TValue >

jade::basic_likelihood< TValue >::basic_likelihood ( const matrix_type &  rf, const matrix_type &  mu  )

inline

Initializes the class based on a rooted F matrix for major allele frequencies and a mu vector; the constructor caches values based on the supplied arguments.

Parameters

rf	The rooted F matrix.
mu	The mu vector.

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

            : _rf      (rf)
            , _mux     (_init_mux(mu))
            , _rkltmux (_init_rkltmux(rf.get_height(), _mux))
            , _mul     (rf.get_height(), rf.get_width())
        {
            assert(mu.get_height() == rf.get_width());
        }

Member Function Documentation

operator()()

template<typename TValue >

value_type jade::basic_likelihood< TValue >::operator() ( const matrix_type &  c_inv, const value_type  log_c_det  )

inline

Returns

The log-likelihood using values cached during the initializaiton of this instance and the supplied arguments.

Parameters

c_inv	The inverted C matrix.
log_c_det	The log of det(C).

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

        {
            const auto RK = _rf.get_height();
            const auto J  = _rf.get_width();
 
            assert(c_inv.is_size(RK, RK));
 
            //
            // Use LAPACK to multiply c_inv and _rf; store the result in the
            // pre-allocated _mul matrix, which is of size [RK x J].
            //
            matrix_type::gemm(c_inv, _rf, _mul);
 
            auto sum = value_type(0);
 
            //
            // Loop over the J columns of _mul.
            //
            auto       rkltmux_ptr = _rkltmux.get_data();
            auto       mux_ptr     = _mux.get_data();
            const auto mux_end     = _mux.get_data() + J;
            auto       rf_ptr      = _rf.get_data();
            auto       mul_ptr     = _mul.get_data();
            while (mux_ptr != mux_end)
            {
                //
                // Do not process columns with non-positive mux[j].
                //
                const auto rkltmux = *rkltmux_ptr++;
                const auto mux     = *mux_ptr++;
                if (mux <= value_type(0))
                    continue;
 
                auto zip = value_type(0);
 
                //
                // Loop over the RK rows of _mul and _rf and sum the products of
                // rf[rk, j] * mul[rk, j].
                //
                const auto rf_anchor  = rf_ptr;
                const auto mul_anchor = mul_ptr;
                const auto mul_end    = mul_ptr + (RK * J);
                while (mul_ptr != mul_end)
                {
                    zip     += *rf_ptr * *mul_ptr;
                    rf_ptr  += J;
                    mul_ptr += J;
                }
 
                //
                // For this column of J, add
                // RK*log(2*pi * mux[j]) + (zip / mux[j]).
                //
                sum += rkltmux + (zip / mux);
 
                //
                // Advance to the next columns.
                //
                rf_ptr  = rf_anchor + 1;
                mul_ptr = mul_anchor + 1;
            }
 
            //
            // The log-likelihood: -0.5 * (J * log(det(C)) + sum).
            //
            return value_type(-0.5) * ((value_type(J) * log_c_det) + sum);
        }

---

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

• jade.likelihood.hpp