Alphabet.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2006-2009 Soeren Sonnenburg
 * Copyright (C) 2006-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _CALPHABET__H__
#define _CALPHABET__H__

#include <shogun/base/SGObject.h>
#include <shogun/lib/common.h>

namespace shogun
{
enum EAlphabet
{
    DNA=0,

    RAWDNA=1,

    RNA=2,

    PROTEIN=3,

    // BINARY just 0 and 1
    BINARY=4,

    ALPHANUM=5,

    CUBE=6,

    RAWBYTE=7,

    IUPAC_NUCLEIC_ACID=8,

    IUPAC_AMINO_ACID=9,

    NONE=10,

    DIGIT=11,

    DIGIT2=12,

    RAWDIGIT=13,

    RAWDIGIT2=14,

    UNKNOWN=15,

    SNP=16,

    RAWSNP=17
};


class CAlphabet : public CSGObject
{
    public:

        CAlphabet();

        CAlphabet(char* alpha, int32_t len);

        CAlphabet(EAlphabet alpha);

        CAlphabet(CAlphabet* alpha);
        virtual ~CAlphabet();

        bool set_alphabet(EAlphabet alpha);

        inline EAlphabet get_alphabet() const
        {
            return alphabet;
        }

        inline int32_t get_num_symbols() const
        {
            return num_symbols;
        }

        inline int32_t get_num_bits() const
        {
            return num_bits;
        }

        inline uint8_t remap_to_bin(uint8_t c)
        {
            return maptable_to_bin[c];
        }

        inline uint8_t remap_to_char(uint8_t c)
        {
            return maptable_to_char[c];
        }

        void clear_histogram();

        template <class T>
        void add_string_to_histogram(T* p, int64_t len)
        {
            for (int64_t i=0; i<len; i++)
                add_byte_to_histogram((uint8_t) (p[i]));
        }

        inline void add_byte_to_histogram(uint8_t p)
        {
            histogram[p]++;
        }

        void print_histogram();

        SGVector<int64_t> get_histogram();

        bool check_alphabet(bool print_error=true);

        inline bool is_valid(uint8_t c)
        {
            return valid_chars[c];
        }

        bool check_alphabet_size(bool print_error=true);

        int32_t get_num_symbols_in_histogram();

        int32_t get_max_value_in_histogram();

        int32_t get_num_bits_in_histogram();

        static const char* get_alphabet_name(EAlphabet alphabet);


        virtual const char* get_name() const { return "Alphabet"; }

        template <class ST>
        static void translate_from_single_order(ST* obs, int32_t sequence_length, int32_t start, int32_t p_order, int32_t max_val);

        template <class ST>
        static void translate_from_single_order_reversed(ST* obs, int32_t sequence_length, int32_t start, int32_t p_order, int32_t max_val);

        template <class ST>
        static void translate_from_single_order(ST* obs, int32_t sequence_length, int32_t start, int32_t p_order, int32_t max_val, int32_t gap);

        template <class ST>
        static void translate_from_single_order_reversed(ST* obs, int32_t sequence_length, int32_t start, int32_t p_order, int32_t max_val, int32_t gap);

    private:
        void init();

    protected:
        void init_map_table();

        void copy_histogram(CAlphabet* src);

    public:
        static const uint8_t B_A;
        static const uint8_t B_C;
        static const uint8_t B_G;
        static const uint8_t B_T;
        static const uint8_t B_0;
        static const uint8_t MAPTABLE_UNDEF;
        static const char* alphabet_names[18];

    protected:
        virtual void load_serializable_post() throw (ShogunException);

    protected:
        EAlphabet alphabet;
        int32_t num_symbols;
        int32_t num_bits;
        bool valid_chars[1 << (sizeof(uint8_t)*8)];
        uint8_t maptable_to_bin[1 << (sizeof(uint8_t)*8)];
        uint8_t maptable_to_char[1 << (sizeof(uint8_t)*8)];
        int64_t histogram[1 << (sizeof(uint8_t)*8)];
};
}
#endif