CombinedDotFeatures.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) 2009-2010 Soeren Sonnenburg
 * Copyright (C) 2009 Fraunhofer Institute FIRST and Max-Planck-Society
 * Copyright (C) 2010 Berlin Institute of Technology
 *
 */

#ifndef _COMBINEDDOTFEATURES_H___
#define _COMBINEDDOTFEATURES_H___

#include "lib/common.h"
#include "lib/List.h"
#include "features/DotFeatures.h"
#include "features/Features.h"

namespace shogun
{
class CFeatures;
template <class T> class CList;
template <class T> class CListElement;
class CCombinedDotFeatures : public CDotFeatures
{
    public:
        CCombinedDotFeatures();

        CCombinedDotFeatures(const CCombinedDotFeatures & orig);

        virtual ~CCombinedDotFeatures();

        inline virtual int32_t get_num_vectors()
        {
            return num_vectors;
        }

        inline virtual int32_t get_dim_feature_space()
        {
            return  num_dimensions;
        }

        virtual float64_t dot(int32_t vec_idx1, int32_t vec_idx2);

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

        virtual void dense_dot_range(float64_t* output, int32_t start, int32_t stop, float64_t* alphas, float64_t* vec, int32_t dim, float64_t b);

        virtual void dense_dot_range_subset(int32_t* sub_index, int32_t num, float64_t* output, float64_t* alphas, float64_t* vec, int32_t dim, float64_t b);

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

        inline virtual EFeatureType get_feature_type()
        {
            return F_DREAL;
        }

        inline virtual EFeatureClass get_feature_class()
        {
            return C_COMBINED_DOT;
        }

        inline virtual int32_t get_size()
        {
            return sizeof(float64_t);
        }

        struct combined_feature_iterator
        {
            CDotFeatures* f;
            CListElement<CDotFeatures*>* current;
            void* iterator;
            /* the index of the vector over whose components to iterate over */
            int32_t vector_index;
        };

        virtual void* get_feature_iterator(int32_t vector_index)
        {
            combined_feature_iterator* it=new combined_feature_iterator[1];

            it->current=NULL;
            it->f=get_first_feature_obj(it->current);
            it->iterator=it->f->get_feature_iterator(vector_index);
            it->vector_index=vector_index;
            return it;
        }

        virtual bool get_next_feature(int32_t& index, float64_t& value, void* iterator)
        {
            ASSERT(iterator);
            combined_feature_iterator* it = (combined_feature_iterator*) iterator;

            while (it->f)
            {
                if (it->f->get_next_feature(index, value, it->iterator))
                {
                    value*=get_combined_feature_weight();
                    return true;
                }

                it->f->free_feature_iterator(it->iterator);
                it->f=get_next_feature_obj(it->current);
                if (it->f)
                    it->iterator=it->f->get_feature_iterator(it->vector_index);
                else
                    it->iterator=NULL;
            }
            return false;
        }

        virtual void free_feature_iterator(void* iterator)
        {
            if (iterator)
            {
                combined_feature_iterator* it = (combined_feature_iterator*) iterator;
                if (it->iterator && it->f)
                    it->f->free_feature_iterator(it->iterator);
                delete[] it;
            }
        }

        virtual CFeatures* duplicate() const;

        void list_feature_objs();

        inline CDotFeatures* get_first_feature_obj()
        {
            CDotFeatures* f=feature_list->get_first_element();
            SG_REF(f);
            return f;
        }

        inline CDotFeatures* get_first_feature_obj(CListElement<CDotFeatures*>*&current)
        {
            CDotFeatures* f=feature_list->get_first_element(current);
            SG_REF(f);
            return f;
        }

        inline CDotFeatures* get_next_feature_obj()
        {
            CDotFeatures* f=feature_list->get_next_element();
            SG_REF(f);
            return f;
        }

        inline CDotFeatures* get_next_feature_obj(CListElement<CDotFeatures*>*&current)
        {
            CDotFeatures* f=feature_list->get_next_element(current);
            SG_REF(f);
            return f;
        }

        inline CDotFeatures* get_last_feature_obj()
        {
            CDotFeatures* f=feature_list->get_last_element();
            SG_REF(f);
            return f;
        }

        inline bool insert_feature_obj(CDotFeatures* obj)
        {
            ASSERT(obj);
            SG_REF(obj);
            bool result=feature_list->insert_element(obj);
            update_dim_feature_space_and_num_vec();
            return result;
        }

        inline bool append_feature_obj(CDotFeatures* obj)
        {
            ASSERT(obj);
            SG_REF(obj);
            bool result=feature_list->append_element(obj);
            update_dim_feature_space_and_num_vec();
            return result;
        }

        inline bool delete_feature_obj()
        {
            CDotFeatures* f=feature_list->delete_element();
            if (f)
            {
                SG_UNREF(f);
                update_dim_feature_space_and_num_vec();
                return true;
            }
            else
                return false;
        }

        inline int32_t get_num_feature_obj()
        {
            return feature_list->get_num_elements();
        }

        virtual void get_subfeature_weights(float64_t** weights, int32_t* num_weights);

        virtual void set_subfeature_weights(
            float64_t* weights, int32_t num_weights);

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

    protected:
        void update_dim_feature_space_and_num_vec();

    protected:
        CList<CDotFeatures*>* feature_list;

        int32_t num_vectors;
        int32_t num_dimensions;
};
}
#endif // _DOTFEATURES_H___