bbq Implementation Documentation

---

weighted_footprint_detector.h

Go to the documentation of this file.

// bbq - Copyright (C) 2005, Axel Mosig, University of Leipzig. See
// main.cpp for details.

#ifndef WEIGHTED_FOOTPRINT_DETECTOR_H
#define WEIGHTED_FOOTPRINT_DETECTOR_H

#include <set>
#include <string>
#include <map>
#include <list>
#include <gmpxx.h>
#include "weighted_bitsets.h"
#include "weighted_bit_multi_set.h"
#include "bit_multi_set.h"
#include "triple.h"


//typedef uint_bitset bit_set;
//typedef uint64_bitset bit_set;
//typedef weighted_variable_bitset w_bit_set;



namespace bbq {

typedef std::list< std::triple<int,int,bool> > match_list;
typedef std::map<std::string,std::list<int> > group_to_index_list;

template<class w_bit_set>
class weighted_footprint_detector
{
        
public:

        typedef std::set< w_bit_set > arrangement;
        typedef std::pair< typename arrangement::iterator , typename arrangement::iterator > arrangement_range;
        typedef std::set< w_bit_set > cell_set; 
        
private:
        
        int k;

        int kappa;

        int K;

        char** s;

        int num_of_group_characters;

        char** group_names;

        int* group_sizes;

        int** group_indices;

        //char*** group_fragments;
        
        char** s_names;
        
        char** T;

        char** T_names;
        
        int* n;

        int* N;

        int* m;

        int h;

        int h_so_far;

        float threshold;

        bool enum_differences;

        int delta;

        bool count_results;

        bool reverted;

        int algorithm;
        
        bool grouped;

        bool output_detail;

        bool anything_found;

        bool ps_output;

        std::string ps_filename;
        
        mpz_class progress;

        int prgr_count;

        mpz_class num_of_inst;

        int *** p;

        bool *** R;

        int ** lambda;

        int * Lambda;

        w_bit_set ** C;

        arrangement* A;

        int ** P;
 
        int *** M;
        
        int L;

        float overall_best_weight;

        float h_best_weight;

        int* best_nu;

        int* last_nu;

        int** best_h_nu;
        
        float* best_h_wghts;

        w_bit_set* best_h_intersections;

        int num_of_solutions;

        w_bit_set best_intersection;

        bool weighted;

        int weight_type;

        bool reverse;

        bool report_progress;

        int* index_table;

        int** frequencies;

        int*** di_frequencies;
        
public:

        weighted_footprint_detector();

        weighted_footprint_detector(int,int,char**,char**,char**,char**,int*,int*,int*);

        ~weighted_footprint_detector();

        void clear();

        void init_arrangement_cells();

        bool bound(const w_bit_set& M, const unsigned int& j);
        
        bool w_bound(const w_bit_set& M, const unsigned int& j);

        bool h_best_w_bound(const w_bit_set& M, const unsigned int& j);

        void enum_w_sets(w_bit_set M, int j);

        void enum_h_best_w_sets(w_bit_set M, int j);

        void enum_h_best_sets(w_bit_set M, int j);
        
        void enum_sets(w_bit_set M, int j);

        void enumerate_subsets();

        void enumerate_h_best_subsets();
        
        void compute_intersections();

        void update_h_best_list(const float& wght, int* nu, w_bit_set& intersection);

        void compute_h_best_intersections();

        w_bit_set difference(w_bit_set M, w_bit_set& D);
        
        bool test_diff_set(w_bit_set& M);

        void get_element_array(w_bit_set M, int* E, int& l);
        
        void enumerate_differences(int delta);
        
        void get_frag_occurences(int i, int j, match_list&);

        void get_occurences(int i, int j);

        void get_group_occurences(int i, int j);

        void run(int,float);

        void reverse_compl();

        float get_result();

        void print_h_results();

        float print_single_result(int* nu, w_bit_set& intersection, const float& weight);

        float print_result();

        void print_postscript(std::string filename);

        void print_ps_labels(std::string filename);
        
        void print_ps_h_results(std::string&);

        void print_ps_single_result(int* nu, std::ostream& o, w_bit_set& intersection);
        
        //int intersection_cardinality(unsigned int);

        void print_with_names(w_bit_set&);

        void set_number_of_hits(int);

        void set_weighted(bool);

        void set_count_results(bool);

        void set_weight_type(int wt);

        void set_reverse(bool);

        void set_postscript(bool);

        void set_ps_filename(std::string);

        void set_progress_report(bool);
        
        void set_algorithm(int A);

        void set_grouping(bool);

        void set_group_characters(int);
        
        void get_groups();

        void set_output_detail(bool);

        void set_delta(int);
        
        //void get_grouped_occurences(int i, int j);

        bool increase(int* nu,int I);

        bool differs(int*,int*);

        double p_value(int i, int j, int nu);

        void get_freq();

        float get_weight(int i, int j, int nu);
                
        void compute_index_table();
};

template class weighted_footprint_detector<weighted_variable_bitset>;
template class weighted_footprint_detector<weighted_bit_multi_set>;
template class weighted_footprint_detector<bit_multi_set>;

typedef weighted_footprint_detector<weighted_variable_bitset> w_set_footprint_detector;
typedef weighted_footprint_detector<bit_multi_set> w_mset_footprint_detector;
typedef weighted_footprint_detector<weighted_bit_multi_set> w_wmset_footprint_detector;


} // end namespace bbq


#include "weighted_footprint_detector.cpp"

#endif

bbq Implementation Documentation
Axel Mosig, Bioinformatics, University of Leipzig