void use_1d_regular_graph_generator(const vle::devs::InitEventList& events)
{
vle::translator::regular_graph_generator::parameter param{
std::bind(&Builder::regular_graph_generator_make_model,
this,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3),
regular_graph_generator_connectivity()
};
vle::translator::regular_graph_generator rgg(param);
const auto& v = events.getSet("mask").value();
std::vector<std::string> mask;
std::transform(v.begin(),
v.end(),
std::back_inserter(mask),
[](const auto& v) { return v->toString().value(); });
rgg.make_1d(*this,
events.getInt("lenght"),
events.getBoolean("graph-wrap"),
mask,
events.getInt("x-mask"));
}
void use_erdosrenyi_graph_generator(const vle::devs::InitEventList& events)
{
vle::translator::graph_generator::parameter param{
std::bind(&Builder::graph_generator_make_model,
this,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3),
graph_generator_connectivity(),
directed
};
vle::translator::graph_generator gg(param);
if (events.exist("fraction"))
gg.make_erdos_renyi(*this,
generator,
model_number,
events.getDouble("fraction"),
events.getBoolean("allow-self-loops"));
else
gg.make_erdos_renyi(*this,
generator,
model_number,
events.getInt("edges_number"),
events.getBoolean("allow-self-loops"));
}
void use_2d_regular_graph_generator(const vle::devs::InitEventList& events)
{
vle::translator::regular_graph_generator::parameter param{
std::bind(&Builder::regular_graph_generator_make_model,
this,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3),
regular_graph_generator_connectivity()
};
vle::translator::regular_graph_generator rgg(param);
int width_mask = events.getInt("mask-width");
int height_mask = events.getInt("mask-height");
vle::utils::Array<std::string> mask(width_mask, height_mask);
const auto& v = events.getSet("mask").value();
{
if (vle::utils::numeric_cast<int>(mask.size()) !=
width_mask * height_mask)
throw vle::utils::ModellingError("mask definition error");
int i = 0, j = 0;
for (const auto& str : v) {
mask(i, j) = str->toString().value();
++j;
if (j >= height_mask) {
i++;
j = 0;
}
}
}
rgg.make_2d(*this,
{ { events.getInt("width"), events.getInt("height") } },
{ { events.getBoolean("wrap-width"),
events.getBoolean("wrap-height") } },
mask,
events.getInt("x-mask"),
events.getInt("y-mask"));
}
LogEx(const vle::devs::DynamicsInit& init, const vle::devs::InitEventList& events)
: DiscreteTimeDyn(init, events)
{
x.init(this, "x",events);
y.init(this, "y",events);
y_noise.init(this, "y_noise",events);
y.init_value(x());
y_noise.init_value(x());
mrand.seed(events.getInt("seed"));
}
void use_regular_graph_generator(const vle::devs::InitEventList& events)
{
int dimension = events.getInt("graph-dimension");
if (dimension == 1)
use_1d_regular_graph_generator(events);
else if (dimension == 2)
use_2d_regular_graph_generator(events);
else
throw vle::utils::ModellingError(
"Undefined regular graph with %d dimension", dimension);
}
ExBohachevsky(const vd::DynamicsInit& init, const vd::InitEventList& events) :
vd::Dynamics(init,events)
{
x1 = events.getDouble("x1");
x2 = events.getDouble("x2");
my = pow(x1,2) + 2 * pow(x2,2) - 0.3 * cos(3 * M_PI * x1)
- 0.4 * cos(4 * M_PI * x2) + 0.7;
mrand.seed(events.getInt("seed"));
double noise = mrand.normal(0,0.1);
my_noise = my + noise;
}
void use_graph_generator(const vle::devs::InitEventList& events)
{
model_number = events.getInt("model-number");
std::string generator_name = events.getString("graph-generator");
if (events.exist("graph-seed"))
generator.seed(events.getInt("graph-seed"));
if (generator_name == "defined")
use_defined_graph_generator(events);
else if (generator_name == "small-world")
use_smallworld_graph_generator(events);
else if (generator_name == "scale-free")
use_scalefree_graph_generator(events);
else if (generator_name == "sorted-erdos-renyi")
use_sortederdesrenyi_graph_generator(events);
else if (generator_name == "erdos_renyi")
use_erdosrenyi_graph_generator(events);
else
throw vle::utils::ModellingError("Unknown graph gererator: %s",
generator_name.c_str());
}
void use_smallworld_graph_generator(const vle::devs::InitEventList& events)
{
vle::translator::graph_generator::parameter param{
std::bind(&Builder::graph_generator_make_model,
this,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3),
graph_generator_connectivity(),
directed
};
vle::translator::graph_generator gg(param);
gg.make_smallworld(*this,
generator,
model_number,
events.getInt("k"),
events.getDouble("probability"),
events.getBoolean("allow-self-loops"));
}
ConstantGenerator(const vle::devs::DynamicsInit &init,
const vle::devs::InitEventList &events)
: vle::devs::Dynamics(init, events)
{
m_neighborhood = events.getInt("neighborhood");
}
