Utopia::Models::Opinionet::Utils Namespace Reference

Classes
struct	Infrastructure
struct	TestNetworkD
struct	TestNetworkD_small
struct	TestNetworkU

Functions
	BOOST_FIXTURE_TEST_CASE (test_get_rand, Infrastructure)
	BOOST_AUTO_TEST_CASE (test_is_directed)
	BOOST_FIXTURE_TEST_CASE (test_get_rand_neighbor, TestNetworkU)
	BOOST_FIXTURE_TEST_CASE (test_set_and_normalize_weights, TestNetworkD, *boost::unit_test::tolerance(1e-12))
	BOOST_FIXTURE_TEST_CASE (test_select_neighbour, TestNetworkD_small, *boost::unit_test::tolerance(1.0))
template<typename RT , typename T , typename RNGType >
RT	get_rand (std::pair< T, T > range, RNGType &rng)
	Generate a random number within the given range.
template<typename NWType >
constexpr bool	is_directed ()
	Check whether the network type allows for directed edges.
template<typename NWType , typename VertexDescType , typename RNGType >
auto	get_rand_neighbor (const VertexDescType v, NWType &nw, RNGType &rng)
template<typename NWType , typename RNGType , typename VertexDescType >
VertexDescType	select_neighbor (const VertexDescType v, NWType &nw, std::uniform_real_distribution< double > &prob_distr, RNGType &rng)
template<typename NWType , typename VertexDescType >
double	opinion_difference (VertexDescType v, VertexDescType w, NWType &nw)
	Calculate the absolute opinion difference of two vertices.
template<typename NWType , typename VertexDescType >
void	set_and_normalize_weights (const VertexDescType v, NWType &nw, const double weighting)
	Set and normalize weights according to opinion difference.

Variables
std::uniform_real_distribution< double >	uniform_prob_distr

Function Documentation

BOOST_AUTO_TEST_CASE()

Utopia::Models::Opinionet::Utils::BOOST_AUTO_TEST_CASE

(

test_is_directed

)

{
    BOOST_TEST(is_directed<NetworkDirected>());
    BOOST_TEST(!is_directed<NetworkUndirected>());
}

BOOST_FIXTURE_TEST_CASE() [1/4]

Utopia::Models::Opinionet::Utils::BOOST_FIXTURE_TEST_CASE	(	test_get_rand	,
		Infrastructure
	)

{
    const auto test_cfg = cfg["test_funcs"]["test_get_rand"];
 
    const std::vector<std::pair<int, int>> to_assert_int
            = get_as<std::vector<std::pair<int, int>>>("vals_int", test_cfg);
    for(const auto& val: to_assert_int) {
        const int rand = get_rand<int>(val, *rng);
        BOOST_TEST(rand >= val.first);
        BOOST_TEST(rand <= val.second);
    }
 
    const std::vector<std::pair<double, double>> to_assert_double
            = get_as<std::vector<std::pair<double, double>>>("vals_double",
                                                                test_cfg);
    for(const auto& val: to_assert_int) {
        const double rand = get_rand<double>(val, *rng);
        BOOST_TEST(rand >= val.first);
        BOOST_TEST(rand <= val.second);
    }
 
    const std::vector<std::pair<double, double>> to_assert_fail
            = get_as<std::vector<std::pair<double, double>>>("assert_fail",
                                                                test_cfg);
    for(const auto& val: to_assert_fail) {
        TestTools::check_exception<std::invalid_argument>(
            [&](){
            get_rand<double>(val, *rng);
            },
            "Error, invalid parameter range! Upper limit has to be "
            "higher than the lower limit."  // expected error message
        );
    }
}

BOOST_FIXTURE_TEST_CASE() [2/4]

Utopia::Models::Opinionet::Utils::BOOST_FIXTURE_TEST_CASE	(	test_get_rand_neighbor	,
		TestNetworkU
	)

{
    for (const auto v : range<IterateOver::vertices>(nw)) {
        if (boost::out_degree(v, nw) != 0) {
            vertex w = get_rand_neighbor(v, nw, *rng);
            // Test edge exists
            BOOST_TEST(edge(v, w, nw).second);
 
            // Test edge selection by probability works on undirected networks
            vertex x = select_neighbor(v, nw, uniform_prob_distr, *rng);
            BOOST_TEST(edge(v, x, nw).second);
        }
    }
}

BOOST_FIXTURE_TEST_CASE() [3/4]

Utopia::Models::Opinionet::Utils::BOOST_FIXTURE_TEST_CASE	(	test_select_neighbour	,
		TestNetworkD_small	,
		*	boost::unit_test::tolerance1.0
	)

{
    const std::vector<double> init_opinions =
        get_as<std::vector<double>>(
            "init_opinions",
            cfg["test_funcs"]["test_select_neighbour"]
        );
 
    const std::vector<double> weighting =
        get_as<std::vector<double>>("weighting",
            cfg["test_funcs"]["test_select_neighbour"]);
 
    for(const auto& w: weighting) {
 
        for (size_t i = 0; i<boost::num_vertices(nw); ++i) {
            nw[i].opinion = init_opinions.at(i);
        }
 
        for (const auto v : range<IterateOver::vertices>(nw)) {
            set_and_normalize_weights(v, nw, w);
        }
 
        const int num_steps = 100000;
 
        // Check interaction partner selection probability is same as ratio of
        // opinions
        int v2_selected = 0;
        int v3_selected = 0;
        for (int i=0; i<num_steps; ++i) {
            vertex w = select_neighbor(v1, nw, uniform_prob_distr, *rng);
            if (w == v2) { ++v2_selected; }
            else if (w == v3) { ++v3_selected; }
        }
 
        BOOST_TEST((static_cast<double>(v2_selected))/v3_selected
                 == exp(-w*(fabs(nw[v2].opinion-nw[v1].opinion)
                         -fabs(nw[v3].opinion-nw[v1].opinion)))
        );
 
        // Repeat for vertex 4
        int v1_selected = 0;
        v2_selected = 0;
        for (int i=0; i<num_steps; ++i) {
            vertex w = select_neighbor(v4, nw, uniform_prob_distr, *rng);
            if (w == v1) { ++v1_selected; }
            else if (w == v2) { ++v2_selected; }
        }
 
        BOOST_TEST((static_cast<double>(v1_selected))/v2_selected
                 == exp(-w*(fabs(nw[v1].opinion-nw[v4].opinion)
                         -fabs(nw[v2].opinion-nw[v4].opinion)))
        );
    }
}

BOOST_FIXTURE_TEST_CASE() [4/4]

Utopia::Models::Opinionet::Utils::BOOST_FIXTURE_TEST_CASE	(	test_set_and_normalize_weights	,
		TestNetworkD	,
		*	boost::unit_test::tolerance1e-12
	)

{
    const std::vector<double> weighting =
        get_as<std::vector<double>>("weighting",
            cfg["test_funcs"]["test_set_and_normalize_weights"]);
 
    std::pair<double, double> opinion_range = {-5., 5.};
    for(const auto& w: weighting) {
        for (const auto v : range<IterateOver::vertices>(nw)) {
            nw[v].opinion = get_rand<double>(opinion_range, *rng);
            set_and_normalize_weights(v, nw, w);
        }
        for (const auto v : range<IterateOver::vertices>(nw)) {
            double sum_of_weights = 0;
            for (const auto e : range<IterateOver::out_edges>(v, nw)) {
                BOOST_TEST(nw[e].weight >= 0);
                sum_of_weights += nw[e].weight;
            }
            if (boost::out_degree(v, nw) != 0) {
                BOOST_TEST(sum_of_weights == 1.);
            }
        }
    }
}

get_rand()

template<typename RT , typename T , typename RNGType >

RT Utopia::Models::Opinionet::Utils::get_rand	(	std::pair< T, T >	range,
		RNGType &	rng
	)

Generate a random number within the given range.

                                               {
    if (range.first > range.second) {
        throw std::invalid_argument(
            "Error, invalid parameter range! Upper limit has to be higher "
            "than the lower limit."
        );
    }
    if constexpr (std::is_floating_point<RT>()) {
        return
            std::uniform_real_distribution<RT>(range.first, range.second)(rng);
    }
    else {
        return
            std::uniform_int_distribution<RT>(range.first, range.second)(rng);
    }
}

get_rand_neighbor()

template<typename NWType , typename VertexDescType , typename RNGType >

auto Utopia::Models::Opinionet::Utils::get_rand_neighbor	(	const VertexDescType	v,
		NWType &	nw,
		RNGType &	rng
	)

Get random neighbour of vertex v (for directed and undirected graphs). Only appliable to vertices with degree > 0

                                                                         {
 
    const int nb_shift = get_rand<int>(
            std::make_pair<int, int>(0, boost::out_degree(v, nw)-1), rng
    );
    auto nb = boost::adjacent_vertices(v, nw).first;
    nb += nb_shift;
    return *nb;
}

is_directed()

template<typename NWType >

constexpr bool Utopia::Models::Opinionet::Utils::is_directed ( )

constexpr

Check whether the network type allows for directed edges.

                             {
    return std::is_convertible<
        typename boost::graph_traits<NWType>::directed_category,
        boost::directed_tag>::value;
}

opinion_difference()

template<typename NWType , typename VertexDescType >

double Utopia::Models::Opinionet::Utils::opinion_difference	(	VertexDescType	v,
		VertexDescType	w,
		NWType &	nw
	)

Calculate the absolute opinion difference of two vertices.

                                                                          {
    return fabs(nw[v].opinion - nw[w].opinion);
}

select_neighbor()

template<typename NWType , typename RNGType , typename VertexDescType >

VertexDescType Utopia::Models::Opinionet::Utils::select_neighbor	(	const VertexDescType	v,
		NWType &	nw,
		std::uniform_real_distribution< double > &	prob_distr,
		RNGType &	rng
	)

Select random neighbor with probability proportional to edge weight. Only applicable to vertices with degree > 0

{
    auto nb = v;
 
    if constexpr (Utils::is_directed<NWType>()) {
        // The probability for choosing neighbor w is given by the weight on
        // the edge (v, w).
        const double nb_prob_frac = prob_distr(rng);
        double cumulative_weights = 0.;
        for (const auto w : range<IterateOver::neighbors>(v, nw)) {
            cumulative_weights += nw[boost::edge(v, w, nw).first].weight;
            if (cumulative_weights >= nb_prob_frac) {
                nb = w;
                break;
            }
        }
    }
    else {
        nb = Utils::get_rand_neighbor(v, nw, rng);
    }
 
    return nb;
}

set_and_normalize_weights()

template<typename NWType , typename VertexDescType >

void Utopia::Models::Opinionet::Utils::set_and_normalize_weights	(	const VertexDescType	v,
		NWType &	nw,
		const double	weighting
	)

Set and normalize weights according to opinion difference.

Iterates over a vertex' out-edges and sets the weights to exp(- weighting * abs(opinion difference)), then normalizes them (softmax).

Warning

This assumes that the vertex has at least one out-edge. Make sure to check this in the calling scope, otherwise this will lead to a zero division error during normalisation.

{
    double weight_norm = 0.;
    for (const auto e : range<IterateOver::out_edges>(v, nw)) {
        double op_diff = opinion_difference(boost::target(e, nw), v, nw);
        nw[e].weight = exp(-(weighting*op_diff));
        weight_norm += nw[e].weight;
    }
    for (const auto e : range<IterateOver::out_edges>(v, nw)) {
        nw[e].weight /= weight_norm;
    }
}

Variable Documentation

uniform_prob_distr

std::uniform_real_distribution<double> Utopia::Models::Opinionet::Utils::uniform_prob_distr