Beispiel #1
0
    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"));
    }
Beispiel #2
0
    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"));
    }
Beispiel #3
0
    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"));
    }
Beispiel #4
0
 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"));
 }
Beispiel #5
0
    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;
    }
Beispiel #7
0
    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());
    }
Beispiel #8
0
    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"));
    }
Beispiel #9
0
 ConstantGenerator(const vle::devs::DynamicsInit &init,
                   const vle::devs::InitEventList &events)
     : vle::devs::Dynamics(init, events)
 {
     m_neighborhood = events.getInt("neighborhood");
 }