StringFeatures.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) 1999-2009 Soeren Sonnenburg
 * Written (W) 1999-2008 Gunnar Raetsch
 * Written (W) 2011-2012 Heiko Strathmann
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _CSTRINGFEATURES__H__
#define _CSTRINGFEATURES__H__

#include <shogun/lib/common.h>
#include <shogun/lib/Cache.h>
#include <shogun/lib/DynamicArray.h>
#include <shogun/lib/Compressor.h>
#include <shogun/io/File.h>

#include <shogun/features/Features.h>
#include <shogun/features/Alphabet.h>

namespace shogun
{
class CAlphabet;
template <class T> class CDynamicArray;
class CFile;
template <class T> class SGString;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
struct SSKDoubleFeature
{
    int feature1;
    int feature2;
    int group;
};

struct SSKTripleFeature
{
    int feature1;
    int feature2;
    int feature3;
    int group;
};
#endif

template <class ST> class CStringFeatures : public CFeatures
{
    public:
        CStringFeatures();

        CStringFeatures(EAlphabet alpha);

        CStringFeatures(SGStringList<ST> string_list, EAlphabet alpha);

        CStringFeatures(SGStringList<ST> string_list, CAlphabet* alpha);

        CStringFeatures(CAlphabet* alpha);

        CStringFeatures(const CStringFeatures & orig);

        CStringFeatures(CFile* loader, EAlphabet alpha=DNA);

        virtual ~CStringFeatures();

        virtual void cleanup();

        virtual void cleanup_feature_vector(int32_t num);

        virtual void cleanup_feature_vectors(int32_t start, int32_t stop);

        virtual EFeatureClass get_feature_class() const;

        virtual EFeatureType get_feature_type() const;

        CAlphabet* get_alphabet();

        virtual CFeatures* duplicate() const;

        SGVector<ST> get_feature_vector(int32_t num);

        void set_feature_vector(SGVector<ST> vector, int32_t num);

        void enable_on_the_fly_preprocessing();

        void disable_on_the_fly_preprocessing();

        ST* get_feature_vector(int32_t num, int32_t& len, bool& dofree);

        CStringFeatures<ST>* get_transposed();

        SGString<ST>* get_transposed(int32_t &num_feat, int32_t &num_vec);

        void free_feature_vector(ST* feat_vec, int32_t num, bool dofree);

        void free_feature_vector(SGVector<ST> feat_vec, int32_t num);

        virtual ST get_feature(int32_t vec_num, int32_t feat_num);

        virtual int32_t get_vector_length(int32_t vec_num);

        virtual int32_t get_max_vector_length();

        virtual int32_t get_num_vectors() const;

        floatmax_t get_num_symbols();

        floatmax_t get_max_num_symbols();

        // these functions are necessary to find out about a former conversion process

        floatmax_t get_original_num_symbols();

        int32_t get_order();

        ST get_masked_symbols(ST symbol, uint8_t mask);

        ST shift_offset(ST offset, int32_t amount);

        ST shift_symbol(ST symbol, int32_t amount);

        virtual void load(CFile* loader);

        void load_ascii_file(char* fname, bool remap_to_bin=true,
                EAlphabet ascii_alphabet=DNA, EAlphabet binary_alphabet=RAWDNA);

        bool load_fasta_file(const char* fname, bool ignore_invalid=false);

        bool load_fastq_file(const char* fname,
                bool ignore_invalid=false, bool bitremap_in_single_string=false);

        bool load_from_directory(char* dirname);

        void set_features(SGStringList<ST> feats);

        bool set_features(SGString<ST>* p_features, int32_t p_num_vectors,
                int32_t p_max_string_length);

        bool append_features(CStringFeatures<ST>* sf);

        bool append_features(SGString<ST>* p_features, int32_t p_num_vectors,
                int32_t p_max_string_length);

        SGStringList<ST> get_features();

        virtual SGString<ST>* get_features(int32_t& num_str, int32_t& max_str_len);

        virtual SGString<ST>* copy_features(int32_t& num_str, int32_t& max_str_len);

        virtual void get_features(SGString<ST>** dst, int32_t* num_str);

        virtual void save(CFile* writer);

        virtual bool load_compressed(char* src, bool decompress);

        virtual bool save_compressed(char* dest, E_COMPRESSION_TYPE compression, int level);

        virtual int32_t get_size() const;

        virtual bool apply_preprocessor(bool force_preprocessing=false);

        int32_t obtain_by_sliding_window(int32_t window_size, int32_t step_size, int32_t skip=0);

        int32_t obtain_by_position_list(int32_t window_size, CDynamicArray<int32_t>* positions,
                int32_t skip=0);

        bool obtain_from_char(CStringFeatures<char>* sf, int32_t start,
                int32_t p_order, int32_t gap, bool rev);

        template <class CT>
            bool obtain_from_char_features(CStringFeatures<CT>* sf, int32_t start,
                    int32_t p_order, int32_t gap, bool rev);

        bool have_same_length(int32_t len=-1);

        void embed_features(int32_t p_order);

        void compute_symbol_mask_table(int64_t max_val);

        void unembed_word(ST word, uint8_t* seq, int32_t len);

        ST embed_word(ST* seq, int32_t len);

        void determine_maximum_string_length();

        static ST* get_zero_terminated_string_copy(SGString<ST> str);

        virtual void set_feature_vector(int32_t num, ST* string, int32_t len);

        virtual void get_histogram(float64_t** hist, int32_t* rows, int32_t* cols,
                bool normalize=true);

        virtual void create_random(float64_t* hist, int32_t rows, int32_t cols,
                int32_t num_vec);

        virtual CFeatures* copy_subset(SGVector<index_t> indices);

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

        virtual void subset_changed_post();

    protected:
        virtual ST* compute_feature_vector(int32_t num, int32_t& len);

    private:
        void init();

    protected:

        CAlphabet* alphabet;

        int32_t num_vectors;

        SGString<ST>* features;

        ST* single_string;

        int32_t length_of_single_string;

        int32_t max_string_length;

        floatmax_t num_symbols;

        floatmax_t original_num_symbols;

        int32_t order;

        ST* symbol_mask_table;
        
        int32_t symbol_mask_table_len;

        bool preprocess_on_get;

        CCache<ST>* feature_cache;
};
}
#endif // _CSTRINGFEATURES__H__