SimpleFeatures.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-2010 Soeren Sonnenburg
 * Written (W) 1999-2008 Gunnar Raetsch
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 * Copyright (C) 2010 Berlin Institute of Technology
 */

#ifndef _SIMPLEFEATURES__H__
#define _SIMPLEFEATURES__H__

#include <shogun/lib/common.h>
#include <shogun/lib/Cache.h>
#include <shogun/io/File.h>
#include <shogun/features/DotFeatures.h>
#include <shogun/features/StringFeatures.h>
#include <shogun/lib/DataType.h>

namespace shogun {
template<class ST> class CStringFeatures;
template<class ST> class CSimpleFeatures;
template<class ST> class SGMatrix;
class CDotFeatures;

template<class ST> class CSimpleFeatures: public CDotFeatures
{
public:
    CSimpleFeatures(int32_t size = 0);

    CSimpleFeatures(const CSimpleFeatures & orig);

    CSimpleFeatures(SGMatrix<ST> matrix);

    CSimpleFeatures(ST* src, int32_t num_feat, int32_t num_vec);

    CSimpleFeatures(CFile* loader);

    virtual CFeatures* duplicate() const;

    virtual ~CSimpleFeatures();

    void free_feature_matrix();

    void free_features();

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

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

    SGVector<ST> get_feature_vector(int32_t num);

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

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

    void vector_subset(int32_t* idx, int32_t idx_len);

    void feature_subset(int32_t* idx, int32_t idx_len);

    void get_feature_matrix(ST** dst, int32_t* num_feat, int32_t* num_vec);

    SGMatrix<ST> get_feature_matrix();

    SGMatrix<ST> steal_feature_matrix();

    void set_feature_matrix(SGMatrix<ST> matrix);

    ST* get_feature_matrix(int32_t &num_feat, int32_t &num_vec);

    CSimpleFeatures<ST>* get_transposed();

    ST* get_transposed(int32_t &num_feat, int32_t &num_vec);

    virtual void set_feature_matrix(ST* fm, int32_t num_feat, int32_t num_vec);

    virtual void copy_feature_matrix(SGMatrix<ST> src);

    void obtain_from_dot(CDotFeatures* df);

    virtual bool apply_preprocessor(bool force_preprocessing = false);

    virtual int32_t get_size();

    virtual int32_t get_num_vectors() const;

    int32_t get_num_features();

    void set_num_features(int32_t num);

    void set_num_vectors(int32_t num);

    void initialize_cache();

    virtual EFeatureClass get_feature_class();

    virtual EFeatureType get_feature_type();

    virtual bool reshape(int32_t p_num_features, int32_t p_num_vectors);

    virtual int32_t get_dim_feature_space() const;

    virtual float64_t dot(int32_t vec_idx1, CDotFeatures* df,
            int32_t vec_idx2);

    virtual float64_t dense_dot(int32_t vec_idx1, const float64_t* vec2,
            int32_t vec2_len);

    virtual void add_to_dense_vec(float64_t alpha, int32_t vec_idx1,
            float64_t* vec2, int32_t vec2_len, bool abs_val = false);

    virtual int32_t get_nnz_features_for_vector(int32_t num);

    virtual bool Align_char_features(CStringFeatures<char>* cf,
            CStringFeatures<char>* Ref, float64_t gapCost);

    virtual void load(CFile* loader);

    virtual void save(CFile* saver);

    #ifndef DOXYGEN_SHOULD_SKIP_THIS

    struct simple_feature_iterator
    {
        ST* vec;
        int32_t vidx;
        int32_t vlen;
        bool vfree;

        int32_t index;
    };
    #endif

    virtual void* get_feature_iterator(int32_t vector_index);

    virtual bool get_next_feature(int32_t& index, float64_t& value,
            void* iterator);

    virtual void free_feature_iterator(void* iterator);

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

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

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

private:
    void init();

protected:
    int32_t num_vectors;

    int32_t num_features;

    ST* feature_matrix;

    int32_t feature_matrix_num_vectors;

    int32_t feature_matrix_num_features;

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