jade::basic_forced_grouping< TValue > Class Template Reference

A template for a class that implements the forced grouping feature. More...

#include <jade.forced_grouping.hpp>

Collaboration diagram for jade::basic_forced_grouping< TValue >:

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

Public Member Functions
	basic_forced_grouping ()
	Initializes a new instance of the class. More...
	basic_forced_grouping (char const *const path)
	Initializes a new instance of the class based on values from the specified file. More...
	basic_forced_grouping (const std::string &path)
	Initializes a new instance of the class based on values from the specified file. More...
size_t	get_i () const
size_t	get_k () const
value_type	get_max (const size_t i, const size_t k) const
value_type	get_min (const size_t i, const size_t k) const
matrix_type	randomize_q (randomizer_type &rnd) const
bool	validate_q (const matrix_type &q) const
	Validates the Q matrix and throws an exception if validation fails. More...
	basic_forced_grouping ()
	Initializes a new instance of the class. More...
	basic_forced_grouping (char const *const path)
	Initializes a new instance of the class based on values from the specified file. More...
	basic_forced_grouping (const std::string &path)
	Initializes a new instance of the class based on values from the specified file. More...
size_t	get_i () const
size_t	get_k () const
value_type	get_max (const size_t i, const size_t k) const
value_type	get_min (const size_t i, const size_t k) const
matrix_type	randomize_q (randomizer_type &rnd) const
bool	validate_q (const matrix_type &q) const
	Validates the Q matrix and throws an exception if validation fails. More...

Detailed Description

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

A template for a class that implements the forced grouping feature.

Definition at line 18 of file cpax/jade.forced_grouping.hpp.

Member Typedef Documentation

matrix_type [1/2]

template<typename TValue >

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

The matrix type.

Definition at line 25 of file cpax/jade.forced_grouping.hpp.

matrix_type [2/2]

template<typename TValue >

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

The matrix type.

Definition at line 25 of file qpas/jade.forced_grouping.hpp.

randomizer_type [1/2]

template<typename TValue >

typedef basic_randomizer<value_type> jade::basic_forced_grouping< TValue >::randomizer_type

The randomizer type.

Definition at line 28 of file cpax/jade.forced_grouping.hpp.

randomizer_type [2/2]

template<typename TValue >

typedef basic_randomizer<value_type> jade::basic_forced_grouping< TValue >::randomizer_type

The randomizer type.

Definition at line 28 of file qpas/jade.forced_grouping.hpp.

value_type [1/2]

template<typename TValue >

typedef TValue jade::basic_forced_grouping< TValue >::value_type

The value type.

Definition at line 22 of file cpax/jade.forced_grouping.hpp.

value_type [2/2]

template<typename TValue >

typedef TValue jade::basic_forced_grouping< TValue >::value_type

The value type.

Definition at line 22 of file qpas/jade.forced_grouping.hpp.

Constructor & Destructor Documentation

basic_forced_grouping() [1/6]

template<typename TValue >

jade::basic_forced_grouping< TValue >::basic_forced_grouping ( )

inline

Initializes a new instance of the class.

Definition at line 33 of file cpax/jade.forced_grouping.hpp.

            : _a ()
            , _b ()
            , _i (0)
            , _k (0)
        {
        }

basic_forced_grouping() [2/6]

template<typename TValue >

jade::basic_forced_grouping< TValue >::basic_forced_grouping ( char const *const  path )

inlineexplicit

Initializes a new instance of the class based on values from the specified file.

Parameters

path	The path to the file.

Definition at line 45 of file cpax/jade.forced_grouping.hpp.

            : _a ()
            , _b ()
            , _i ()
            , _k ()
        {
            assert(path != nullptr);
            try
            {
                std::istringstream in (_strip_comments(path));
 
                if (!(in >> _i) || _i == 0)
                    throw error()
                        << "error parsing number of individuals";
 
                if (!(in >> _k) || _k == 0)
                    throw error()
                        << "error parsing number of components";
 
                _a.reserve(_i);
 
                for (size_t i = 0; i < _i; i++)
                {
                    size_t value;
 
                    if (!(in >> value))
                        throw error()
                            << "error parsing component assignment "
                            << "for individual " << i+1;
 
                    _a.push_back(value);
                }
 
                const auto P = 1 + *std::max_element(_a.begin(), _a.end());
 
                _b.reserve(P);
 
                for (size_t p = 0; p < P; p++)
                {
                    try
                    {
                        _b.emplace_back(in);
                    }
                    catch (const std::exception & e)
                    {
                        throw error()
                            << "error reading B vector for population index "
                            << p << ": " << e.what();
                    }
                }
 
                _validate(in);
            }
            catch (const std::exception & e)
            {
                throw error() << "failed to read forced-grouping file '"
                              << path << "': " << e.what();
            }
        }

Here is the call graph for this function:

basic_forced_grouping() [3/6]

template<typename TValue >

jade::basic_forced_grouping< TValue >::basic_forced_grouping ( const std::string &  path )

inlineexplicit

Initializes a new instance of the class based on values from the specified file.

Parameters

path	The path to the file.

Definition at line 110 of file cpax/jade.forced_grouping.hpp.

            : basic_forced_grouping(path.c_str())
        {
        }

basic_forced_grouping() [4/6]

template<typename TValue >

jade::basic_forced_grouping< TValue >::basic_forced_grouping ( )

inline

Initializes a new instance of the class.

Definition at line 33 of file qpas/jade.forced_grouping.hpp.

            : _a ()
            , _b ()
            , _i (0)
            , _k (0)
        {
        }

basic_forced_grouping() [5/6]

template<typename TValue >

jade::basic_forced_grouping< TValue >::basic_forced_grouping ( char const *const  path )

inlineexplicit

Initializes a new instance of the class based on values from the specified file.

Parameters

path	The path to the file.

Definition at line 45 of file qpas/jade.forced_grouping.hpp.

            : _a ()
            , _b ()
            , _i ()
            , _k ()
        {
            assert(path != nullptr);
            try
            {
                std::istringstream in (_strip_comments(path));
 
                if (!(in >> _i) || _i == 0)
                    throw error()
                        << "error parsing number of individuals";
 
                if (!(in >> _k) || _k == 0)
                    throw error()
                        << "error parsing number of components";
 
                _a.reserve(_i);
 
                for (size_t i = 0; i < _i; i++)
                {
                    size_t value;
 
                    if (!(in >> value))
                        throw error()
                            << "error parsing component assignment "
                            << "for individual " << i+1;
 
                    _a.push_back(value);
                }
 
                const auto P = 1 + *std::max_element(_a.begin(), _a.end());
 
                _b.reserve(P);
 
                for (size_t p = 0; p < P; p++)
                {
                    try
                    {
                        _b.emplace_back(in);
                    }
                    catch (const std::exception & e)
                    {
                        throw error()
                            << "error reading B vector for population index "
                            << p << ": " << e.what();
                    }
                }
 
                _validate(in);
            }
            catch (const std::exception & e)
            {
                throw error() << "failed to read forced-grouping file '"
                              << path << "': " << e.what();
            }
        }

Here is the call graph for this function:

basic_forced_grouping() [6/6]

template<typename TValue >

jade::basic_forced_grouping< TValue >::basic_forced_grouping ( const std::string &  path )

inlineexplicit

Initializes a new instance of the class based on values from the specified file.

Parameters

path	The path to the file.

Definition at line 110 of file qpas/jade.forced_grouping.hpp.

            : basic_forced_grouping(path.c_str())
        {
        }

Member Function Documentation

get_i() [1/2]

template<typename TValue >

size_t jade::basic_forced_grouping< TValue >::get_i ( ) const

inline

Returns

The number of individuals.

Definition at line 119 of file cpax/jade.forced_grouping.hpp.

        {
            return _i;
        }

get_i() [2/2]

template<typename TValue >

size_t jade::basic_forced_grouping< TValue >::get_i ( ) const

inline

Returns

The number of individuals.

Definition at line 119 of file qpas/jade.forced_grouping.hpp.

        {
            return _i;
        }

get_k() [1/2]

template<typename TValue >

size_t jade::basic_forced_grouping< TValue >::get_k ( ) const

inline

Returns

The number of components.

Definition at line 127 of file cpax/jade.forced_grouping.hpp.

        {
            return _k;
        }

get_k() [2/2]

template<typename TValue >

size_t jade::basic_forced_grouping< TValue >::get_k ( ) const

inline

Returns

The number of components.

Definition at line 127 of file qpas/jade.forced_grouping.hpp.

        {
            return _k;
        }

get_max() [1/2]

template<typename TValue >

value_type jade::basic_forced_grouping< TValue >::get_max ( const size_t  i, const size_t  k  ) const

inline

Returns

The maximum value for a specified individual and component.

Parameters

i	The individual index.
k	The component index.

Definition at line 135 of file cpax/jade.forced_grouping.hpp.

        {
            assert(i < _i);
            assert(k < _k);
            return _b[_a[i]].get_value(k + _k);
        }

Here is the caller graph for this function:

get_max() [2/2]

template<typename TValue >

value_type jade::basic_forced_grouping< TValue >::get_max ( const size_t  i, const size_t  k  ) const

inline

Returns

The maximum value for a specified individual and component.

Parameters

i	The individual index.
k	The component index.

Definition at line 135 of file qpas/jade.forced_grouping.hpp.

        {
            assert(i < _i);
            assert(k < _k);
            return _b[_a[i]].get_value(k + _k);
        }

get_min() [1/2]

template<typename TValue >

value_type jade::basic_forced_grouping< TValue >::get_min ( const size_t  i, const size_t  k  ) const

inline

Returns

The minimim value for a specified individual and component.

Parameters

i	The individual index.
k	The component index.

Definition at line 148 of file cpax/jade.forced_grouping.hpp.

        {
            assert(i < _i);
            assert(k < _k);
            return _b[_a[i]].get_value(k);
        }

Here is the caller graph for this function:

get_min() [2/2]

template<typename TValue >

value_type jade::basic_forced_grouping< TValue >::get_min ( const size_t  i, const size_t  k  ) const

inline

Returns

The minimim value for a specified individual and component.

Parameters

i	The individual index.
k	The component index.

Definition at line 148 of file qpas/jade.forced_grouping.hpp.

        {
            assert(i < _i);
            assert(k < _k);
            return _b[_a[i]].get_value(k);
        }

randomize_q() [1/2]

template<typename TValue >

matrix_type jade::basic_forced_grouping< TValue >::randomize_q ( randomizer_type &  rnd ) const

inline

Returns

A new Q matrix from random values.

Parameters

rnd	The randomizer.

Definition at line 161 of file cpax/jade.forced_grouping.hpp.

        {
            static const auto epsilon = value_type(0.000001);
 
            matrix_type q (_i, _k);
 
            for (size_t k = 0; k < _k; k++)
                for (size_t i = 0; i < _i; i++)
                    q(i, k) = _lerp(get_min(i, k), get_max(i, k), q(i, k));
 
            typedef std::uniform_int_distribution<size_t>  k_dist_type;
            typedef std::uniform_real_distribution<value_type> q_dist_type;
 
            k_dist_type k_dist (0, _k - 1);
 
            auto & engine = rnd.get_engine();
 
            for (size_t i = 0; i < _i; i++)
            {
                for (;;)
                {
                    const auto row_sum = q.get_row_sum(i);
                    if (std::fabs(value_type(1) - row_sum) < epsilon)
                        break;
 
                    const auto k = k_dist(engine);
                    const auto q_ik = q(i, k);
 
                    if (row_sum > value_type(1))
                    {
                        const auto min_ik   = get_min(i, k);
                        const auto distance = row_sum - value_type(1);
                        const auto boundary = std::max(min_ik, q_ik - distance);
 
                        q_dist_type q_dist (boundary, q_ik);
                        q(i, k) = q_dist(engine);
                    }
                    else
                    {
                        const auto max_ik   = get_max(i, k);
                        const auto distance = value_type(1) - row_sum;
                        const auto boundary = std::min(q_ik + distance, max_ik);
 
                        q_dist_type q_dist (q_ik, boundary);
                        q(i, k) = q_dist(engine);
                    }
                }
            }
 
            return q;
        }

Here is the call graph for this function:

randomize_q() [2/2]

template<typename TValue >

matrix_type jade::basic_forced_grouping< TValue >::randomize_q ( randomizer_type &  rnd ) const

inline

Returns

A new Q matrix from random values.

Parameters

rnd	The randomizer.

Definition at line 161 of file qpas/jade.forced_grouping.hpp.

        {
            static const auto epsilon = value_type(0.000001);
 
            matrix_type q (_i, _k);
 
            for (size_t k = 0; k < _k; k++)
                for (size_t i = 0; i < _i; i++)
                    q(i, k) = _lerp(get_min(i, k), get_max(i, k), q(i, k));
 
            typedef std::uniform_int_distribution<size_t>  k_dist_type;
            typedef std::uniform_real_distribution<value_type> q_dist_type;
 
            k_dist_type k_dist (0, _k - 1);
 
            auto & engine = rnd.get_engine();
 
            for (size_t i = 0; i < _i; i++)
            {
                for (;;)
                {
                    const auto row_sum = q.get_row_sum(i);
                    if (std::fabs(value_type(1) - row_sum) < epsilon)
                        break;
 
                    const auto k = k_dist(engine);
                    const auto q_ik = q(i, k);
 
                    if (row_sum > value_type(1))
                    {
                        const auto min_ik   = get_min(i, k);
                        const auto distance = row_sum - value_type(1);
                        const auto boundary = std::max(min_ik, q_ik - distance);
 
                        q_dist_type q_dist (boundary, q_ik);
                        q(i, k) = q_dist(engine);
                    }
                    else
                    {
                        const auto max_ik   = get_max(i, k);
                        const auto distance = value_type(1) - row_sum;
                        const auto boundary = std::min(q_ik + distance, max_ik);
 
                        q_dist_type q_dist (q_ik, boundary);
                        q(i, k) = q_dist(engine);
                    }
                }
            }
 
            return q;
        }

Here is the call graph for this function:

validate_q() [1/2]

template<typename TValue >

bool jade::basic_forced_grouping< TValue >::validate_q ( const matrix_type &  q ) const

inline

Validates the Q matrix and throws an exception if validation fails.

Returns

True.

Parameters

q	The Q matrix.

Definition at line 219 of file cpax/jade.forced_grouping.hpp.

        {
            if (_k != q.get_width())
                throw error()
                    << "inconsistent number of components specified in "
                    << "forced-grouping file (" << _k << ") and "
                    << q.get_size_str() << " Q matrix";
 
            if (_i != q.get_height())
                throw error()
                    << "inconsistent number of individuals specified in "
                    << "forced-grouping file (" << _i << ") and "
                    << q.get_size_str() << " Q matrix";
 
            for (size_t i = 0; i < _i; i++)
            {
                for (size_t k = 0; k < _k; k++)
                {
                    const auto q_ik = q(i, k);
                    const auto min  = get_min(i, k);
                    const auto max  = get_max(i, k);
                    if (q_ik >= min && q_ik <= max)
                        continue;
 
                    throw error()
                        << "inconsistent Q matrix cell [" << i+1 << "," << k+1
                        << "] (" << q_ik << ") is outside the range specified "
                        << "in the forced-grouping file " << min << " to "
                        << max;
                }
            }
 
            return true;
        }

Here is the call graph for this function:

validate_q() [2/2]

template<typename TValue >

bool jade::basic_forced_grouping< TValue >::validate_q ( const matrix_type &  q ) const

inline

Validates the Q matrix and throws an exception if validation fails.

Returns

True.

Parameters

q	The Q matrix.

Definition at line 219 of file qpas/jade.forced_grouping.hpp.

        {
            if (_k != q.get_width())
                throw error()
                    << "inconsistent number of components specified in "
                    << "forced-grouping file (" << _k << ") and "
                    << q.get_size_str() << " Q matrix";
 
            if (_i != q.get_height())
                throw error()
                    << "inconsistent number of individuals specified in "
                    << "forced-grouping file (" << _i << ") and "
                    << q.get_size_str() << " Q matrix";
 
            for (size_t i = 0; i < _i; i++)
            {
                for (size_t k = 0; k < _k; k++)
                {
                    const auto q_ik = q(i, k);
                    const auto min  = get_min(i, k);
                    const auto max  = get_max(i, k);
                    if (q_ik >= min && q_ik <= max)
                        continue;
 
                    throw error()
                        << "inconsistent Q matrix cell [" << i+1 << "," << k+1
                        << "] (" << q_ik << ") is outside the range specified "
                        << "in the forced-grouping file " << min << " to "
                        << max;
                }
            }
 
            return true;
        }

Here is the call graph for this function:

---

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

• cpax/jade.forced_grouping.hpp