• adding twitter_follow rate function
• adding quarter_twitter_follow rate function

• making bins, weights and kmax for each agent type (i.e. at_bins_, at_weights and at_kmaxes)
• initialize the above mentioned member variables in twitter_follow::init_agent_types like twitter_follow::init_bins
• implementing update_at_bins_when_connection_added()
• updating twitter_follow::preferential_agent_follow_model()
• implementing update_at_bins_when_agent_added()
• calling init_bins() in init_follow_models() rather than do_init()
• printing bins in do_print() for preferential_agent follow model

• first slot is update_counters_when_connection_added() which ls bound to connection_added() signal in init_slots()
• second slot is update_bins_when_connection_added() which is bound to connection_added() signal in init_follow_models() for twitter_suggest and twitter follow models
• third slot is update_at_bins_when_connection_added() which is bound to connection_added() signal in init_follow_models() for preferential_agent and twitter follow models

Agent types' add weights and monthly weights must be considered at the same time during random selection.

This is probably because of using cbegin() for selecting from the set. Accessing the buckets first may solve the problem.

• first slot is update_counters_when_agent_added() which ls bound to network::grow() signal in init_slots()
• second slot is update_bins_when_agent_added() which is bound to network::grow() signal in init_follow_models() for twitter_suggest and twitter follow models
• third slot is update_at_bins_when_agent_added() which is bound to network::grow() signal in init_follow_models() for preferential_agent and twitter follow models

VC version works correctly.

• adding std::vector<weight_type> at_add_weight_ to twitter_follow class and initialize it the same way as it was done for twitter_add_agent class
• selecting agent type based on the agent type add weights (i.e. at_add_weight_)
• adding AgentType network::agent_by_type(std::size_t type, T n) const to network class
• if add rate is zero, just try to randomly select from network::agent_by_type(type, n)
• when add rate is not zero, make a vector of adjusted add weights by multiplying follow rate of that agent type for each month (at_monthly_weights_[at][i]) with add weight of the agent type (at_add_weight_[at]) and dividing by sum of monthly follow rates (std::accumulate(at_monthly_weights_))
• using adjusted_add_weights vector to select relevant month by discrete distribution
• use the month for selecting agent ID using at_agent_per_month_[at][month] and uniform distribution

The method currently used for selecting concurrent version is by defining _CONCURRENT. It clutters the code and make it hard to understand. One possible alternative approach is to add _st and _mt suffixes to relevant classes and header files (e.g. engine_st, engine_mt, engine_st.hpp, engine_mt.hpp).

• adding std::array<T, 5> follow_models_count_ as a member to twitter_follow
• initializing follow_models_count_ in init_follow_models() to zero
• increment relevant element on invocation of each model
• report values in twitter_follow::dump()

• in twitter_follow::init_bins(), if max is greater than max_agent + 1, set it to max_agent + 1
• in twitter_follow::init_agent_types(), if max is greater than max_agent + 1, set it to max_agent + 1
• using new method for calculating previous and current bin's index in update_bins_when_connection_added() slot
• using new method for calculating previous and current bin's index in update_at_bins_when_connection_added() slot

twitter_follow::select_follower() must be changed to use the exact hashkat algorithm, considering agent types and their probabilities.

Instead of using bins_, a new one must be built on the fly.

• adding std::vector<std::size_t> at_follows_count_ as a member to twitter_follow
• initializing at_follows_count_ in init_agent_types() to zero
• increment relevant element in do do_action
• report values in twitter_follow::dump()

Agent stereotypes are intended to represent different kinds of network participants. For a network like Twitter, example agent stereotypes include 'Standard User', 'Celebrity', etc. Issue #9 requires this feature.

After new bug fixes for event rate this one was introduced.

std::vector<std::pair<ValueType, std::unordered_set>> bins_;

must be changed to:

std::vectorstd::unordered_set> bins_;
std::vector weights_;

• making two slots for action::finished() signal: increase_time() and increase_time_randomly()
• based on the analysis.use_random_time_increment config item, bind action::finished() to either increase_time() or increase_time_randomly() in engine constructor
• remove random_time_increment_ member variable
• doing the same for multi-threaded version

• changing -o option to output-folder rather than output-file with 'output' as default value
• placing out.dat inside output-folder
• adding void dump(const std::string& folder) const member method to network, simulation, engine and action_base classes
• adding virtual void do_dump(const std::string& folder) const = 0 to action_base class
• overriding do_dump() in all action classes
• calling network and engine's dump() in simulation::dump()
• calling dump() for all actions in engine::dump()
• saving network.dat file in network::dump()
• saving main_stats.dat in network::dump() and relevant action classes checking for output.main_statistics flag in config
• saving Categories_Distro.dat in twitter_follow::dump() checking for output.categories_distro flag in config
• saving dd_by_follow_model.dat in twitter_follow::dump() checking for output.degree_distribution_by_follow_model flag in config
• saving AT_info.dat for each agent type in twitter_follow::dump() checking for output.agent_stats flag in config
• implement twitter_follow::save_degree_distributions() which saves X_degree_distribution_monthY.dat files
• saving X_degree_distribution_monthY.dat files for each month in twitter_follow::dump() by calling twitter_follow::save_degree_distributions() checking for output.degree_distributions flag in config
• pushing back months to twitter_follow::at_agent_per_month_ in twitter_follow::do_action() rather than twitter_follow::init_agent_types()
• saving X_degree_distribution_monthY.dat files if we crossed a month in twitter_follow::do_action() by calling twitter_follow::save_degree_distributions() checking for output.degree_distributions flag in config
• saving network.gexf in network_st::dump() checking for output.visualize flag in config
• saving network.graphml in network_st::dump() checking for output.visualize flag in config
• finding a way to pass output folder name for the previous item
• removing reverse vector ordering for reading agent type configuration file in order to have consistent output for labels in graphs

• using option like --random-seed|-r for program_option.
• printing the used seed like the original hashkat (i.e. "Starting simulation with seed '%d'.\n")

• twitter_follow_st
• twitter_follow_mt

In order to implement #6, there should be a way for actions to know the time of the simulation.

TRNG (http://numbercrunch.de/trng) is suited for shared memory as well as for distributed memory computers and may be used in any parallel programming environment, e.g. Message Passing Standard, OpenMP or CUDA. All generators, that are implemented by TRNG, have been subjected to thorough statistical tests in sequential and parallel setups.

• adding std::vector<TimeType> agent_creation_time_ to twitter_follow class
• initializing agent_creation_time_ in `twitter_follow::do_init()
• pushing back current time to agent_creation_time_ for each invocation of twitter_follow::agent_added(T idx, W at)
• adding referral_rate_function
• changing twitter_follow::twitter_suggest_follow_model(T)

This is required for efficient implementation of #15 and #33.

Comparing event_rate being less than std::numeric_limits<double>::epsilon() is a better way for doing that.

• adding network_st::make_cdf() function
• adding network_st::write_cdf() static function
• adding network_st::read_cdf() static function
• adding bool network_st::ks_test(cdf1, cdf2, alpha = 0.05) function
• write a patch for original hashkat to do write_cdf()

• checking for analysis.use_barabasi config item in twitter_follow::init_follow_models() and binding barabasi_follow_model member function to follow_models_[1] if true
• implementing barabasi_follow_model() function
• saving analysis.barabasi_connections to barabasi_connections_ member variable in twitter_follow::init_follow_models()
• implementing twitter_follow::barabasi_follow_when_agent_added() to follow that many times when a new agent is added
• using analysis.use_barabasi config in twitter_follow::init_follow_models() to bind twitter_follow::barabasi_follow_when_agent_added() member function as a slot for 'network::agent_added()' signal
• adding update_barabasi_bins_when_connection_added() slot and connect it to the signal
• use the barabasi_exponent for bins
• calling handle_follow() function in the slot

• add std::vector<weight_type> at_followback_weight_ member variable to twitter_follow class
• initializing at_followback_weight_ for each agent type by reading agents.followback_probability from config in twitter_follow::init_agent_types
• making an empty followback_when_connection_added() slot
• binding followback_when_connection_added() slot to connection_added() signal in init_slots() if analysis.use_followback is true in config
• implement followback_when_connection_added() slot

This in yaml:

add: {function: constant, value: 1.0}

must be changed to this in xml:

    <rates>
        <add_function>constant</add_function>
        <add_rate>1.0</add_rate>
    </rates>

also this in yaml:

add: {function: linear, y_intercept: 0.0, slope: 0.5 }

to

    <rates>
        <add_function>linear</add_function>
        <add_y_intercept>0.0</add_y_intercept>
        <add_slope>0.5</add_slope>
    </rates>

Using C++11 atomic operations specially for increasing/decreasing can boost concurrency performance.

Using an online utility like http://codebeautify.org/yaml-to-json-xml-csv# the latest default original hashkat configuration file can be converted from yaml to xml. The resulting file can be used as a default configuration for hashkat-lib.

• std::uint16_t will be the last template argument (W)
• it must be a vector of std::uint16_t types
• VauleType will be renamed to V
• agent type names will be stored as std::vector<std::string> at_name_
• agent type name can be found using std::string type_name(std::size_t type_idx) const
• agent type can be found using W agent_type(T n) const
• initialization of agent types from config can happen in constructors
• agent types add weights are stored in std::vector<V> at_add_weight_
• changing bool network::grow() to bool network::grow(W at)
• changing signal<void(T)> grown_signal_type to signal<void(T,W)> grown_signal_type
• during grow, type of the agent will be decided using the algorithm in original hashkat
• adding std::vector<std::vector<T>> at_agent_ids to network class to hold agent_list for each agent type
• adding std::vector<std::vector<T>> at_agent_per_month to twitter_follow class to hold agent_cap for each agent type
• calculation of follow action weight must be based on the agent type monthly follow weights in twitter_follow::do_update_weight(const TimeType&) (requires #14)
• creation of follow ranks (bins) for each agent type
• updating follow ranks (bins) for each agent type in twitter_follow::agent_added(T,W) and twitter_follow::update_ranks(T,T) member functions

• using at_af_weight_ for selecting agent type
• checking for the agent language

• adding time as the last parameter of action::do_init(net, cnt, cnf, rng)
• removing time parameter of do_update_weight(const TimeType& time)
• adding std::size_t month() const member function to action classes which returns current month
• increasing at_agent_per_month_[type][month] in twitter_follow::agent_added(T idx, W at)

• updating hashkat_mt.cpp based on hashkat.cpp
• updating network_mt.hpp based on network_st.hpp
• updating simulation_mt.hpp based on simulation_st.hpp
• updating engine_mt.hpp based on engine_st.hpp
• updating action_mt.hpp based on action_st.hpp
• updating twitter_add_agent_mt.hpp based on twitter_add_agent_st.hpp
• updating twitter_follow_mt.hpp based on twitter_follow_st.hpp

Using Boost.Filesystem, if the output folder doesn't exit, it must be created

The follow rate was made to be proportional to add rate in 196a0ca commit for parallel benchmarks. It must be reverted to normal.

• adding support for version extraction
• add CMakeLists.txt to include folder for headers installation
• adding CTest
• adding INSTALL_TESTS option
• adding support for CPack driven installer package
• update `install.txt' file
• make a tagged version for the latest release