dena.h

/*
    Copyright (C) 2022 Amirabbas Asadi , All Rights Reserved
    distributed under Apache-2.0 license
*/
#ifndef ROCKY_ZAGROS_DENA_GUARD
#define ROCKY_ZAGROS_DENA_GUARD
 
#include<vector>
#include<deque>
#include<map>
#include<stack>
#include<type_traits>
#include<variant>
 
#include<rocky/zagros/strategies/log.h>
 
 
namespace rocky{
namespace zagros{
 
namespace dena{
 
 
struct flow_node{
    // a unique identifier
    int tag;
};
 
struct null_node: public flow_node{};
 
struct container_node: public flow_node{};
struct container_create_node: public container_node{
    std::string id;
    int n_particles;
    int group_size;
};
struct container_select_from_node: public container_node{
    std::string des;
    std::string src;
};
struct container_eval_node: public container_node{
    std::string id;
};
 
struct init_node: public flow_node{};
struct init_uniform_node: public init_node{
    std::string id;
};
struct init_normal_node: public init_node{};
 
struct log_node: public flow_node{};
struct log_local_best_node: public log_node{
    std::string id;
    local_log_handler* handler;
};
struct log_comet_best_node: public log_node{
    std::string id;
    comet_log_handler* handler;
};
 
struct comm_node: public flow_node{};
struct comm_cluster_prop_best_node: public comm_node{
    std::string id;
};
 
struct pso_node: public flow_node{};
struct pso_memory_create_node: public pso_node{
    std::string memory_id;
    std::string main_cnt_id;
};
struct pso_step_node: public pso_node{
    std::string memory_id;
    std::string main_cnt_id;
};
struct pso_group_level_step_node: public pso_step_node{};
struct pso_cluster_level_step_node: public pso_step_node{};
 
struct mutate_node: public flow_node{};
struct mutate_gaussian_node: public mutate_node{
    std::string id;
    int dims;
    float mu;
    float sigma;
};
 
struct crossover_node: public flow_node{};
struct crossover_multipoint_node: public crossover_node{
    std::string id;
    int dims;
};
struct crossover_differential_evolution_node: public crossover_node{
    std::string id;
    float crossover_prob;
    float differential_weight;
};
struct crossover_segment_node: public crossover_node{
    std::string id;
    int segment_length;
};
 
struct eda_node: public flow_node{};
struct eda_mvn_node: public eda_node{};
struct eda_mvn_fullcov_node: public eda_mvn_node{
    std::string id;
};
 
struct analysis_node: public flow_node{};
struct plot_node: public analysis_node{};
struct plot_heatmap_node: public plot_node{
    int width;
    int height;
    std::string label;
};
struct container_recorder_node: public analysis_node{
    std::string id;
    container_analysis_handler* handler;
};
 
struct bcd_node: public flow_node{};
enum bcd_mask_generator { uniform };
struct bcd_mask_node: public bcd_node{
    bcd_mask_generator generator;
};
 
struct run_node: public flow_node{
    std::vector<int> sub_procedure;
};
struct run_until_no_improve_node: public run_node{
    std::string id;
    int max_check;
};
struct run_with_probability_node: public run_node{
    float prob;
};
struct run_n_times_node: public run_node{
    int n_iters;
};
struct run_every_n_steps_node: public run_node{
    int period;
};
 
 
// a variant containing all nodes
typedef std::variant<log_local_best_node,
                    log_comet_best_node,
                    bcd_mask_node,
                    comm_cluster_prop_best_node,
                    init_uniform_node,
                    init_normal_node,
                    container_create_node,
                    container_select_from_node,
                    container_eval_node,
                    pso_memory_create_node,
                    pso_group_level_step_node,
                    pso_cluster_level_step_node,
                    mutate_gaussian_node,
                    crossover_multipoint_node,
                    crossover_differential_evolution_node,
                    crossover_segment_node,
                    eda_mvn_fullcov_node,
                    plot_heatmap_node,
                    container_recorder_node,
                    run_with_probability_node,
                    run_n_times_node,
                    run_every_n_steps_node,
                    run_until_no_improve_node> flow_node_variant;
 
class node{
public:
    static std::vector<flow_node_variant>& nodes(){
        static std::vector<flow_node_variant> nodes_;
        return nodes_;
    }
    static std::map<int, int>& next_node(){
        static std::map<int, int> next_node_;
        return next_node_;
    }
    template<typename T_n>
    static int register_node(T_n flow_node){ 
        flow_node.tag = node::nodes().size();
        node::nodes().push_back(flow_node);
        next_node()[flow_node.tag] = -1;
        return flow_node.tag;
    }
    static void register_link(int s, int e){
        node::next_node()[s] = e;
    }
    static int next(int tag){
        return node::next_node()[tag];
    }
};
 
class flow{
public:
    std::vector<int> procedure;
    size_t total_memory;
 
    flow& operator >>(const flow& f){
        // concat the two procedures
        auto last_node = procedure.back();
        auto first_node = f.procedure.front();
        node::register_link(last_node, first_node);
        this->procedure.insert(this->procedure.end(), f.procedure.begin(), f.procedure.end());
        return *this;
    }
};
 
class container{
public:
    static flow create(std::string id, int n_particles, int group_size){
        flow f;
        container_create_node node;
        node.id = id;
        node.n_particles = n_particles;
        node.group_size = group_size;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow create(std::string id, int n_particles){
        return create(id, n_particles, n_particles);
    }
    static flow create(std::string id){
        return create(id, 1, 1);
    }
    static flow take_best(std::string des, std::string src){
        flow f;
        container_select_from_node node;
        node.des = des;
        node.src = src;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow eval(std::string id){
        flow f;
        container_eval_node node;
        node.id = id;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
};
 
class utils{
public:
    static std::string temp_name(int tag){
        return fmt::format("__temp__T[{}]__", tag);
    }
    static std::string temp_name(int tag, std::string desc){
        return fmt::format("__temp__{}__{}__", tag, desc);
    }
};
 
class init{
public:
    static flow uniform(std::string id){
        flow f;
        init_uniform_node node;
        node.id = id;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
}; // end of init
 
namespace log{
class local{
public:
    static flow best(std::string id, local_log_handler& handler){
        flow f;
        log_local_best_node node;
        node.id = id;
        node.handler = &handler;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    // an overload of the best function which selects the best continer automatically
    static flow best(local_log_handler& handler){
        return best("__best__", handler);
    }
}; // end of local
 
class comet{
public:
    static flow best(std::string id, comet_log_handler& handler){
        flow f;
        log_comet_best_node node;
        node.id = id;
        node.handler = &handler;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    // an overload of the best function which selects the best continer automatically
    static flow best(comet_log_handler& handler){
        return best(std::string("__best__"), handler);
    }
}; // end of comet
 
}; // end of log
 
namespace block{
class uniform{
public:
    static flow select(){
        flow f;
        bcd_mask_node node;
        node.generator = bcd_mask_generator::uniform;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
}; // end of uniform
}; // end of blocked descent
 
 
namespace propagate{
class cluster{
public:
static flow best(std::string id){
    flow f;
    comm_cluster_prop_best_node node;
    node.id = id;
    auto node_tag = node::register_node<>(node);
    f.procedure.push_back(node_tag);
    return f;
}
}; // end of cluster
}; // end of comm
 
class run{
public:
    static flow n_times(int iters, const flow& wrapped_flow){
        flow f;
        run_n_times_node node;
        node.n_iters = iters;
        node.sub_procedure.insert(node.sub_procedure.end(), wrapped_flow.procedure.begin(), wrapped_flow.procedure.end());
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow with_probability(float prob, const flow& wrapped_flow){
        flow f;
        run_with_probability_node node;
        node.prob = prob;
        node.sub_procedure.insert(node.sub_procedure.end(), wrapped_flow.procedure.begin(), wrapped_flow.procedure.end());
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow every_n_steps(int n, const flow& wrapped_flow){
        flow f;
        run_every_n_steps_node node;
        node.period = n;
        node.sub_procedure.insert(node.sub_procedure.end(), wrapped_flow.procedure.begin(), wrapped_flow.procedure.end());
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow while_improve(std::string id, int n, const flow& wrapped_flow){
        flow f;
        run_until_no_improve_node node;
        node.id = id;
        node.max_check = n;
        node.sub_procedure.insert(node.sub_procedure.end(), wrapped_flow.procedure.begin(), wrapped_flow.procedure.end());
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow while_improve(int n, const flow& wrapped_flow){
        return while_improve(std::string("__best__"), n, wrapped_flow);
    }
    static flow while_improve(const flow& wrapped_flow){
        return while_improve(std::string("__best__"), 20, wrapped_flow);
    }
 
}; // end of init
 
 
namespace pso{
class memory{
public:
    static flow create(std::string mem_id, std::string main_id){
        flow f;
        pso_memory_create_node node;
        node.memory_id = mem_id;
        node.main_cnt_id = main_id;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static std::string particles_vel(std::string base){
        return base + std::string("__pvel__");
    }
    static std::string particles_mem(std::string base){
        return base + std::string("__pmem__");
    }
    static std::string groups_mem(std::string base){
        return base + std::string("__gmem__");
    }
    static std::string node_mem(std::string base){
        return base + std::string("__nmem__");
    }
    static std::string cluster_mem(std::string base){
        return base + std::string("__cmem__");
    } 
}; // end of memory
 
class local{
public:
    static flow step(std::string mem_id, std::string main_id){
        flow f;
        pso_group_level_step_node node;
        node.memory_id = mem_id;
        node.main_cnt_id = main_id;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
}; // end of group level
 
class global{
public:
    static flow step(std::string mem_id, std::string main_id){
        flow f;
        pso_cluster_level_step_node node;
        node.memory_id = mem_id;
        node.main_cnt_id = main_id;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
}; // end of group level
 
}; // end of pso
 
class mutate{
public:
    static flow gaussian(std::string id, int dims=1, float mu=0.0, float sigma=1.0){
        flow f;
        mutate_gaussian_node node;
        node.id = id;
        node.dims = dims;
        node.mu = mu;
        node.sigma = sigma;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
 
}; // end of mutate
 
class crossover{
public:
    static flow multipoint(std::string id, int dims=1){
        flow f;
        crossover_multipoint_node node;
        node.id = id;
        node.dims = dims;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow differential_evolution(std::string id, float cr=0.9, float dw=0.9){
        flow f;
        crossover_differential_evolution_node node;
        node.id = id;
        node.crossover_prob = cr;
        node.differential_weight = dw;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow segment(std::string id, int segment_length){
        flow f;
        crossover_segment_node node;
        node.id = id;
        node.segment_length = segment_length;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
 
}; // end of mutate
 
namespace eda{
class mvn{
public:
    static flow full_cov(std::string id){
        flow f;
        eda_mvn_fullcov_node node;
        node.id = id;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
}; // end of mvn
}; // end of eda
 
namespace analyze{
 
class plot{
public:
    static flow heatmap(std::string label, int width, int height){
        flow f;
        plot_heatmap_node node;
        node.label = label;
        node.width = width;
        node.height = height;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    }
    static flow heatmap(std::string label, int width){
        return heatmap(label, width, width);
    }
    static flow heatmap(std::string label){
        return heatmap(label, 500);
    }
    static flow heatmap(){
        return heatmap(std::string("heatmap"));
    }
    static flow container(std::string id, container_analysis_handler& handler){
        flow f;
        container_recorder_node node;
        node.id = id;
        node.handler = &handler;
        auto node_tag = node::register_node<>(node);
        f.procedure.push_back(node_tag);
        return f;
    } 
}; // end of plot
 
}; // end of analysis
 
}; // end of dena
}; // end of zagros
}; // end of rocky
#endif