DenseFeatures.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
 * Written (W) 2011-2013 Heiko Strathmann
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 * Copyright (C) 2010 Berlin Institute of Technology
 */

#ifndef _DENSEFEATURES__H__
#define _DENSEFEATURES__H__

#include <shogun/lib/config.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>

#include <shogun/lib/SGMatrix.h>

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

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

    CDenseFeatures(const CDenseFeatures & orig);

    CDenseFeatures(SGMatrix<ST> matrix);

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

    CDenseFeatures(CFile* loader);

    virtual CFeatures* duplicate() const;

    virtual ~CDenseFeatures();

    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);

    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);

    CDenseFeatures<ST>* get_transposed();

    ST* get_transposed(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_num_vectors() const;

    int32_t get_num_features() const;

    void set_num_features(int32_t num);

    void set_num_vectors(int32_t num);

    void initialize_cache();

    virtual EFeatureClass get_feature_class() const;

    virtual EFeatureType get_feature_type() const;

    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 void load(CFile* loader);

    virtual void save(CFile* saver);

#ifndef DOXYGEN_SHOULD_SKIP_THIS

    struct dense_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);

    virtual CFeatures* copy_dimension_subset(SGVector<index_t> dims);

    virtual bool is_equal(CDenseFeatures* rhs);

    CFeatures* create_merged_copy(CList* other);

    CFeatures* create_merged_copy(CFeatures* other);

    static CDenseFeatures* obtain_from_generic(CFeatures* const base_features);

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

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;

    SGMatrix<ST> feature_matrix;

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