Utopia::Models::Opinionet::Revision Namespace Reference

Classes
struct	TestNetworkD
struct	TestNetworkU

Functions
template<typename NWType , typename VertexDescType >
void	update_opinion_HK (const VertexDescType v, NWType &nw, const double susceptibility, const double tolerance, const Opinion_space_type opinion_space)
	Hegselmann-Krause opinion update function.
template<typename NWType , typename RNGType , typename VertexDescType >
void	update_opinion_Deffuant (const VertexDescType v, NWType &nw, const double susceptibility, const double tolerance, const Opinion_space_type opinion_space, std::uniform_real_distribution< double > &prob_distr, RNGType &rng)
	Deffuant opinion update function.
template<typename NWType , typename RNGType >
void	rewire_random_edge (NWType &nw, const double tolerance, const double weighting, RNGType &rng)
template<typename NWType , typename RNGType >
void	revision (NWType &nw, const double susceptibility, const double tolerance, const double weighting, const Interaction_type interaction, const Opinion_space_type opinion_space, const Rewiring rewire, std::uniform_real_distribution< double > &prob_distr, RNGType &rng)
	Performs an opinion update and edge rewiring (if enabled).
	BOOST_FIXTURE_TEST_CASE (test_opinion_update_HK_u, TestNetworkU)
	BOOST_FIXTURE_TEST_CASE (test_opinion_update_HK_d, TestNetworkD, *boost::unit_test::tolerance(0.0001))
	BOOST_FIXTURE_TEST_CASE (test_rewiring_u, TestNetworkU)
	BOOST_FIXTURE_TEST_CASE (test_rewiring_d, TestNetworkD)
	BOOST_FIXTURE_TEST_CASE (test_opinion_update_D_c, TestNetworkD, *boost::unit_test::tolerance(0.05))
	BOOST_FIXTURE_TEST_CASE (test_opinion_update_D_d, TestNetworkU, *boost::unit_test::tolerance(0.05))

Variables
std::mt19937	rng {}
	– Type definitions ----------------------------------------------------—
std::uniform_real_distribution< double >	prob_distr

Function Documentation

BOOST_FIXTURE_TEST_CASE() [1/6]

Utopia::Models::Opinionet::Revision::BOOST_FIXTURE_TEST_CASE	(	test_opinion_update_D_c	,
		TestNetworkD	,
		*	boost::unit_test::tolerance0.05
	)

{
    using Modes::Opinion_space_type;
 
    TestNetworkD();
    const double tolerance = 2;
    const double susceptibility = 0.5;
    const int num_steps = 10000;
    const double init_opinion = nw[v1].opinion;
 
    //Check interaction probabilities equal to ratio of opinion differences
    int v2_selected = 0;
    int v3_selected = 0;
    const double ratio_of_interactions
        = exp(-weighting*(fabs(nw[v2].opinion-nw[v1].opinion)
                          -fabs(nw[v3].opinion-nw[v1].opinion)));
 
    for (int i = 0; i<num_steps; ++i) {
        update_opinion_Deffuant(
            v1, nw, susceptibility, tolerance, Opinion_space_type::continuous,
            prob_distr, rng
        );
        if (nw[v1].opinion
          == init_opinion+susceptibility*(nw[v2].opinion-init_opinion)
        ) {
                ++v2_selected;
        }
        else if (nw[v1].opinion
               == init_opinion +susceptibility*(nw[v3].opinion-init_opinion)
        ) {
                ++v3_selected;
        }
        nw[v1].opinion = init_opinion;
    }
 
    BOOST_TEST((1. * v2_selected)/v3_selected
            == ratio_of_interactions);
 
}

BOOST_FIXTURE_TEST_CASE() [2/6]

Utopia::Models::Opinionet::Revision::BOOST_FIXTURE_TEST_CASE	(	test_opinion_update_D_d	,
		TestNetworkU	,
		*	boost::unit_test::tolerance0.05
	)

{
    using Modes::Opinion_space_type;
 
    TestNetworkU();
    const double tolerance = 5;
    const double susceptibility = 0.5;
    const int num_steps = 100000;
    const double init_opinion = nw[v1].opinion;
 
    // Check ratio of opinion flips is equal to susceptibility
    // Check ratio of flips to opinion of v2 is proportional to 1/out_degree
    int total_opinion_flips = 0;
    int opinion_flipped_to_v2 = 0;
    for (int i = 0; i<num_steps; ++i) {
        update_opinion_Deffuant(
            v1, nw, susceptibility, tolerance, Opinion_space_type::discrete,
            prob_distr, rng
        );
        if (nw[v1].opinion == nw[v2].opinion) {
            ++opinion_flipped_to_v2;
        }
        if (nw[v1].opinion != init_opinion) {
            ++total_opinion_flips;
        }
        nw[v1].opinion = init_opinion;
    }
 
    BOOST_TEST(1.*total_opinion_flips == num_steps * susceptibility);
    BOOST_TEST(1.*opinion_flipped_to_v2
            == num_steps * susceptibility/boost::degree(v1, nw)
    );
}

BOOST_FIXTURE_TEST_CASE() [3/6]

Utopia::Models::Opinionet::Revision::BOOST_FIXTURE_TEST_CASE	(	test_opinion_update_HK_d	,
		TestNetworkD	,
		*	boost::unit_test::tolerance0.0001
	)

{
    using Modes::Opinion_space_type;
 
    const double tolerance = 4;
    const double susceptibility = 1;
    update_opinion_HK(
        v1, nw, susceptibility, tolerance, Opinion_space_type::continuous
    );
    BOOST_TEST (nw[v1].opinion==4.3296);
}

BOOST_FIXTURE_TEST_CASE() [4/6]

Utopia::Models::Opinionet::Revision::BOOST_FIXTURE_TEST_CASE	(	test_opinion_update_HK_u	,
		TestNetworkU
	)

                                      {
    using Modes::Opinion_space_type;
 
    const double tolerance = 4;
    const double susceptibility = 1;
    update_opinion_HK(
        v1, nw, susceptibility, tolerance, Opinion_space_type::continuous
    );
    BOOST_TEST (nw[v1].opinion==2);
}

BOOST_FIXTURE_TEST_CASE() [5/6]

Utopia::Models::Opinionet::Revision::BOOST_FIXTURE_TEST_CASE	(	test_rewiring_d	,
		TestNetworkD
	)

                                      {
    const double tolerance = 3;
    for (size_t i = 0; i<20; ++i) {
        rewire_random_edge(nw, tolerance, weighting, rng);
    }
 
    // Test rewiring
    BOOST_TEST(edge(v1, v5, nw).second);
    BOOST_TEST(!edge(v1, v6, nw).second);
}

BOOST_FIXTURE_TEST_CASE() [6/6]

Utopia::Models::Opinionet::Revision::BOOST_FIXTURE_TEST_CASE	(	test_rewiring_u	,
		TestNetworkU
	)

                                      {
    const double tolerance = 3;
    const double weighting = 1;
    for (size_t i = 0; i<20; ++i) {
        rewire_random_edge(nw, tolerance, weighting, rng);
    }
 
    BOOST_TEST(edge(v1, v5, nw).second);
    BOOST_TEST(!edge(v1, v6, nw).second);
}

revision()

template<typename NWType , typename RNGType >

void Utopia::Models::Opinionet::Revision::revision	(	NWType &	nw,
		const double	susceptibility,
		const double	tolerance,
		const double	weighting,
		const Interaction_type	interaction,
		const Opinion_space_type	opinion_space,
		const Rewiring	rewire,
		std::uniform_real_distribution< double > &	prob_distr,
		RNGType &	rng
	)

Performs an opinion update and edge rewiring (if enabled).

{
    // Choose random vertex for revision
    const auto v = boost::random_vertex(nw, rng);
 
    if (boost::out_degree(v, nw) != 0) {
 
        if (interaction == Interaction_type::HegselmannKrause) {
            update_opinion_HK(
                v, nw, susceptibility, tolerance, opinion_space
            );
        }
 
        else if (interaction == Interaction_type::Deffuant) {
            update_opinion_Deffuant(
                v, nw, susceptibility, tolerance, opinion_space,
                prob_distr, rng
            );
        }
 
        if constexpr (Utils::is_directed<NWType>()) {
            Utils::set_and_normalize_weights(v, nw, weighting);
        }
    }
 
    if (rewire == Rewiring::RewiringOn) {
        rewire_random_edge(nw, tolerance, weighting, rng);
    }
}

rewire_random_edge()

template<typename NWType , typename RNGType >

void Utopia::Models::Opinionet::Revision::rewire_random_edge	(	NWType &	nw,
		const double	tolerance,
		const double	weighting,
		RNGType &	rng
	)

Selects a random edge. If the opinion distance of the source and target exceeds the tolerance, the edge is rewired to a random target.

{
    using namespace boost;
 
    // Choose random edge for rewiring
    const auto e = random_edge(nw, rng);
    const auto s = source(e, nw);
 
    if (Utils::opinion_difference(s, target(e, nw), nw) > tolerance) {
        const auto new_target = random_vertex(nw, rng);
 
        if (new_target != s and not edge(s, new_target, nw).second)
          {
            remove_edge(e, nw);
            add_edge(s, new_target, nw);
 
            if constexpr (Utils::is_directed<NWType>()) {
                Utils::set_and_normalize_weights(s, nw, weighting);
            }
        }
    }
}

update_opinion_Deffuant()

template<typename NWType , typename RNGType , typename VertexDescType >

void Utopia::Models::Opinionet::Revision::update_opinion_Deffuant	(	const VertexDescType	v,
		NWType &	nw,
		const double	susceptibility,
		const double	tolerance,
		const Opinion_space_type	opinion_space,
		std::uniform_real_distribution< double > &	prob_distr,
		RNGType &	rng
	)

Deffuant opinion update function.

{
    // Get neighbor
    const VertexDescType nb = Utils::select_neighbor(v, nw, prob_distr, rng);
 
    // Discrete case: adopt nb opinion with probability = susceptibility
    if (opinion_space == Opinion_space_type::discrete) {
        if (Utils::opinion_difference(v, nb, nw) <= tolerance) {
            const double interaction_probability = prob_distr(rng);
            if (interaction_probability < susceptibility) {
                nw[v].opinion = nw[nb].opinion;
            }
        }
    }
 
    // Continuous case: move towards nb opinion proportional to susceptibility
    else {
        if (Utils::opinion_difference(v, nb, nw) <= tolerance) {
            nw[v].opinion += susceptibility * (nw[nb].opinion - nw[v].opinion);
        }
    }
}

update_opinion_HK()

template<typename NWType , typename VertexDescType >

void Utopia::Models::Opinionet::Revision::update_opinion_HK	(	const VertexDescType	v,
		NWType &	nw,
		const double	susceptibility,
		const double	tolerance,
		const Opinion_space_type	opinion_space
	)

Hegselmann-Krause opinion update function.

{
    double expectation = 0;
    size_t num_interaction_partners = 0;
 
    // Directed case: Calculate the expectation based on the probability
    // distribution given by the weights.
    if constexpr (Utils::is_directed<NWType>()) {
        VertexDescType nb;
        for (const auto e : range<IterateOver::out_edges>(v, nw)) {
            nb = target(e, nw);
            if (Utils::opinion_difference(v, nb, nw) <= tolerance) {
                expectation += nw[nb].opinion * nw[e].weight;
                ++num_interaction_partners;
            }
        }
 
        // If interaction partners found: normalize weighted opinion average to
        // number of interaction partners participating in interaction.
        if (num_interaction_partners != 0) {
            expectation *= static_cast<double>(boost::out_degree(v, nw)) /
                  num_interaction_partners;
        }
        else {
            expectation = nw[v].opinion;
        }
    }
 
    // Undirected case: Calculate the opinion average
    else {
        for (const auto e : range<IterateOver::out_edges>(v, nw)) {
            auto nb = boost::target(e, nw);
            if (Utils::opinion_difference(v, nb, nw) <= tolerance) {
                expectation += nw[nb].opinion;
                ++num_interaction_partners;
            }
        }
 
        // If interaction partners found: normalize opinion average to
        // number of interaction partners
        if (num_interaction_partners != 0) {
            expectation /= num_interaction_partners;
        }
        else {
            expectation = nw[v].opinion;
        }
    }
 
    // Update opinion
    nw[v].opinion += susceptibility * (expectation - nw[v].opinion);
 
    if (opinion_space == Opinion_space_type::discrete) {
        nw[v].opinion = round(nw[v].opinion);
    }
}

Variable Documentation

prob_distr

std::uniform_real_distribution<double> Utopia::Models::Opinionet::Revision::prob_distr

rng

std::mt19937 Utopia::Models::Opinionet::Revision::rng {}

– Type definitions ----------------------------------------------------—

{};