Features.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
 * Subset support written (W) 2011 Heiko Strathmann
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _CFEATURES__H__
#define _CFEATURES__H__

#include <shogun/lib/common.h>
#include <shogun/io/File.h>
#include <shogun/base/SGObject.h>
#include <shogun/preprocessor/Preprocessor.h>
#include <shogun/features/FeatureTypes.h>
#include <shogun/features/Subset.h>

namespace shogun
{
    class CFile;
    class CPreprocessor;
    class CKernel;
    enum EFeatureType;
    enum EFeatureClass;
    enum EFeatureProperty;
}

namespace shogun
{

class CFeatures : public CSGObject
{
    void init(void);

    public:
        CFeatures(int32_t size=0);

        CFeatures(const CFeatures& orig);

        CFeatures(CFile* loader);

        virtual CFeatures* duplicate() const=0;

        virtual ~CFeatures();

        virtual EFeatureType get_feature_type()=0;

        virtual EFeatureClass get_feature_class()=0;

        virtual int32_t add_preprocessor(CPreprocessor* p);

        virtual CPreprocessor* del_preprocessor(int32_t num);

        CPreprocessor* get_preprocessor(int32_t num);

        inline void set_preprocessed(int32_t num) { preprocessed[num]=true; }

        inline bool is_preprocessed(int32_t num) { return preprocessed[num]; }

        int32_t get_num_preprocessed();

        inline int32_t get_num_preprocessors() const { return num_preproc; }

        void clean_preprocessors();

        inline int32_t get_cache_size() { return cache_size; };

        virtual int32_t get_num_vectors() const=0;

        virtual bool reshape(int32_t num_features, int32_t num_vectors)
        {
            SG_NOTIMPLEMENTED;
            return false;
        }

        virtual int32_t get_size()=0;

        void list_feature_obj();

        virtual void load(CFile* loader)
        {
            SG_SET_LOCALE_C;
            SG_NOTIMPLEMENTED;
            SG_RESET_LOCALE;
        }

        virtual void save(CFile* writer)
        {
            SG_SET_LOCALE_C;
            SG_NOTIMPLEMENTED;
            SG_RESET_LOCALE;
        }

        bool check_feature_compatibility(CFeatures* f);

        inline bool has_property(EFeatureProperty p) { return (properties & p) != 0; }

        inline void set_property(EFeatureProperty p)
        {
            properties |= p;
        }

        inline void unset_property(EFeatureProperty p)
        {
            properties &= (properties | p) ^ p;
        }

        virtual void set_subset(CSubset* subset);

        virtual void remove_subset();

        virtual void subset_changed_post() {}

        inline index_t subset_idx_conversion(index_t idx) const
        {
            return m_subset ? m_subset->subset_idx_conversion(idx) : idx;
        }

        inline bool has_subset() const { return m_subset!=NULL; }

        virtual CFeatures* copy_subset(SGVector<index_t> indices)
        {
            SG_ERROR("copy_subset and therefore model storage of CMachine "
                    "(required for cross-validation and model-selection is ",
                    "not yet implemented for feature type %s\n", get_name());
            return NULL;
        }

    private:
        uint64_t  properties;

        int32_t cache_size;

        CPreprocessor** preproc;

        int32_t num_preproc;

        bool* preprocessed;

    protected:

        CSubset* m_subset;
};
}
#endif