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 "lib/common.h"
#include "lib/Mathematics.h"
#include "lib/io.h"
#include "lib/Cache.h"
#include "lib/File.h"
#include "preproc/SimplePreProc.h"
#include "features/DotFeatures.h"
#include "features/StringFeatures.h"

#include <string.h>

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

template <class ST> class CSimpleFeatures: public CDotFeatures
{
    public:
        CSimpleFeatures(int32_t size=0)
        : CDotFeatures(size), num_vectors(0), num_features(0),
            feature_matrix(NULL), feature_cache(NULL) {}

        CSimpleFeatures(const CSimpleFeatures & orig)
        : CDotFeatures(orig), num_vectors(orig.num_vectors),
            num_features(orig.num_features),
            feature_matrix(orig.feature_matrix),
            feature_cache(orig.feature_cache)
        {
            if (orig.feature_matrix)
            {
                free_feature_matrix();
                feature_matrix=new ST(num_vectors*num_features);
                memcpy(feature_matrix, orig.feature_matrix, sizeof(float64_t)*int64_t(num_vectors)*num_features);
            }
        }

        CSimpleFeatures(ST* src, int32_t num_feat, int32_t num_vec)
        : CDotFeatures(0), num_vectors(0), num_features(0),
            feature_matrix(NULL), feature_cache(NULL)
        {
            copy_feature_matrix(src, num_feat, num_vec);
        }

        CSimpleFeatures(CFile* loader)
        : CDotFeatures(loader), num_vectors(0), num_features(0),
            feature_matrix(NULL), feature_cache(NULL)
        {
            load(loader);
        }

        virtual CFeatures* duplicate() const
        {
            return new CSimpleFeatures<ST>(*this);
        }

        virtual ~CSimpleFeatures()
        {
            SG_DEBUG("deleting simplefeatures (0x%p)\n", this);
            free_features();
        }

        void free_feature_matrix()
        {
            delete[] feature_matrix;
            feature_matrix = NULL;
            num_vectors=0;
            num_features=0;
        }

        void free_features()
        {
            free_feature_matrix();
            delete feature_cache;
            feature_cache = NULL;
        }

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

            if (feature_matrix)
            {
                dofree=false;
                return &feature_matrix[num*int64_t(num_features)];
            } 
            else
            {
                SG_DEBUG( "compute feature!!!\n") ;

                ST* feat=NULL;
                dofree=false;

                if (feature_cache)
                {
                    feat=feature_cache->lock_entry(num);

                    if (feat)
                        return feat;
                    else
                    {
                        feat=feature_cache->set_entry(num);
                    }
                }

                if (!feat)
                    dofree=true;
                feat=compute_feature_vector(num, len, feat);


                if (get_num_preproc())
                {
                    int32_t tmp_len=len;
                    ST* tmp_feat_before = feat;
                    ST* tmp_feat_after = NULL;

                    for (int32_t i=0; i<get_num_preproc(); i++)
                    {
                        CSimplePreProc<ST>* p = (CSimplePreProc<ST>*) get_preproc(i);
                        tmp_feat_after=p->apply_to_feature_vector(tmp_feat_before, tmp_len);
                        SG_UNREF(p);

                        if (i!=0)   // delete feature vector, except for the the first one, i.e., feat
                            delete[] tmp_feat_before;
                        tmp_feat_before=tmp_feat_after;
                    }

                    memcpy(feat, tmp_feat_after, sizeof(ST)*tmp_len);
                    delete[] tmp_feat_after;

                    len=tmp_len ;
                    SG_DEBUG( "len: %d len2: %d\n", len, num_features);
                }
                return feat ;
            }
        }

        void set_feature_vector(ST* src, int32_t len, int32_t num)
        {
            if (num>=num_vectors)
            {
                SG_ERROR("Index out of bounds (number of vectors %d, you "
                        "requested %d)\n", num_vectors, num);
            }

            if (!feature_matrix)
                SG_ERROR("Requires a in-memory feature matrix\n");

            if (len != num_features)
                SG_ERROR("Vector not of length %d (has %d)\n", num_features, len);

            memcpy(&feature_matrix[num*int64_t(num_features)], src, int64_t(num_features)*sizeof(ST));
        }

        void get_feature_vector(ST** dst, int32_t* len, int32_t num)
        {
            if (num>=num_vectors)
            {
                SG_ERROR("Index out of bounds (number of vectors %d, you "
                        "requested %d)\n", num_vectors, num);
            }

            int32_t vlen=0;
            bool free_vec;

            ST* vec= get_feature_vector(num, vlen, free_vec);

            *len=vlen;
            *dst=(ST*) malloc(vlen*sizeof(ST));
            memcpy(*dst, vec, vlen*sizeof(ST));

            free_feature_vector(vec, num, free_vec);
        }

        void free_feature_vector(ST* feat_vec, int32_t num, bool dofree)
        {
            if (feature_cache)
                feature_cache->unlock_entry(num);

            if (dofree)
                delete[] feat_vec ;
        }

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

            int64_t num=int64_t(num_features)*num_vectors;
            *num_feat=num_features;
            *num_vec=num_vectors;
            *dst=(ST*) malloc(sizeof(ST)*num);
            if (!*dst)
                SG_ERROR("Allocating %ld bytes failes\n", sizeof(ST)*num);
            memcpy(*dst, feature_matrix, num * sizeof(ST));
        }

        ST* get_feature_matrix(int32_t &num_feat, int32_t &num_vec)
        {
            num_feat=num_features;
            num_vec=num_vectors;
            return feature_matrix;
        }

        CSimpleFeatures<ST>* get_transposed()
        {
            int32_t num_feat;
            int32_t num_vec;
            ST* fm=get_transposed(num_feat, num_vec);

            return new CSimpleFeatures<ST>(fm, num_feat, num_vec);
        }

        ST* get_transposed(int32_t &num_feat, int32_t &num_vec)
        {
            num_feat=num_vectors;
            num_vec=num_features;

            ST* fm=new ST[int64_t(num_feat)*num_vec];

            for (int32_t i=0; i<num_vectors; i++)
            {
                int32_t vlen;
                bool vfree;
                ST* vec=get_feature_vector(i, vlen, vfree);

                for (int32_t j=0; j<vlen; j++)
                    fm[j*int64_t(num_vectors)+i]=vec[j];

                free_feature_vector(vec, i, vfree);
            }

            return fm;
        }

        virtual void set_feature_matrix(ST* fm, int32_t num_feat, int32_t num_vec)
        {
            free_feature_matrix();
            feature_matrix=fm;
            num_features=num_feat;
            num_vectors=num_vec;
        }

        virtual void copy_feature_matrix(ST* src, int32_t num_feat, int32_t num_vec)
        {
            free_feature_matrix();
            feature_matrix=new ST[((int64_t) num_feat)*num_vec];
            memcpy(feature_matrix, src, (sizeof(ST)*((int64_t) num_feat)*num_vec));

            num_features=num_feat;
            num_vectors=num_vec;
        }

        void obtain_from_dot(CDotFeatures* df)
        {
            int32_t num_feat=df->get_dim_feature_space();
            int32_t num_vec=df->get_num_vectors();

            ASSERT(num_feat>0 && num_vec>0);

            free_feature_matrix();
            feature_matrix=new ST[((int64_t) num_feat)*num_vec];

            for (int32_t i=0; i<num_vec; i++)
            {
                float64_t* dst;
                int32_t len;
                df->get_feature_vector(&dst, &len, i);
                ASSERT(num_feat==len);

                for (int32_t j=0; j<num_feat; j++)
                    feature_matrix[i*int64_t(num_feat)+j]=(ST) dst[j];

                delete[] dst;
            }
            num_features=num_feat;
            num_vectors=num_vec;
        }

        virtual bool apply_preproc(bool force_preprocessing=false)
        {
            SG_DEBUG( "force: %d\n", force_preprocessing);

            if ( feature_matrix && get_num_preproc())
            {

                for (int32_t i=0; i<get_num_preproc(); i++)
                { 
                    if ( (!is_preprocessed(i) || force_preprocessing) )
                    {
                        set_preprocessed(i);
                        CSimplePreProc<ST>* p = (CSimplePreProc<ST>*) get_preproc(i);
                        SG_INFO( "preprocessing using preproc %s\n", p->get_name());
                        if (p->apply_to_feature_matrix(this) == NULL)
                        {
                            SG_UNREF(p);
                            return false;
                        }
                        SG_UNREF(p);
                    }
                }
                return true;
            }
            else
            {
                if (!feature_matrix)
                    SG_ERROR( "no feature matrix\n");

                if (!get_num_preproc())
                    SG_ERROR( "no preprocessors available\n");

                return false;
            }
        }

        virtual int32_t get_size() { return sizeof(ST); }


        virtual inline int32_t  get_num_vectors() { return num_vectors; }

        inline int32_t  get_num_features() { return num_features; }

        inline void set_num_features(int32_t num)
        { 
            num_features= num;

            if (num_features && num_vectors)
            {
                delete feature_cache;
                feature_cache= new CCache<ST>(get_cache_size(), num_features, num_vectors);
            }
        }

        inline void set_num_vectors(int32_t num)
        {
            num_vectors= num;
            if (num_features && num_vectors)
            {
                delete feature_cache;
                feature_cache= new CCache<ST>(get_cache_size(), num_features, num_vectors);
            }
        }

        inline virtual EFeatureClass get_feature_class() { return C_SIMPLE; }

        inline virtual EFeatureType get_feature_type();

        virtual bool reshape(int32_t p_num_features, int32_t p_num_vectors)
        {
            if (p_num_features*p_num_vectors == this->num_features * this->num_vectors)
            {
                this->num_features=p_num_features;
                this->num_vectors=p_num_vectors;
                return true;
            }
            else
                return false;
        }

        virtual int32_t get_dim_feature_space()
        {
            return num_features;
        }

        virtual float64_t dot(int32_t vec_idx1, int32_t vec_idx2)
        {
            int32_t len1, len2;
            bool free1, free2;

            ST* vec1= get_feature_vector(vec_idx1, len1, free1);
            ST* vec2= get_feature_vector(vec_idx2, len2, free2);

            float64_t result=CMath::dot(vec1, vec2, len1);

            free_feature_vector(vec1, vec_idx1, free1);
            free_feature_vector(vec2, vec_idx2, free2);

            return result;
        }

        virtual float64_t dense_dot(int32_t vec_idx1, 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)
        {
            ASSERT(vec2_len == num_features);

            int32_t vlen;
            bool vfree;
            ST* vec1=get_feature_vector(vec_idx1, vlen, vfree);

            ASSERT(vlen == num_features);

            if (abs_val)
            {
                for (int32_t i=0; i<num_features; i++)
                    vec2[i]+=alpha*CMath::abs(vec1[i]);
            }
            else
            {
                for (int32_t i=0; i<num_features; i++)
                    vec2[i]+=alpha*vec1[i];
            }

            free_feature_vector(vec1, vec_idx1, vfree);
        }

        virtual inline int32_t get_nnz_features_for_vector(int32_t num)
        {
            return num_features;
        }

        virtual inline bool Align_char_features(
            CStringFeatures<char>* cf, CStringFeatures<char>* Ref, float64_t gapCost)
        {
            return false;
        }

        virtual inline void load(CFile* loader);

        virtual inline void save(CFile* saver);

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

            int32_t index;
        };

        virtual void* get_feature_iterator(int32_t vector_index)
        {
            if (vector_index>=num_vectors)
            {
                SG_ERROR("Index out of bounds (number of vectors %d, you "
                        "requested %d)\n", num_vectors, vector_index);
            }

            simple_feature_iterator* iterator=new simple_feature_iterator[1];
            iterator->vec= get_feature_vector(vector_index, iterator->vlen, iterator->vfree);
            iterator->vidx=vector_index;
            iterator->index=0;
            return iterator;
        }

        virtual bool get_next_feature(int32_t& index, float64_t& value, void* iterator)
        {
            simple_feature_iterator* it=(simple_feature_iterator*) iterator;
            if (!it || it->index>=it->vlen)
                return false;

            index=it->index++;
            value = (float64_t) it->vec[index];

            return true;
        }

        virtual void free_feature_iterator(void* iterator)
        {
            if (!iterator)
                return;

            simple_feature_iterator* it=(simple_feature_iterator*) iterator;
            free_feature_vector(it->vec, it->vidx, it->vfree);
            delete[] it;
        }

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


#ifdef HAVE_BOOST_SERIALIZATION
    private:

        friend class ::boost::serialization::access;
        template<class Archive>
            void save(Archive & ar, const unsigned int archive_version) const
            {

                SG_DEBUG("archiving SimpleFeatures\n");

                ar & ::boost::serialization::base_object<CDotFeatures>(*this);

                //TODO
                //ar & feature_cache;

                ar & num_vectors;
                ar & num_features;

                for (int i=0; i < num_vectors*num_features; ++i) 
                {
                    ar & feature_matrix[i];
                }

                SG_DEBUG("done SimpleFeatures\n");


            }

        template<class Archive>
            void load(Archive & ar, const unsigned int archive_version)
            {

                SG_DEBUG("archiving SimpleFeatures\n");

                ar & ::boost::serialization::base_object<CDotFeatures>(*this);

                //TODO
                //ar & feature_cache;

                ar & num_vectors;
                ar & num_features;

                feature_matrix = new ST[int64_t(num_vectors)*num_features];
                for (int i=0; i< num_vectors*num_features; ++i){
                    ar & feature_matrix[i];
                }


                SG_DEBUG("done SimpleFeatures\n");

            }

        GLOBAL_BOOST_SERIALIZATION_SPLIT_MEMBER();

#endif //HAVE_BOOST_SERIALIZATION


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

        int32_t num_vectors;

        int32_t num_features;

        ST* feature_matrix;

        CCache<ST>* feature_cache;
};

#ifndef DOXYGEN_SHOULD_SKIP_THIS

#define GET_FEATURE_TYPE(f_type, sg_type)   \
template<> inline EFeatureType CSimpleFeatures<sg_type>::get_feature_type() \
{                                                                           \
    return f_type;                                                          \
}

GET_FEATURE_TYPE(F_BOOL, bool)
GET_FEATURE_TYPE(F_CHAR, char)
GET_FEATURE_TYPE(F_BYTE, uint8_t)
GET_FEATURE_TYPE(F_SHORT, int16_t)
GET_FEATURE_TYPE(F_WORD, uint16_t)
GET_FEATURE_TYPE(F_INT, int32_t)
GET_FEATURE_TYPE(F_UINT, uint32_t)
GET_FEATURE_TYPE(F_LONG, int64_t)
GET_FEATURE_TYPE(F_ULONG, uint64_t)
GET_FEATURE_TYPE(F_SHORTREAL, float32_t)
GET_FEATURE_TYPE(F_DREAL, float64_t)
GET_FEATURE_TYPE(F_LONGREAL, floatmax_t)
#undef GET_FEATURE_TYPE

#define GET_FEATURE_NAME(f_name, sg_type)                                   \
template<> inline const char* CSimpleFeatures<sg_type>::get_name() const    \
{                                                                           \
    return f_name;                                                          \
}

GET_FEATURE_NAME("BoolFeatures", bool)
GET_FEATURE_NAME("CharFeatures", char)
GET_FEATURE_NAME("ByteFeatures", uint8_t)
GET_FEATURE_NAME("ShortFeatures", int16_t)
GET_FEATURE_NAME("WordFeatures", uint16_t)
GET_FEATURE_NAME("IntFeatures", int32_t)
GET_FEATURE_NAME("UIntFeatures", uint32_t)
GET_FEATURE_NAME("LongIntFeatures", int64_t)
GET_FEATURE_NAME("ULongIntFeatures", uint64_t)
GET_FEATURE_NAME("ShortRealFeatures", float32_t)
GET_FEATURE_NAME("RealFeatures", float64_t)
GET_FEATURE_NAME("LongRealFeatures", floatmax_t)
#undef GET_FEATURE_NAME

template<> inline bool CSimpleFeatures<float64_t>::Align_char_features(
        CStringFeatures<char>* cf, CStringFeatures<char>* Ref, float64_t gapCost)
{
    ASSERT(cf);
    /*num_vectors=cf->get_num_vectors();
    num_features=Ref->get_num_vectors();

    int64_t len=((int64_t) num_vectors)*num_features;
    free_feature_matrix();
    feature_matrix=new float64_t[len];
    int32_t num_cf_feat=0;
    int32_t num_cf_vec=0;
    int32_t num_ref_feat=0;
    int32_t num_ref_vec=0;
    char* fm_cf=NULL; //cf->get_feature_matrix(num_cf_feat, num_cf_vec);
    char* fm_ref=NULL; //Ref->get_feature_matrix(num_ref_feat, num_ref_vec);

    ASSERT(num_cf_vec==num_vectors);
    ASSERT(num_ref_vec==num_features);

    SG_INFO( "computing aligments of %i vectors to %i reference vectors: ", num_cf_vec, num_ref_vec) ;
    for (int32_t i=0; i< num_ref_vec; i++)
    {
        SG_PROGRESS(i, num_ref_vec) ;
        for (int32_t j=0; j<num_cf_vec; j++)
            feature_matrix[i+j*num_features] = CMath::Align(&fm_cf[j*num_cf_feat], &fm_ref[i*num_ref_feat], num_cf_feat, num_ref_feat, gapCost);
    } ;

    SG_INFO( "created %i x %i matrix (0x%p)\n", num_features, num_vectors, feature_matrix) ;*/
    return true;
}

template<> inline float64_t CSimpleFeatures<bool>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    bool* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i] ? vec2[i] : 0;

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}


template<> inline float64_t CSimpleFeatures<char>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    char* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<uint8_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    uint8_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<int16_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    int16_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}


template<> inline float64_t CSimpleFeatures<uint16_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    uint16_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<int32_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    int32_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<uint32_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    uint32_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<int64_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    int64_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<uint64_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    uint64_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<float32_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    float32_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<float64_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    float64_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=CMath::dot(vec1, vec2, num_features);

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

template<> inline float64_t CSimpleFeatures<floatmax_t>:: dense_dot(int32_t vec_idx1, float64_t* vec2, int32_t vec2_len)
{
    ASSERT(vec2_len == num_features);

    int32_t vlen;
    bool vfree;
    floatmax_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);

    ASSERT(vlen == num_features);
    float64_t result=0;

    for (int32_t i=0 ; i<num_features; i++)
        result+=vec1[i]*vec2[i];

    free_feature_vector(vec1, vec_idx1, vfree);

    return result;
}

#define LOAD(f_load, sg_type)                                               \
template<> inline void CSimpleFeatures<sg_type>::load(CFile* loader)        \
{                                                                           \
    ASSERT(loader);                                                         \
    sg_type* matrix;                                                        \
    int32_t num_feat;                                                       \
    int32_t num_vec;                                                        \
    loader->f_load(matrix, num_feat, num_vec);                              \
    set_feature_matrix(matrix, num_feat, num_vec);                          \
}

LOAD(get_bool_matrix, bool)
LOAD(get_char_matrix, char)
LOAD(get_byte_matrix, uint8_t)
LOAD(get_short_matrix, int16_t)
LOAD(get_word_matrix, uint16_t)
LOAD(get_int_matrix, int32_t)
LOAD(get_uint_matrix, uint32_t)
LOAD(get_long_matrix, int64_t)
LOAD(get_ulong_matrix, uint64_t)
LOAD(get_shortreal_matrix, float32_t)
LOAD(get_real_matrix, float64_t)
LOAD(get_longreal_matrix, floatmax_t)
#undef LOAD

#define SAVE(f_write, sg_type)                                              \
template<> inline void CSimpleFeatures<sg_type>::save(CFile* writer)        \
{                                                                           \
    ASSERT(writer);                                                         \
    writer->f_write(feature_matrix, num_features, num_vectors);             \
}

SAVE(set_bool_matrix, bool)
SAVE(set_char_matrix, char)
SAVE(set_byte_matrix, uint8_t)
SAVE(set_short_matrix, int16_t)
SAVE(set_word_matrix, uint16_t)
SAVE(set_int_matrix, int32_t)
SAVE(set_uint_matrix, uint32_t)
SAVE(set_long_matrix, int64_t)
SAVE(set_ulong_matrix, uint64_t)
SAVE(set_shortreal_matrix, float32_t)
SAVE(set_real_matrix, float64_t)
SAVE(set_longreal_matrix, floatmax_t)
#undef SAVE

#endif // DOXYGEN_SHOULD_SKIP_THIS
}
#endif // _SIMPLEFEATURES__H__