SimpleFeatures.h

Go to the documentation of this file.
00001 /*
00002  * This program is free software; you can redistribute it and/or modify
00003  * it under the terms of the GNU General Public License as published by
00004  * the Free Software Foundation; either version 3 of the License, or
00005  * (at your option) any later version.
00006  *
00007  * Written (W) 1999-2010 Soeren Sonnenburg
00008  * Written (W) 1999-2008 Gunnar Raetsch
00009  * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
00010  * Copyright (C) 2010 Berlin Institute of Technology
00011  */
00012 
00013 #ifndef _SIMPLEFEATURES__H__
00014 #define _SIMPLEFEATURES__H__
00015 
00016 #include "lib/common.h"
00017 #include "lib/Mathematics.h"
00018 #include "lib/io.h"
00019 #include "lib/Cache.h"
00020 #include "lib/File.h"
00021 #include "preproc/SimplePreProc.h"
00022 #include "features/DotFeatures.h"
00023 #include "features/StringFeatures.h"
00024 #include "base/Parameter.h"
00025 
00026 #include <string.h>
00027 
00028 namespace shogun
00029 {
00030 template <class ST> class CStringFeatures;
00031 template <class ST> class CSimpleFeatures;
00032 template <class ST> class CSimplePreProc;
00033 class CDotFeatures;
00034 
00064 template <class ST> class CSimpleFeatures: public CDotFeatures
00065 {
00066     public:
00071         CSimpleFeatures(int32_t size=0)
00072             : CDotFeatures(size)
00073         {
00074             init();
00075         }
00076 
00078         CSimpleFeatures(const CSimpleFeatures & orig)
00079         : CDotFeatures(orig)
00080         {
00081             copy_feature_matrix(orig.feature_matrix,
00082                     orig.num_features, orig.num_vectors);
00083             initialize_cache();
00084         }
00085 
00092         CSimpleFeatures(ST* src, int32_t num_feat, int32_t num_vec)
00093         : CDotFeatures()
00094         {
00095             init();
00096             copy_feature_matrix(src, num_feat, num_vec);
00097         }
00098 
00103         CSimpleFeatures(CFile* loader)
00104         : CDotFeatures(loader)
00105         {
00106             init();
00107             load(loader);
00108         }
00109 
00114         virtual CFeatures* duplicate() const
00115         {
00116             return new CSimpleFeatures<ST>(*this);
00117         }
00118 
00119         virtual ~CSimpleFeatures()
00120         {
00121             free_features();
00122         }
00123 
00127         void free_feature_matrix()
00128         {
00129             delete[] feature_matrix;
00130             feature_matrix = NULL;
00131             feature_matrix_num_features=num_features;
00132             feature_matrix_num_vectors=num_vectors;
00133             num_vectors=0;
00134             num_features=0;
00135         }
00136 
00140         void free_features()
00141         {
00142             free_feature_matrix();
00143             SG_UNREF(feature_cache);
00144         }
00145 
00156         ST* get_feature_vector(int32_t num, int32_t& len, bool& dofree)
00157         {
00158             len=num_features;
00159 
00160             if (feature_matrix)
00161             {
00162                 dofree=false;
00163                 return &feature_matrix[num*int64_t(num_features)];
00164             } 
00165             else
00166             {
00167                 ST* feat=NULL;
00168                 dofree=false;
00169 
00170                 if (feature_cache)
00171                 {
00172                     feat=feature_cache->lock_entry(num);
00173 
00174                     if (feat)
00175                         return feat;
00176                     else
00177                     {
00178                         feat=feature_cache->set_entry(num);
00179                     }
00180                 }
00181 
00182                 if (!feat)
00183                     dofree=true;
00184                 feat=compute_feature_vector(num, len, feat);
00185 
00186 
00187                 if (get_num_preproc())
00188                 {
00189                     int32_t tmp_len=len;
00190                     ST* tmp_feat_before = feat;
00191                     ST* tmp_feat_after = NULL;
00192 
00193                     for (int32_t i=0; i<get_num_preproc(); i++)
00194                     {
00195                         CSimplePreProc<ST>* p = (CSimplePreProc<ST>*) get_preproc(i);
00196                         tmp_feat_after=p->apply_to_feature_vector(tmp_feat_before, tmp_len);
00197                         SG_UNREF(p);
00198 
00199                         if (i!=0)   // delete feature vector, except for the the first one, i.e., feat
00200                             delete[] tmp_feat_before;
00201                         tmp_feat_before=tmp_feat_after;
00202                     }
00203 
00204                     memcpy(feat, tmp_feat_after, sizeof(ST)*tmp_len);
00205                     delete[] tmp_feat_after;
00206 
00207                     len=tmp_len ;
00208                 }
00209                 return feat ;
00210             }
00211         }
00212 
00221         void set_feature_vector(ST* src, int32_t len, int32_t num)
00222         {
00223             if (num>=num_vectors)
00224             {
00225                 SG_ERROR("Index out of bounds (number of vectors %d, you "
00226                         "requested %d)\n", num_vectors, num);
00227             }
00228 
00229             if (!feature_matrix)
00230                 SG_ERROR("Requires a in-memory feature matrix\n");
00231 
00232             if (len != num_features)
00233                 SG_ERROR("Vector not of length %d (has %d)\n", num_features, len);
00234 
00235             memcpy(&feature_matrix[num*int64_t(num_features)], src, int64_t(num_features)*sizeof(ST));
00236         }
00237 
00244         void get_feature_vector(ST** dst, int32_t* len, int32_t num)
00245         {
00246             if (num>=num_vectors)
00247             {
00248                 SG_ERROR("Index out of bounds (number of vectors %d, you "
00249                         "requested %d)\n", num_vectors, num);
00250             }
00251 
00252             int32_t vlen=0;
00253             bool free_vec;
00254 
00255             ST* vec= get_feature_vector(num, vlen, free_vec);
00256 
00257             *len=vlen;
00258             *dst=(ST*) malloc(vlen*sizeof(ST));
00259             memcpy(*dst, vec, vlen*sizeof(ST));
00260 
00261             free_feature_vector(vec, num, free_vec);
00262         }
00263 
00270         void free_feature_vector(ST* feat_vec, int32_t num, bool dofree)
00271         {
00272             if (feature_cache)
00273                 feature_cache->unlock_entry(num);
00274 
00275             if (dofree)
00276                 delete[] feat_vec ;
00277         }
00278 
00286         void get_feature_matrix(ST** dst, int32_t* num_feat, int32_t* num_vec)
00287         {
00288             ASSERT(feature_matrix);
00289 
00290             int64_t num=int64_t(num_features)*num_vectors;
00291             *num_feat=num_features;
00292             *num_vec=num_vectors;
00293             *dst=(ST*) malloc(sizeof(ST)*num);
00294             if (!*dst)
00295                 SG_ERROR("Allocating %ld bytes failes\n", sizeof(ST)*num);
00296             memcpy(*dst, feature_matrix, num * sizeof(ST));
00297         }
00298 
00306         ST* get_feature_matrix(int32_t &num_feat, int32_t &num_vec)
00307         {
00308             num_feat=num_features;
00309             num_vec=num_vectors;
00310             return feature_matrix;
00311         }
00312 
00317         CSimpleFeatures<ST>* get_transposed()
00318         {
00319             int32_t num_feat;
00320             int32_t num_vec;
00321             ST* fm=get_transposed(num_feat, num_vec);
00322 
00323             return new CSimpleFeatures<ST>(fm, num_feat, num_vec);
00324         }
00325 
00335         ST* get_transposed(int32_t &num_feat, int32_t &num_vec)
00336         {
00337             num_feat=num_vectors;
00338             num_vec=num_features;
00339 
00340             ST* fm=new ST[int64_t(num_feat)*num_vec];
00341 
00342             for (int32_t i=0; i<num_vectors; i++)
00343             {
00344                 int32_t vlen;
00345                 bool vfree;
00346                 ST* vec=get_feature_vector(i, vlen, vfree);
00347 
00348                 for (int32_t j=0; j<vlen; j++)
00349                     fm[j*int64_t(num_vectors)+i]=vec[j];
00350 
00351                 free_feature_vector(vec, i, vfree);
00352             }
00353 
00354             return fm;
00355         }
00356 
00367         virtual void set_feature_matrix(ST* fm, int32_t num_feat, int32_t num_vec)
00368         {
00369             free_feature_matrix();
00370             feature_matrix=fm;
00371             feature_matrix_num_features=num_feat;
00372             feature_matrix_num_vectors=num_vec;
00373 
00374             num_features=num_feat;
00375             num_vectors=num_vec;
00376             initialize_cache();
00377         }
00378 
00388         virtual void copy_feature_matrix(ST* src, int32_t num_feat, int32_t num_vec)
00389         {
00390             free_feature_matrix();
00391             feature_matrix=new ST[((int64_t) num_feat)*num_vec];
00392             feature_matrix_num_features=num_feat;
00393             feature_matrix_num_vectors=num_vec;
00394 
00395             memcpy(feature_matrix, src, (sizeof(ST)*((int64_t) num_feat)*num_vec));
00396 
00397             num_features=num_feat;
00398             num_vectors=num_vec;
00399             initialize_cache();
00400         }
00401 
00406         void obtain_from_dot(CDotFeatures* df)
00407         {
00408             int32_t num_feat=df->get_dim_feature_space();
00409             int32_t num_vec=df->get_num_vectors();
00410 
00411             ASSERT(num_feat>0 && num_vec>0);
00412 
00413             free_feature_matrix();
00414             feature_matrix=new ST[((int64_t) num_feat)*num_vec];
00415             feature_matrix_num_features=num_feat;
00416             feature_matrix_num_vectors=num_vec;
00417 
00418             for (int32_t i=0; i<num_vec; i++)
00419             {
00420                 float64_t* dst;
00421                 int32_t len;
00422                 df->get_feature_vector(&dst, &len, i);
00423                 ASSERT(num_feat==len);
00424 
00425                 for (int32_t j=0; j<num_feat; j++)
00426                     feature_matrix[i*int64_t(num_feat)+j]=(ST) dst[j];
00427 
00428                 delete[] dst;
00429             }
00430             num_features=num_feat;
00431             num_vectors=num_vec;
00432         }
00433 
00439         virtual bool apply_preproc(bool force_preprocessing=false)
00440         {
00441             SG_DEBUG( "force: %d\n", force_preprocessing);
00442 
00443             if ( feature_matrix && get_num_preproc())
00444             {
00445 
00446                 for (int32_t i=0; i<get_num_preproc(); i++)
00447                 { 
00448                     if ( (!is_preprocessed(i) || force_preprocessing) )
00449                     {
00450                         set_preprocessed(i);
00451                         CSimplePreProc<ST>* p = (CSimplePreProc<ST>*) get_preproc(i);
00452                         SG_INFO( "preprocessing using preproc %s\n", p->get_name());
00453                         if (p->apply_to_feature_matrix(this) == NULL)
00454                         {
00455                             SG_UNREF(p);
00456                             return false;
00457                         }
00458                         SG_UNREF(p);
00459                     }
00460                 }
00461                 return true;
00462             }
00463             else
00464             {
00465                 if (!feature_matrix)
00466                     SG_ERROR( "no feature matrix\n");
00467 
00468                 if (!get_num_preproc())
00469                     SG_ERROR( "no preprocessors available\n");
00470 
00471                 return false;
00472             }
00473         }
00474 
00479         virtual int32_t get_size() { return sizeof(ST); }
00480 
00481 
00486         virtual inline int32_t  get_num_vectors() { return num_vectors; }
00487 
00492         inline int32_t  get_num_features() { return num_features; }
00493 
00498         inline void set_num_features(int32_t num)
00499         { 
00500             num_features= num;
00501             initialize_cache();
00502         }
00503 
00508         inline void set_num_vectors(int32_t num)
00509         {
00510             num_vectors= num;
00511             initialize_cache();
00512         }
00513 
00514         /* Initialize cache */
00515         inline void initialize_cache()
00516         {
00517             if (num_features && num_vectors)
00518             {
00519                 SG_UNREF(feature_cache);
00520                 feature_cache= new CCache<ST>(get_cache_size(), num_features, num_vectors);
00521                 SG_REF(feature_cache);
00522             }
00523         }
00524 
00529         inline virtual EFeatureClass get_feature_class() { return C_SIMPLE; }
00530 
00535         inline virtual EFeatureType get_feature_type();
00536 
00543         virtual bool reshape(int32_t p_num_features, int32_t p_num_vectors)
00544         {
00545             if (p_num_features*p_num_vectors == this->num_features * this->num_vectors)
00546             {
00547                 this->num_features=p_num_features;
00548                 this->num_vectors=p_num_vectors;
00549                 return true;
00550             }
00551             else
00552                 return false;
00553         }
00554 
00562         virtual int32_t get_dim_feature_space()
00563         {
00564             return num_features;
00565         }
00566 
00574         virtual float64_t dot(int32_t vec_idx1, CDotFeatures* df, int32_t vec_idx2)
00575         {
00576             ASSERT(df);
00577             ASSERT(df->get_feature_type() == get_feature_type());
00578             ASSERT(df->get_feature_class() == get_feature_class());
00579             CSimpleFeatures<ST>* sf=(CSimpleFeatures<ST>*) df;
00580 
00581             int32_t len1, len2;
00582             bool free1, free2;
00583 
00584             ST* vec1= get_feature_vector(vec_idx1, len1, free1);
00585             ST* vec2= sf->get_feature_vector(vec_idx2, len2, free2);
00586 
00587             float64_t result=CMath::dot(vec1, vec2, len1);
00588 
00589             free_feature_vector(vec1, vec_idx1, free1);
00590             sf->free_feature_vector(vec2, vec_idx2, free2);
00591 
00592             return result;
00593         }
00594 
00601         virtual float64_t dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len);
00602 
00611         virtual void add_to_dense_vec(float64_t alpha, int32_t vec_idx1, float64_t* vec2, int32_t vec2_len, bool abs_val=false)
00612         {
00613             ASSERT(vec2_len == num_features);
00614 
00615             int32_t vlen;
00616             bool vfree;
00617             ST* vec1=get_feature_vector(vec_idx1, vlen, vfree);
00618 
00619             ASSERT(vlen == num_features);
00620 
00621             if (abs_val)
00622             {
00623                 for (int32_t i=0; i<num_features; i++)
00624                     vec2[i]+=alpha*CMath::abs(vec1[i]);
00625             }
00626             else
00627             {
00628                 for (int32_t i=0; i<num_features; i++)
00629                     vec2[i]+=alpha*vec1[i];
00630             }
00631 
00632             free_feature_vector(vec1, vec_idx1, vfree);
00633         }
00634 
00640         virtual inline int32_t get_nnz_features_for_vector(int32_t num)
00641         {
00642             return num_features;
00643         }
00644 
00652         virtual inline bool Align_char_features(
00653             CStringFeatures<char>* cf, CStringFeatures<char>* Ref, float64_t gapCost)
00654         {
00655             return false;
00656         }
00657 
00662         virtual inline void load(CFile* loader);
00663 
00668         virtual inline void save(CFile* saver);
00669 
00671         struct simple_feature_iterator
00672         {
00674             ST* vec;
00676             int32_t vidx;
00678             int32_t vlen;
00680             bool vfree;
00681 
00683             int32_t index;
00684         };
00685 
00695         virtual void* get_feature_iterator(int32_t vector_index)
00696         {
00697             if (vector_index>=num_vectors)
00698             {
00699                 SG_ERROR("Index out of bounds (number of vectors %d, you "
00700                         "requested %d)\n", num_vectors, vector_index);
00701             }
00702 
00703             simple_feature_iterator* iterator=new simple_feature_iterator[1];
00704             iterator->vec= get_feature_vector(vector_index, iterator->vlen, iterator->vfree);
00705             iterator->vidx=vector_index;
00706             iterator->index=0;
00707             return iterator;
00708         }
00709 
00720         virtual bool get_next_feature(int32_t& index, float64_t& value, void* iterator)
00721         {
00722             simple_feature_iterator* it=(simple_feature_iterator*) iterator;
00723             if (!it || it->index>=it->vlen)
00724                 return false;
00725 
00726             index=it->index++;
00727             value = (float64_t) it->vec[index];
00728 
00729             return true;
00730         }
00731 
00737         virtual void free_feature_iterator(void* iterator)
00738         {
00739             if (!iterator)
00740                 return;
00741 
00742             simple_feature_iterator* it=(simple_feature_iterator*) iterator;
00743             free_feature_vector(it->vec, it->vidx, it->vfree);
00744             delete[] it;
00745         }
00746 
00748         inline virtual const char* get_name() const { return "SimpleFeatures"; }
00749 
00750     protected:
00762         virtual ST* compute_feature_vector(int32_t num, int32_t& len, ST* target=NULL)
00763         {
00764             len=0;
00765             return NULL;
00766         }
00767 
00768     private:
00769         void init()
00770         {
00771             num_vectors=0;
00772             num_features=0;
00773 
00774             feature_matrix=NULL;
00775             feature_matrix_num_vectors=0;
00776             feature_matrix_num_features=0;
00777 
00778             feature_cache=NULL;
00779 
00780             set_generic<ST>();
00781             m_parameters->add(&num_vectors,
00782                         "num_vectors", "Number of vectors.");
00783             m_parameters->add(&num_features,
00784                         "num_features", "Number of features.");
00785             m_parameters->add_matrix(&feature_matrix,
00786                     &feature_matrix_num_features, &feature_matrix_num_vectors,
00787                     "feature_matrix", "Matrix of feature vectors / 1 vector per column.");
00788         }
00789 
00790     protected:
00792         int32_t num_vectors;
00793 
00795         int32_t num_features;
00796 
00801         ST* feature_matrix;
00802         int32_t feature_matrix_num_vectors;
00803         int32_t feature_matrix_num_features;
00804 
00806         CCache<ST>* feature_cache;
00807 };
00808 
00809 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00810 
00811 #define GET_FEATURE_TYPE(f_type, sg_type)   \
00812 template<> inline EFeatureType CSimpleFeatures<sg_type>::get_feature_type() \
00813 {                                                                           \
00814     return f_type;                                                          \
00815 }
00816 
00817 GET_FEATURE_TYPE(F_BOOL, bool)
00818 GET_FEATURE_TYPE(F_CHAR, char)
00819 GET_FEATURE_TYPE(F_BYTE, uint8_t)
00820 GET_FEATURE_TYPE(F_BYTE, int8_t)
00821 GET_FEATURE_TYPE(F_SHORT, int16_t)
00822 GET_FEATURE_TYPE(F_WORD, uint16_t)
00823 GET_FEATURE_TYPE(F_INT, int32_t)
00824 GET_FEATURE_TYPE(F_UINT, uint32_t)
00825 GET_FEATURE_TYPE(F_LONG, int64_t)
00826 GET_FEATURE_TYPE(F_ULONG, uint64_t)
00827 GET_FEATURE_TYPE(F_SHORTREAL, float32_t)
00828 GET_FEATURE_TYPE(F_DREAL, float64_t)
00829 GET_FEATURE_TYPE(F_LONGREAL, floatmax_t)
00830 #undef GET_FEATURE_TYPE
00831 
00840 template<> inline bool CSimpleFeatures<float64_t>::Align_char_features(
00841         CStringFeatures<char>* cf, CStringFeatures<char>* Ref, float64_t gapCost)
00842 {
00843     ASSERT(cf);
00844     /*num_vectors=cf->get_num_vectors();
00845     num_features=Ref->get_num_vectors();
00846 
00847     int64_t len=((int64_t) num_vectors)*num_features;
00848     free_feature_matrix();
00849     feature_matrix=new float64_t[len];
00850     int32_t num_cf_feat=0;
00851     int32_t num_cf_vec=0;
00852     int32_t num_ref_feat=0;
00853     int32_t num_ref_vec=0;
00854     char* fm_cf=NULL; //cf->get_feature_matrix(num_cf_feat, num_cf_vec);
00855     char* fm_ref=NULL; //Ref->get_feature_matrix(num_ref_feat, num_ref_vec);
00856 
00857     ASSERT(num_cf_vec==num_vectors);
00858     ASSERT(num_ref_vec==num_features);
00859 
00860     SG_INFO( "computing aligments of %i vectors to %i reference vectors: ", num_cf_vec, num_ref_vec) ;
00861     for (int32_t i=0; i< num_ref_vec; i++)
00862     {
00863         SG_PROGRESS(i, num_ref_vec) ;
00864         for (int32_t j=0; j<num_cf_vec; j++)
00865             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);
00866     } ;
00867 
00868     SG_INFO( "created %i x %i matrix (0x%p)\n", num_features, num_vectors, feature_matrix) ;*/
00869     return true;
00870 }
00871 
00872 template<> inline float64_t CSimpleFeatures<bool>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
00873 {
00874     ASSERT(vec2_len == num_features);
00875 
00876     int32_t vlen;
00877     bool vfree;
00878     bool* vec1= get_feature_vector(vec_idx1, vlen, vfree);
00879 
00880     ASSERT(vlen == num_features);
00881     float64_t result=0;
00882 
00883     for (int32_t i=0 ; i<num_features; i++)
00884         result+=vec1[i] ? vec2[i] : 0;
00885 
00886     free_feature_vector(vec1, vec_idx1, vfree);
00887 
00888     return result;
00889 }
00890 
00891 
00892 template<> inline float64_t CSimpleFeatures<char>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
00893 {
00894     ASSERT(vec2_len == num_features);
00895 
00896     int32_t vlen;
00897     bool vfree;
00898     char* vec1= get_feature_vector(vec_idx1, vlen, vfree);
00899 
00900     ASSERT(vlen == num_features);
00901     float64_t result=0;
00902 
00903     for (int32_t i=0 ; i<num_features; i++)
00904         result+=vec1[i]*vec2[i];
00905 
00906     free_feature_vector(vec1, vec_idx1, vfree);
00907 
00908     return result;
00909 }
00910 
00911 template<> inline float64_t CSimpleFeatures<int8_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
00912 {
00913     ASSERT(vec2_len == num_features);
00914 
00915     int32_t vlen;
00916     bool vfree;
00917     int8_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
00918 
00919     ASSERT(vlen == num_features);
00920     float64_t result=0;
00921 
00922     for (int32_t i=0 ; i<num_features; i++)
00923         result+=vec1[i]*vec2[i];
00924 
00925     free_feature_vector(vec1, vec_idx1, vfree);
00926 
00927     return result;
00928 }
00929 
00930 template<> inline float64_t CSimpleFeatures<uint8_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
00931 {
00932     ASSERT(vec2_len == num_features);
00933 
00934     int32_t vlen;
00935     bool vfree;
00936     uint8_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
00937 
00938     ASSERT(vlen == num_features);
00939     float64_t result=0;
00940 
00941     for (int32_t i=0 ; i<num_features; i++)
00942         result+=vec1[i]*vec2[i];
00943 
00944     free_feature_vector(vec1, vec_idx1, vfree);
00945 
00946     return result;
00947 }
00948 
00949 template<> inline float64_t CSimpleFeatures<int16_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
00950 {
00951     ASSERT(vec2_len == num_features);
00952 
00953     int32_t vlen;
00954     bool vfree;
00955     int16_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
00956 
00957     ASSERT(vlen == num_features);
00958     float64_t result=0;
00959 
00960     for (int32_t i=0 ; i<num_features; i++)
00961         result+=vec1[i]*vec2[i];
00962 
00963     free_feature_vector(vec1, vec_idx1, vfree);
00964 
00965     return result;
00966 }
00967 
00968 
00969 template<> inline float64_t CSimpleFeatures<uint16_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
00970 {
00971     ASSERT(vec2_len == num_features);
00972 
00973     int32_t vlen;
00974     bool vfree;
00975     uint16_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
00976 
00977     ASSERT(vlen == num_features);
00978     float64_t result=0;
00979 
00980     for (int32_t i=0 ; i<num_features; i++)
00981         result+=vec1[i]*vec2[i];
00982 
00983     free_feature_vector(vec1, vec_idx1, vfree);
00984 
00985     return result;
00986 }
00987 
00988 template<> inline float64_t CSimpleFeatures<int32_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
00989 {
00990     ASSERT(vec2_len == num_features);
00991 
00992     int32_t vlen;
00993     bool vfree;
00994     int32_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
00995 
00996     ASSERT(vlen == num_features);
00997     float64_t result=0;
00998 
00999     for (int32_t i=0 ; i<num_features; i++)
01000         result+=vec1[i]*vec2[i];
01001 
01002     free_feature_vector(vec1, vec_idx1, vfree);
01003 
01004     return result;
01005 }
01006 
01007 template<> inline float64_t CSimpleFeatures<uint32_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
01008 {
01009     ASSERT(vec2_len == num_features);
01010 
01011     int32_t vlen;
01012     bool vfree;
01013     uint32_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
01014 
01015     ASSERT(vlen == num_features);
01016     float64_t result=0;
01017 
01018     for (int32_t i=0 ; i<num_features; i++)
01019         result+=vec1[i]*vec2[i];
01020 
01021     free_feature_vector(vec1, vec_idx1, vfree);
01022 
01023     return result;
01024 }
01025 
01026 template<> inline float64_t CSimpleFeatures<int64_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
01027 {
01028     ASSERT(vec2_len == num_features);
01029 
01030     int32_t vlen;
01031     bool vfree;
01032     int64_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
01033 
01034     ASSERT(vlen == num_features);
01035     float64_t result=0;
01036 
01037     for (int32_t i=0 ; i<num_features; i++)
01038         result+=vec1[i]*vec2[i];
01039 
01040     free_feature_vector(vec1, vec_idx1, vfree);
01041 
01042     return result;
01043 }
01044 
01045 template<> inline float64_t CSimpleFeatures<uint64_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
01046 {
01047     ASSERT(vec2_len == num_features);
01048 
01049     int32_t vlen;
01050     bool vfree;
01051     uint64_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
01052 
01053     ASSERT(vlen == num_features);
01054     float64_t result=0;
01055 
01056     for (int32_t i=0 ; i<num_features; i++)
01057         result+=vec1[i]*vec2[i];
01058 
01059     free_feature_vector(vec1, vec_idx1, vfree);
01060 
01061     return result;
01062 }
01063 
01064 template<> inline float64_t CSimpleFeatures<float32_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
01065 {
01066     ASSERT(vec2_len == num_features);
01067 
01068     int32_t vlen;
01069     bool vfree;
01070     float32_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
01071 
01072     ASSERT(vlen == num_features);
01073     float64_t result=0;
01074 
01075     for (int32_t i=0 ; i<num_features; i++)
01076         result+=vec1[i]*vec2[i];
01077 
01078     free_feature_vector(vec1, vec_idx1, vfree);
01079 
01080     return result;
01081 }
01082 
01083 template<> inline float64_t CSimpleFeatures<float64_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
01084 {
01085     ASSERT(vec2_len == num_features);
01086 
01087     int32_t vlen;
01088     bool vfree;
01089     float64_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
01090 
01091     ASSERT(vlen == num_features);
01092     float64_t result=CMath::dot(vec1, vec2, num_features);
01093 
01094     free_feature_vector(vec1, vec_idx1, vfree);
01095 
01096     return result;
01097 }
01098 
01099 template<> inline float64_t CSimpleFeatures<floatmax_t>:: dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
01100 {
01101     ASSERT(vec2_len == num_features);
01102 
01103     int32_t vlen;
01104     bool vfree;
01105     floatmax_t* vec1= get_feature_vector(vec_idx1, vlen, vfree);
01106 
01107     ASSERT(vlen == num_features);
01108     float64_t result=0;
01109 
01110     for (int32_t i=0 ; i<num_features; i++)
01111         result+=vec1[i]*vec2[i];
01112 
01113     free_feature_vector(vec1, vec_idx1, vfree);
01114 
01115     return result;
01116 }
01117 
01118 #define LOAD(f_load, sg_type)                                               \
01119 template<> inline void CSimpleFeatures<sg_type>::load(CFile* loader)        \
01120 {                                                                           \
01121     SG_SET_LOCALE_C;                                                    \
01122     ASSERT(loader);                                                         \
01123     sg_type* matrix;                                                        \
01124     int32_t num_feat;                                                       \
01125     int32_t num_vec;                                                        \
01126     loader->f_load(matrix, num_feat, num_vec);                              \
01127     set_feature_matrix(matrix, num_feat, num_vec);                          \
01128     SG_RESET_LOCALE;                                                    \
01129 }
01130 
01131 LOAD(get_bool_matrix, bool)
01132 LOAD(get_char_matrix, char)
01133 LOAD(get_int8_matrix, int8_t)
01134 LOAD(get_byte_matrix, uint8_t)
01135 LOAD(get_short_matrix, int16_t)
01136 LOAD(get_word_matrix, uint16_t)
01137 LOAD(get_int_matrix, int32_t)
01138 LOAD(get_uint_matrix, uint32_t)
01139 LOAD(get_long_matrix, int64_t)
01140 LOAD(get_ulong_matrix, uint64_t)
01141 LOAD(get_shortreal_matrix, float32_t)
01142 LOAD(get_real_matrix, float64_t)
01143 LOAD(get_longreal_matrix, floatmax_t)
01144 #undef LOAD
01145 
01146 #define SAVE(f_write, sg_type)                                              \
01147 template<> inline void CSimpleFeatures<sg_type>::save(CFile* writer)        \
01148 {                                                                           \
01149     SG_SET_LOCALE_C;                                                    \
01150     ASSERT(writer);                                                         \
01151     writer->f_write(feature_matrix, num_features, num_vectors);             \
01152     SG_RESET_LOCALE;                                                    \
01153 }
01154 
01155 SAVE(set_bool_matrix, bool)
01156 SAVE(set_char_matrix, char)
01157 SAVE(set_int8_matrix, int8_t)
01158 SAVE(set_byte_matrix, uint8_t)
01159 SAVE(set_short_matrix, int16_t)
01160 SAVE(set_word_matrix, uint16_t)
01161 SAVE(set_int_matrix, int32_t)
01162 SAVE(set_uint_matrix, uint32_t)
01163 SAVE(set_long_matrix, int64_t)
01164 SAVE(set_ulong_matrix, uint64_t)
01165 SAVE(set_shortreal_matrix, float32_t)
01166 SAVE(set_real_matrix, float64_t)
01167 SAVE(set_longreal_matrix, floatmax_t)
01168 #undef SAVE
01169 
01170 #endif // DOXYGEN_SHOULD_SKIP_THIS
01171 }
01172 #endif // _SIMPLEFEATURES__H__
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation