SHOGUN  v1.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SimpleFeatures.cpp
Go to the documentation of this file.
3 #include <shogun/io/SGIO.h>
6 
7 #include <string.h>
8 
9 namespace shogun {
10 
11 template<class ST> CSimpleFeatures<ST>::CSimpleFeatures(int32_t size) : CDotFeatures(size)
12 {
13  init();
14 }
15 
16 template<class ST> CSimpleFeatures<ST>::CSimpleFeatures(const CSimpleFeatures & orig) :
17  CDotFeatures(orig)
18 {
20  orig.num_features,
21  orig.num_vectors));
23  m_subset=orig.m_subset->duplicate();
24 }
25 
27  CDotFeatures()
28 {
29  init();
30  set_feature_matrix(matrix);
31 }
32 template<class ST> CSimpleFeatures<ST>::CSimpleFeatures(ST* src, int32_t num_feat, int32_t num_vec) :
33  CDotFeatures()
34 {
35  init();
36  set_feature_matrix(src, num_feat, num_vec);
37 }
38 template<class ST> CSimpleFeatures<ST>::CSimpleFeatures(CFile* loader) :
39  CDotFeatures(loader)
40 {
41  init();
42  load(loader);
43 }
44 template<class ST> CFeatures* CSimpleFeatures<ST>::duplicate() const
45 {
46  return new CSimpleFeatures<ST>(*this);
47 }
48 
49 template<class ST> CSimpleFeatures<ST>::~CSimpleFeatures() { free_features(); }
50 
51 template<class ST> void CSimpleFeatures<ST>::free_features()
52 {
53  remove_subset();
54  free_feature_matrix();
55  SG_UNREF(feature_cache);
56 }
57 
59 {
60  remove_subset();
61  SG_FREE(feature_matrix);
62  feature_matrix = NULL;
63  feature_matrix_num_features = num_features;
64  feature_matrix_num_vectors = num_vectors;
65  num_vectors = 0;
66  num_features = 0;
67 }
68 
69 template<class ST> ST* CSimpleFeatures<ST>::get_feature_vector(int32_t num, int32_t& len, bool& dofree)
70 {
71  /* index conversion for subset, only for array access */
72  int32_t real_num=subset_idx_conversion(num);
73 
74  len = num_features;
75 
76  if (feature_matrix)
77  {
78  dofree = false;
79  return &feature_matrix[real_num * int64_t(num_features)];
80  }
81 
82  ST* feat = NULL;
83  dofree = false;
84 
85  if (feature_cache)
86  {
87  feat = feature_cache->lock_entry(num);
88 
89  if (feat)
90  return feat;
91  else
92  feat = feature_cache->set_entry(real_num);
93  }
94 
95  if (!feat)
96  dofree = true;
97  feat = compute_feature_vector(num, len, feat);
98 
99  if (get_num_preprocessors())
100  {
101  int32_t tmp_len = len;
102  ST* tmp_feat_before = feat;
103  ST* tmp_feat_after = NULL;
104 
105  for (int32_t i = 0; i < get_num_preprocessors(); i++)
106  {
108  (CSimplePreprocessor<ST>*) get_preprocessor(i);
109  // temporary hack
111  SGVector<ST>(tmp_feat_before, tmp_len));
112  tmp_feat_after = applied.vector;
113  SG_UNREF(p);
114 
115  if (i != 0) // delete feature vector, except for the the first one, i.e., feat
116  SG_FREE(tmp_feat_before);
117  tmp_feat_before = tmp_feat_after;
118  }
119 
120  memcpy(feat, tmp_feat_after, sizeof(ST) * tmp_len);
121  SG_FREE(tmp_feat_after);
122 
123  len = tmp_len;
124  }
125  return feat;
126 }
127 
128 template<class ST> void CSimpleFeatures<ST>::set_feature_vector(SGVector<ST> vector, int32_t num)
129 {
130  /* index conversion for subset, only for array access */
131  int32_t real_num=subset_idx_conversion(num);
132 
133  if (num>=get_num_vectors())
134  {
135  SG_ERROR("Index out of bounds (number of vectors %d, you "
136  "requested %d)\n", get_num_vectors(), num);
137  }
138 
139  if (!feature_matrix)
140  SG_ERROR("Requires a in-memory feature matrix\n");
141 
142  if (vector.vlen != num_features)
143  SG_ERROR(
144  "Vector not of length %d (has %d)\n", num_features, vector.vlen);
145 
146  memcpy(&feature_matrix[real_num * int64_t(num_features)], vector.vector,
147  int64_t(num_features) * sizeof(ST));
148 }
149 
151 {
152  /* index conversion for subset, only for array access */
153  int32_t real_num=subset_idx_conversion(num);
154 
155  if (num >= get_num_vectors())
156  {
157  SG_ERROR("Index out of bounds (number of vectors %d, you "
158  "requested %d)\n", get_num_vectors(), real_num);
159  }
160 
161  SGVector<ST> vec;
162  vec.vector = get_feature_vector(num, vec.vlen, vec.do_free);
163  return vec;
164 }
165 
166 template<class ST> void CSimpleFeatures<ST>::free_feature_vector(ST* feat_vec, int32_t num, bool dofree)
167 {
168  if (feature_cache)
169  feature_cache->unlock_entry(subset_idx_conversion(num));
170 
171  if (dofree)
172  SG_FREE(feat_vec);
173 }
174 
175 template<class ST> void CSimpleFeatures<ST>::free_feature_vector(SGVector<ST> vec, int32_t num)
176 {
177  free_feature_vector(vec.vector, num, vec.do_free);
178 }
179 
180 template<class ST> void CSimpleFeatures<ST>::vector_subset(int32_t* idx, int32_t idx_len)
181 {
182  if (m_subset)
183  SG_ERROR("A subset is set, cannot call vector_subset\n");
184 
185  ASSERT(feature_matrix);
186  ASSERT(idx_len<=num_vectors);
187 
188  int32_t num_vec = num_vectors;
189  num_vectors = idx_len;
190 
191  int32_t old_ii = -1;
192 
193  for (int32_t i = 0; i < idx_len; i++)
194  {
195  int32_t ii = idx[i];
196  ASSERT(old_ii<ii);
197 
198  if (ii < 0 || ii >= num_vec)
199  SG_ERROR( "Index out of range: should be 0<%d<%d\n", ii, num_vec);
200 
201  if (i == ii)
202  continue;
203 
204  memcpy(&feature_matrix[int64_t(num_features) * i],
205  &feature_matrix[int64_t(num_features) * ii],
206  num_features * sizeof(ST));
207  old_ii = ii;
208  }
209 }
210 
211 template<class ST> void CSimpleFeatures<ST>::feature_subset(int32_t* idx, int32_t idx_len)
212 {
213  if (m_subset)
214  SG_ERROR("A subset is set, cannot call feature_subset\n");
215 
216  ASSERT(feature_matrix);
217  ASSERT(idx_len<=num_features);
218  int32_t num_feat = num_features;
219  num_features = idx_len;
220 
221  for (int32_t i = 0; i < num_vectors; i++)
222  {
223  ST* src = &feature_matrix[int64_t(num_feat) * i];
224  ST* dst = &feature_matrix[int64_t(num_features) * i];
225 
226  int32_t old_jj = -1;
227  for (int32_t j = 0; j < idx_len; j++)
228  {
229  int32_t jj = idx[j];
230  ASSERT(old_jj<jj);
231  if (jj < 0 || jj >= num_feat)
232  SG_ERROR(
233  "Index out of range: should be 0<%d<%d\n", jj, num_feat);
234 
235  dst[j] = src[jj];
236  old_jj = jj;
237  }
238  }
239 }
240 
241 template<class ST> void CSimpleFeatures<ST>::get_feature_matrix(ST** dst, int32_t* num_feat, int32_t* num_vec)
242 {
243  ASSERT(feature_matrix);
244 
245  int64_t num = int64_t(num_features) * get_num_vectors();
246  *num_feat = num_features;
247  *num_vec = get_num_vectors();
248  *dst = SG_MALLOC(ST, num);
249 
250  /* copying depends on whether a subset is used */
251  if (m_subset)
252  {
253  /* copy vector wise */
254  for (int32_t i = 0; i < *num_vec; ++i)
255  {
256  int32_t real_i = m_subset->subset_idx_conversion(i);
257  memcpy(*dst, &feature_matrix[real_i * int64_t(num_features)],
258  num_features * sizeof(ST));
259  }
260  }
261  else
262  {
263  /* copy complete matrix */
264  memcpy(*dst, feature_matrix, num * sizeof(ST));
265  }
266 }
267 
269 {
270  return SGMatrix<ST>(feature_matrix, num_features, num_vectors);
271 }
272 
274 {
275  SGMatrix<ST> st_feature_matrix(feature_matrix, num_features, num_vectors);
276  remove_subset();
277  SG_UNREF(feature_cache);
278  clean_preprocessors();
279 
280  feature_matrix = NULL;
281  feature_matrix_num_vectors = 0;
282  feature_matrix_num_features = 0;
283  num_features = 0;
284  num_vectors = 0;
285  return st_feature_matrix;
286 }
287 
289 {
290  remove_subset();
291  free_feature_matrix();
292  feature_matrix = matrix.matrix;
293  num_features = matrix.num_rows;
294  num_vectors = matrix.num_cols;
295  feature_matrix_num_vectors = num_vectors;
296  feature_matrix_num_features = num_features;
297 }
298 
299 template<class ST> ST* CSimpleFeatures<ST>::get_feature_matrix(int32_t &num_feat, int32_t &num_vec)
300 {
301  num_feat = num_features;
302  num_vec = num_vectors;
303  return feature_matrix;
304 }
305 
307 {
308  int32_t num_feat;
309  int32_t num_vec;
310  ST* fm = get_transposed(num_feat, num_vec);
311 
312  return new CSimpleFeatures<ST>(fm, num_feat, num_vec);
313 }
314 
315 template<class ST> ST* CSimpleFeatures<ST>::get_transposed(int32_t &num_feat, int32_t &num_vec)
316 {
317  num_feat = get_num_vectors();
318  num_vec = num_features;
319 
320  int32_t old_num_vec=get_num_vectors();
321 
322  ST* fm = SG_MALLOC(ST, int64_t(num_feat) * num_vec);
323 
324  for (int32_t i=0; i<old_num_vec; i++)
325  {
326  SGVector<ST> vec=get_feature_vector(i);
327 
328  for (int32_t j=0; j<vec.vlen; j++)
329  fm[j*int64_t(old_num_vec)+i]=vec.vector[j];
330 
331  free_feature_vector(vec, i);
332  }
333 
334  return fm;
335 }
336 
337 template<class ST> void CSimpleFeatures<ST>::set_feature_matrix(ST* fm, int32_t num_feat, int32_t num_vec)
338 {
339  if (m_subset)
340  SG_ERROR("A subset is set, cannot call set_feature_matrix\n");
341 
342  free_feature_matrix();
343  feature_matrix = fm;
344  feature_matrix_num_features = num_feat;
345  feature_matrix_num_vectors = num_vec;
346 
347  num_features = num_feat;
348  num_vectors = num_vec;
349  initialize_cache();
350 }
351 
353 {
354  if (m_subset)
355  SG_ERROR("A subset is set, cannot call copy_feature_matrix\n");
356 
357  free_feature_matrix();
358  int32_t num_feat = src.num_rows;
359  int32_t num_vec = src.num_cols;
360  feature_matrix = SG_MALLOC(ST, ((int64_t) num_feat) * num_vec);
361  feature_matrix_num_features = num_feat;
362  feature_matrix_num_vectors = num_vec;
363 
364  memcpy(feature_matrix, src.matrix,
365  (sizeof(ST) * ((int64_t) num_feat) * num_vec));
366 
367  num_features = num_feat;
368  num_vectors = num_vec;
369  initialize_cache();
370 }
371 
373 {
374  remove_subset();
375 
376  int32_t num_feat = df->get_dim_feature_space();
377  int32_t num_vec = df->get_num_vectors();
378 
379  ASSERT(num_feat>0 && num_vec>0);
380 
381  free_feature_matrix();
382  feature_matrix = SG_MALLOC(ST, ((int64_t) num_feat) * num_vec);
383  feature_matrix_num_features = num_feat;
384  feature_matrix_num_vectors = num_vec;
385 
386  for (int32_t i = 0; i < num_vec; i++)
387  {
389  ASSERT(num_feat==v.vlen);
390 
391  for (int32_t j = 0; j < num_feat; j++)
392  feature_matrix[i * int64_t(num_feat) + j] = (ST) v.vector[j];
393 
394  v.free_vector();
395  }
396  num_features = num_feat;
397  num_vectors = num_vec;
398 }
399 
400 template<class ST> bool CSimpleFeatures<ST>::apply_preprocessor(bool force_preprocessing)
401 {
402  if (m_subset)
403  SG_ERROR("A subset is set, cannot call apply_preproc\n");
404 
405  SG_DEBUG( "force: %d\n", force_preprocessing);
406 
407  if (feature_matrix && get_num_preprocessors())
408  {
409  for (int32_t i = 0; i < get_num_preprocessors(); i++)
410  {
411  if ((!is_preprocessed(i) || force_preprocessing))
412  {
413  set_preprocessed(i);
415  (CSimplePreprocessor<ST>*) get_preprocessor(i);
416  SG_INFO( "preprocessing using preproc %s\n", p->get_name());
417 
418  if (p->apply_to_feature_matrix(this).matrix == NULL)
419  {
420  SG_UNREF(p);
421  return false;
422  }SG_UNREF(p);
423 
424  }
425  }
426 
427  return true;
428  }
429  else
430  {
431  if (!feature_matrix)
432  SG_ERROR( "no feature matrix\n");
433 
434  if (!get_num_preprocessors())
435  SG_ERROR( "no preprocessors available\n");
436 
437  return false;
438  }
439 }
440 
441 template<class ST> int32_t CSimpleFeatures<ST>::get_size() { return sizeof(ST); }
442 
443 template<class ST> int32_t CSimpleFeatures<ST>::get_num_vectors() const
444 {
445  return m_subset ? m_subset->get_size() : num_vectors;
446 }
447 
448 template<class ST> int32_t CSimpleFeatures<ST>::get_num_features() { return num_features; }
449 
450 template<class ST> void CSimpleFeatures<ST>::set_num_features(int32_t num)
451 {
452  num_features = num;
453  initialize_cache();
454 }
455 
456 template<class ST> void CSimpleFeatures<ST>::set_num_vectors(int32_t num)
457 {
458  if (m_subset)
459  SG_ERROR("A subset is set, cannot call set_num_vectors\n");
460 
461  num_vectors = num;
462  initialize_cache();
463 }
464 
465 template<class ST> void CSimpleFeatures<ST>::initialize_cache()
466 {
467  if (m_subset)
468  SG_ERROR("A subset is set, cannot call initialize_cache\n");
469 
470  if (num_features && num_vectors)
471  {
472  SG_UNREF(feature_cache);
473  feature_cache = new CCache<ST>(get_cache_size(), num_features,
474  num_vectors);
475  SG_REF(feature_cache);
476  }
477 }
478 
480 
481 template<class ST> bool CSimpleFeatures<ST>::reshape(int32_t p_num_features, int32_t p_num_vectors)
482 {
483  if (m_subset)
484  SG_ERROR("A subset is set, cannot call reshape\n");
485 
486  if (p_num_features * p_num_vectors
487  == this->num_features * this->num_vectors)
488  {
489  num_features = p_num_features;
490  num_vectors = p_num_vectors;
491  return true;
492  } else
493  return false;
494 }
495 
496 template<class ST> int32_t CSimpleFeatures<ST>::get_dim_feature_space() const { return num_features; }
497 
498 template<class ST> float64_t CSimpleFeatures<ST>::dot(int32_t vec_idx1, CDotFeatures* df,
499  int32_t vec_idx2)
500 {
501  ASSERT(df);
502  ASSERT(df->get_feature_type() == get_feature_type());
503  ASSERT(df->get_feature_class() == get_feature_class());
505 
506  int32_t len1, len2;
507  bool free1, free2;
508 
509  ST* vec1 = get_feature_vector(vec_idx1, len1, free1);
510  ST* vec2 = sf->get_feature_vector(vec_idx2, len2, free2);
511 
512  float64_t result = CMath::dot(vec1, vec2, len1);
513 
514  free_feature_vector(vec1, vec_idx1, free1);
515  sf->free_feature_vector(vec2, vec_idx2, free2);
516 
517  return result;
518 }
519 
520 template<class ST> void CSimpleFeatures<ST>::add_to_dense_vec(float64_t alpha, int32_t vec_idx1,
521  float64_t* vec2, int32_t vec2_len, bool abs_val)
522 {
523  ASSERT(vec2_len == num_features);
524 
525  int32_t vlen;
526  bool vfree;
527  ST* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
528 
529  ASSERT(vlen == num_features);
530 
531  if (abs_val)
532  {
533  for (int32_t i = 0; i < num_features; i++)
534  vec2[i] += alpha * CMath::abs(vec1[i]);
535  }
536  else
537  {
538  for (int32_t i = 0; i < num_features; i++)
539  vec2[i] += alpha * vec1[i];
540  }
541 
542  free_feature_vector(vec1, vec_idx1, vfree);
543 }
544 
545 template<class ST> int32_t CSimpleFeatures<ST>::get_nnz_features_for_vector(int32_t num)
546 {
547  /* H.Strathmann: TODO fix according to Soerens mail */
548  return num_features;
549 }
550 
552  CStringFeatures<char>* Ref, float64_t gapCost)
553 {
554  return false;
555 }
556 
557 template<class ST> void* CSimpleFeatures<ST>::get_feature_iterator(int32_t vector_index)
558 {
559  if (vector_index>=get_num_vectors())
560  {
561  SG_ERROR("Index out of bounds (number of vectors %d, you "
562  "requested %d)\n", get_num_vectors(), vector_index);
563  }
564 
565  simple_feature_iterator* iterator = SG_MALLOC(simple_feature_iterator, 1);
566  iterator->vec = get_feature_vector(vector_index, iterator->vlen,
567  iterator->vfree);
568  iterator->vidx = vector_index;
569  iterator->index = 0;
570  return iterator;
571 }
572 
573 template<class ST> bool CSimpleFeatures<ST>::get_next_feature(int32_t& index, float64_t& value,
574  void* iterator)
575 {
576  simple_feature_iterator* it = (simple_feature_iterator*) iterator;
577  if (!it || it->index >= it->vlen)
578  return false;
579 
580  index = it->index++;
581  value = (float64_t) it->vec[index];
582 
583  return true;
584 }
585 
586 template<class ST> void CSimpleFeatures<ST>::free_feature_iterator(void* iterator)
587 {
588  if (!iterator)
589  return;
590 
591  simple_feature_iterator* it = (simple_feature_iterator*) iterator;
592  free_feature_vector(it->vec, it->vidx, it->vfree);
593  SG_FREE(it);
594 }
595 
597 {
598  SGMatrix<ST> feature_matrix_copy(num_features, indices.vlen);
599 
600  for (index_t i=0; i<indices.vlen; ++i)
601  {
602  index_t real_idx=subset_idx_conversion(indices.vector[i]);
603  memcpy(&feature_matrix_copy.matrix[i*num_features],
604  &feature_matrix[real_idx*num_features],
605  num_features*sizeof(ST));
606  }
607 
608  return new CSimpleFeatures(feature_matrix_copy);
609 }
610 
611 template<class ST> ST* CSimpleFeatures<ST>::compute_feature_vector(int32_t num, int32_t& len,
612  ST* target)
613 {
615  len = 0;
616  return NULL;
617 }
618 
619 template<class ST> void CSimpleFeatures<ST>::init()
620 {
621  num_vectors = 0;
622  num_features = 0;
623 
624  feature_matrix = NULL;
625  feature_matrix_num_vectors = 0;
626  feature_matrix_num_features = 0;
627 
628  feature_cache = NULL;
629 
630  set_generic<ST>();
631  /* not store number of vectors in subset */
632  m_parameters->add(&num_vectors, "num_vectors",
633  "Number of vectors.");
634  m_parameters->add(&num_features, "num_features", "Number of features.");
635  m_parameters->add_matrix(&feature_matrix, &feature_matrix_num_features,
636  &feature_matrix_num_vectors, "feature_matrix",
637  "Matrix of feature vectors / 1 vector per column.");
638 }
639 
640 #define GET_FEATURE_TYPE(f_type, sg_type) \
641 template<> EFeatureType CSimpleFeatures<sg_type>::get_feature_type() \
642 { \
643  return f_type; \
644 }
645 
648 GET_FEATURE_TYPE(F_BYTE, uint8_t)
649 GET_FEATURE_TYPE(F_BYTE, int8_t)
650 GET_FEATURE_TYPE(F_SHORT, int16_t)
651 GET_FEATURE_TYPE(F_WORD, uint16_t)
652 GET_FEATURE_TYPE(F_INT, int32_t)
653 GET_FEATURE_TYPE(F_UINT, uint32_t)
654 GET_FEATURE_TYPE(F_LONG, int64_t)
655 GET_FEATURE_TYPE(F_ULONG, uint64_t)
659 #undef GET_FEATURE_TYPE
660 
671  float64_t gapCost)
672 {
673  ASSERT(cf);
674  /*num_vectors=cf->get_num_vectors();
675  num_features=Ref->get_num_vectors();
676 
677  int64_t len=((int64_t) num_vectors)*num_features;
678  free_feature_matrix();
679  feature_matrix=SG_MALLOC(float64_t, len);
680  int32_t num_cf_feat=0;
681  int32_t num_cf_vec=0;
682  int32_t num_ref_feat=0;
683  int32_t num_ref_vec=0;
684  char* fm_cf=NULL; //cf->get_feature_matrix(num_cf_feat, num_cf_vec);
685  char* fm_ref=NULL; //Ref->get_feature_matrix(num_ref_feat, num_ref_vec);
686 
687  ASSERT(num_cf_vec==num_vectors);
688  ASSERT(num_ref_vec==num_features);
689 
690  SG_INFO( "computing aligments of %i vectors to %i reference vectors: ", num_cf_vec, num_ref_vec) ;
691  for (int32_t i=0; i< num_ref_vec; i++)
692  {
693  SG_PROGRESS(i, num_ref_vec) ;
694  for (int32_t j=0; j<num_cf_vec; j++)
695  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);
696  } ;
697 
698  SG_INFO( "created %i x %i matrix (0x%p)\n", num_features, num_vectors, feature_matrix) ;*/
699  return true;
700 }
701 
702 template<> float64_t CSimpleFeatures<bool>::dense_dot(int32_t vec_idx1,
703  const float64_t* vec2, int32_t vec2_len)
704 {
705  ASSERT(vec2_len == num_features);
706 
707  int32_t vlen;
708  bool vfree;
709  bool* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
710 
711  ASSERT(vlen == num_features);
712  float64_t result = 0;
713 
714  for (int32_t i = 0; i < num_features; i++)
715  result += vec1[i] ? vec2[i] : 0;
716 
717  free_feature_vector(vec1, vec_idx1, vfree);
718 
719  return result;
720 }
721 
722 template<> float64_t CSimpleFeatures<char>::dense_dot(int32_t vec_idx1,
723  const float64_t* vec2, int32_t vec2_len)
724 {
725  ASSERT(vec2_len == num_features);
726 
727  int32_t vlen;
728  bool vfree;
729  char* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
730 
731  ASSERT(vlen == num_features);
732  float64_t result = 0;
733 
734  for (int32_t i = 0; i < num_features; i++)
735  result += vec1[i] * vec2[i];
736 
737  free_feature_vector(vec1, vec_idx1, vfree);
738 
739  return result;
740 }
741 
742 template<> float64_t CSimpleFeatures<int8_t>::dense_dot(int32_t vec_idx1,
743  const float64_t* vec2, int32_t vec2_len)
744 {
745  ASSERT(vec2_len == num_features);
746 
747  int32_t vlen;
748  bool vfree;
749  int8_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
750 
751  ASSERT(vlen == num_features);
752  float64_t result = 0;
753 
754  for (int32_t i = 0; i < num_features; i++)
755  result += vec1[i] * vec2[i];
756 
757  free_feature_vector(vec1, vec_idx1, vfree);
758 
759  return result;
760 }
761 
763  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
764 {
765  ASSERT(vec2_len == num_features);
766 
767  int32_t vlen;
768  bool vfree;
769  uint8_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
770 
771  ASSERT(vlen == num_features);
772  float64_t result = 0;
773 
774  for (int32_t i = 0; i < num_features; i++)
775  result += vec1[i] * vec2[i];
776 
777  free_feature_vector(vec1, vec_idx1, vfree);
778 
779  return result;
780 }
781 
783  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
784 {
785  ASSERT(vec2_len == num_features);
786 
787  int32_t vlen;
788  bool vfree;
789  int16_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
790 
791  ASSERT(vlen == num_features);
792  float64_t result = 0;
793 
794  for (int32_t i = 0; i < num_features; i++)
795  result += vec1[i] * vec2[i];
796 
797  free_feature_vector(vec1, vec_idx1, vfree);
798 
799  return result;
800 }
801 
803  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
804 {
805  ASSERT(vec2_len == num_features);
806 
807  int32_t vlen;
808  bool vfree;
809  uint16_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
810 
811  ASSERT(vlen == num_features);
812  float64_t result = 0;
813 
814  for (int32_t i = 0; i < num_features; i++)
815  result += vec1[i] * vec2[i];
816 
817  free_feature_vector(vec1, vec_idx1, vfree);
818 
819  return result;
820 }
821 
823  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
824 {
825  ASSERT(vec2_len == num_features);
826 
827  int32_t vlen;
828  bool vfree;
829  int32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
830 
831  ASSERT(vlen == num_features);
832  float64_t result = 0;
833 
834  for (int32_t i = 0; i < num_features; i++)
835  result += vec1[i] * vec2[i];
836 
837  free_feature_vector(vec1, vec_idx1, vfree);
838 
839  return result;
840 }
841 
843  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
844 {
845  ASSERT(vec2_len == num_features);
846 
847  int32_t vlen;
848  bool vfree;
849  uint32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
850 
851  ASSERT(vlen == num_features);
852  float64_t result = 0;
853 
854  for (int32_t i = 0; i < num_features; i++)
855  result += vec1[i] * vec2[i];
856 
857  free_feature_vector(vec1, vec_idx1, vfree);
858 
859  return result;
860 }
861 
863  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
864 {
865  ASSERT(vec2_len == num_features);
866 
867  int32_t vlen;
868  bool vfree;
869  int64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
870 
871  ASSERT(vlen == num_features);
872  float64_t result = 0;
873 
874  for (int32_t i = 0; i < num_features; i++)
875  result += vec1[i] * vec2[i];
876 
877  free_feature_vector(vec1, vec_idx1, vfree);
878 
879  return result;
880 }
881 
883  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
884 {
885  ASSERT(vec2_len == num_features);
886 
887  int32_t vlen;
888  bool vfree;
889  uint64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
890 
891  ASSERT(vlen == num_features);
892  float64_t result = 0;
893 
894  for (int32_t i = 0; i < num_features; i++)
895  result += vec1[i] * vec2[i];
896 
897  free_feature_vector(vec1, vec_idx1, vfree);
898 
899  return result;
900 }
901 
903  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
904 {
905  ASSERT(vec2_len == num_features);
906 
907  int32_t vlen;
908  bool vfree;
909  float32_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
910 
911  ASSERT(vlen == num_features);
912  float64_t result = 0;
913 
914  for (int32_t i = 0; i < num_features; i++)
915  result += vec1[i] * vec2[i];
916 
917  free_feature_vector(vec1, vec_idx1, vfree);
918 
919  return result;
920 }
921 
923  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
924 {
925  ASSERT(vec2_len == num_features);
926 
927  int32_t vlen;
928  bool vfree;
929  float64_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
930 
931  ASSERT(vlen == num_features);
932  float64_t result = CMath::dot(vec1, vec2, num_features);
933 
934  free_feature_vector(vec1, vec_idx1, vfree);
935 
936  return result;
937 }
938 
940  int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len)
941 {
942  ASSERT(vec2_len == num_features);
943 
944  int32_t vlen;
945  bool vfree;
946  floatmax_t* vec1 = get_feature_vector(vec_idx1, vlen, vfree);
947 
948  ASSERT(vlen == num_features);
949  float64_t result = 0;
950 
951  for (int32_t i = 0; i < num_features; i++)
952  result += vec1[i] * vec2[i];
953 
954  free_feature_vector(vec1, vec_idx1, vfree);
955 
956  return result;
957 }
958 
959 #define LOAD(f_load, sg_type) \
960 template<> void CSimpleFeatures<sg_type>::load(CFile* loader) \
961 { \
962  SG_SET_LOCALE_C; \
963  ASSERT(loader); \
964  sg_type* matrix; \
965  int32_t num_feat; \
966  int32_t num_vec; \
967  loader->f_load(matrix, num_feat, num_vec); \
968  set_feature_matrix(matrix, num_feat, num_vec); \
969  SG_RESET_LOCALE; \
970 }
971 
972 LOAD(get_matrix, bool)
973 LOAD(get_matrix, char)
974 LOAD(get_int8_matrix, int8_t)
975 LOAD(get_matrix, uint8_t)
976 LOAD(get_matrix, int16_t)
977 LOAD(get_matrix, uint16_t)
978 LOAD(get_matrix, int32_t)
979 LOAD(get_uint_matrix, uint32_t)
980 LOAD(get_long_matrix, int64_t)
981 LOAD(get_ulong_matrix, uint64_t)
982 LOAD(get_matrix, float32_t)
983 LOAD(get_matrix, float64_t)
984 LOAD(get_longreal_matrix, floatmax_t)
985 #undef LOAD
986 
987 #define SAVE(f_write, sg_type) \
988 template<> void CSimpleFeatures<sg_type>::save(CFile* writer) \
989 { \
990  SG_SET_LOCALE_C; \
991  ASSERT(writer); \
992  writer->f_write(feature_matrix, num_features, num_vectors); \
993  SG_RESET_LOCALE; \
994 }
995 
996 SAVE(set_matrix, bool)
997 SAVE(set_matrix, char)
998 SAVE(set_int8_matrix, int8_t)
999 SAVE(set_matrix, uint8_t)
1000 SAVE(set_matrix, int16_t)
1001 SAVE(set_matrix, uint16_t)
1002 SAVE(set_matrix, int32_t)
1003 SAVE(set_uint_matrix, uint32_t)
1004 SAVE(set_long_matrix, int64_t)
1005 SAVE(set_ulong_matrix, uint64_t)
1006 SAVE(set_matrix, float32_t)
1007 SAVE(set_matrix, float64_t)
1008 SAVE(set_longreal_matrix, floatmax_t)
1009 #undef SAVE
1010 
1011 template class CSimpleFeatures<bool>;
1012 template class CSimpleFeatures<char>;
1013 template class CSimpleFeatures<int8_t>;
1014 template class CSimpleFeatures<uint8_t>;
1015 template class CSimpleFeatures<int16_t>;
1016 template class CSimpleFeatures<uint16_t>;
1017 template class CSimpleFeatures<int32_t>;
1018 template class CSimpleFeatures<uint32_t>;
1019 template class CSimpleFeatures<int64_t>;
1020 template class CSimpleFeatures<uint64_t>;
1021 template class CSimpleFeatures<float32_t>;
1022 template class CSimpleFeatures<float64_t>;
1023 template class CSimpleFeatures<floatmax_t>;
1024 }

SHOGUN Machine Learning Toolbox - Documentation