RNAblueprint.h

Go to the documentation of this file.

 
#ifndef RNADESIGN_H
#define RNADESIGN_H
 
// include header
#include "common.h"
#include "dependency_graph.h"
#include "parsestruct.h"
#include "decompose.h"
 
// boost header
#include <chrono>
#include <boost/graph/bipartite.hpp>
 
 
namespace design {
    void initialize_library(bool debug);
    void initialize_library(bool debug, int construction_timeout);
    std::string structures_to_graphml(std::vector<std::string> structures, std::string constraints, bool decompose, unsigned long seed);
    std::string structures_to_graphml(std::vector<std::string> structures, std::string constraints, bool decompose);
    std::string structures_to_graphml(std::vector<std::string> structures, std::string constraints);
    bool graph_is_bipartite(std::vector<std::string> structures);
    bool sequence_structure_compatible(std::string sequence, std::vector<std::string> structures);
    std::vector<int> incompatible_sequence_positions(std::string sequence, std::string structure);
    template <typename R>
    class DependencyGraph {
    public:
        DependencyGraph(std::vector<std::string> structures, std::string constraints, R rand);
        DependencyGraph(std::vector<std::string> structures, std::string constraints, unsigned long seed);
        DependencyGraph(std::vector<std::string> structures, std::string constraints);
        DependencyGraph(std::vector<std::string> structures, R rand);
        DependencyGraph(std::vector<std::string> structures);
        DependencyGraph(const DependencyGraph& copy);
        ~DependencyGraph();
        void set_history_size(unsigned int size);
        std::string get_graphml();
        std::string get_graphml(int connected_component_ID);
        std::string get_sequence();
        SolutionSizeType set_sequence(std::string sequence);
        bool revert_sequence();
        bool revert_sequence(unsigned int jump);
        std::vector< std::string > get_history();
        SolutionSizeType sample();
        SolutionSizeType sample(int position);
        SolutionSizeType sample(int start, int end);
        SolutionSizeType sample_plocal(int min_num_pos, int max_num_pos);
        SolutionSizeType sample_plocal();
        SolutionSizeType sample_clocal(int min_num_pos, int max_num_pos);
        SolutionSizeType sample_clocal(int connected_component_ID);
        SolutionSizeType sample_clocal();
        SolutionSizeType number_of_sequences();
        SolutionSizeType number_of_sequences(int connected_component_ID);
        int number_of_connected_components();
        std::vector<int> component_vertices(int connected_component_ID);
        std::vector< int > articulation_vertices();
        std::vector< int > articulation_vertices(int connected_component_ID);
        unsigned int max_number_of_dimensions();
        // ??? get_articulation_probabilities(connected components ID)
        // Returns basically the ProbabilityMatrix for all articulation vertices (remove make_internal() function) of the whole connected component
        // hash of hash: vertex -> base_color -> number_of_sequences
 
        // ??? get_constrained_probabilities()
        // Returns a hash of hash table of vertex -> base_color -> number_of_sequences for all positions given the base_color.
        // for articulation vertices we can just call the function above and get the sums,
        // for non-articulation we maybe have to do a constraint recalculation for every position/base combination?
 
 
    private:
        detail::DependencyGraph<R> * g;
    };
}
 
#endif