SHOGUN  3.2.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SGVector.h
Go to the documentation of this file.
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 3 of the License, or
5  * (at your option) any later version.
6  *
7  * Written (W) 2011-2013 Heiko Strathmann
8  * Written (W) 2013 Soumyajit De
9  * Written (W) 2012 Fernando Jose Iglesias Garcia
10  * Written (W) 2010,2012 Soeren Sonnenburg
11  * Copyright (C) 2010 Berlin Institute of Technology
12  * Copyright (C) 2012 Soeren Sonnenburg
13  */
14 #ifndef __SGVECTOR_H__
15 #define __SGVECTOR_H__
16 
17 #include <shogun/lib/config.h>
18 
19 #include <shogun/lib/common.h>
21 
22 #ifdef HAVE_EIGEN3
24 #endif
25 
26 namespace shogun
27 {
28  template <class T> class SGSparseVector;
29  template <class T> class SGMatrix;
30  class CFile;
31  class CRandom;
32 
34 template<class T> class SGVector : public SGReferencedData
35 {
36  public:
37  typedef T Scalar;
38 
40  SGVector();
41 
43  SGVector(T* v, index_t len, bool ref_counting=true);
44 
46  SGVector(T* m, index_t len, index_t offset)
47  : SGReferencedData(false), vector(m+offset), vlen(len) { }
48 
50  SGVector(index_t len, bool ref_counting=true);
51 
53  SGVector(const SGVector &orig);
54 
55 #ifndef SWIG // SWIG should skip this part
56 #ifdef HAVE_EIGEN3
57 
58  template <class Derived>
59  SGVector(Eigen::PlainObjectBase<Derived>& vec)
60  : SGReferencedData(false), vector(vec.data()), vlen(vec.size()) { }
61 
63  operator Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> >() const
64  {
65  return Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> >(vector, vlen);
66  }
67 
69  operator Eigen::Map<Eigen::Matrix<T, 1, Eigen::Dynamic> >() const
70  {
71  return Eigen::Map<Eigen::Matrix<T, 1, Eigen::Dynamic> >(vector, vlen);
72  }
73 #endif
74 #endif
75 
80  void set(SGVector<T> orig);
81 
83  virtual ~SGVector();
84 
86  inline int32_t size() const { return vlen; }
87 
89  operator T*() { return vector; };
90 
92  void zero();
93 
98  void set_const(T const_elem);
99 
104  void range_fill(T start=0);
105 
111  void random(T min_value, T max_value);
112 
114  void randperm();
115 
117  static SGVector<T> randperm_vec(int32_t n);
118 
125  static T* randperm(int32_t n);
126 
134  static SGVector<float64_t> linspace_vec(T start, T end, int32_t n);
135 
143  static float64_t* linspace(T start, T end, int32_t n);
144 
151  index_t find_position_to_insert(T element);
152 
156  void qsort();
157 
165 
170  bool is_sorted() const;
171 
173  SGVector<T> clone() const;
174 
176  static T* clone_vector(const T* vec, int32_t len);
177 
179  static void fill_vector(T* vec, int32_t len, T value);
180 
182  static void range_fill_vector(T* vec, int32_t len, T start=0);
183 
185  static void random_vector(T* vec, int32_t len, T min_value, T max_value);
186 
188  static void randperm(T* perm, int32_t n);
189 
191  static void permute(T* vec, int32_t n);
192 
194  static void permute(T* vec, int32_t n, CRandom * rand);
195 
202  {
203  return *this;
204  }
205 
211  const T& get_element(index_t index);
212 
219  void set_element(const T& p_element, index_t index);
220 
226  void resize_vector(int32_t n);
227 
233  inline const T& operator[](uint64_t index) const
234  {
235  return vector[index];
236  }
237 
243  inline const T& operator[](int64_t index) const
244  {
245  return vector[index];
246  }
247 
253  inline const T& operator[](uint32_t index) const
254  {
255  return vector[index];
256  }
257 
263  inline const T& operator[](int32_t index) const
264  {
265  return vector[index];
266  }
267 
273  inline T& operator[](uint64_t index)
274  {
275  return vector[index];
276  }
277 
283  inline T& operator[](int64_t index)
284  {
285  return vector[index];
286  }
287 
293  inline T& operator[](uint32_t index)
294  {
295  return vector[index];
296  }
297 
303  inline T& operator[](int32_t index)
304  {
305  return vector[index];
306  }
307 
312  void add(const SGVector<T> x);
313 
318  void add(const SGSparseVector<T>& x);
319 
324  void add(const T x);
325 
328 
331  {
332  add(x);
333  return *this;
334  }
335 
338  {
339  add(x);
340  return *this;
341  }
342 
348  bool equals(SGVector<T>& other);
349 
351  static void permute_vector(SGVector<T> vec);
352 
354  void permute();
355 
357  void permute(CRandom * rand);
358 
360  static T twonorm(const T* x, int32_t len);
361 
363  static float64_t onenorm(T* x, int32_t len);
364 
366  static T qsq(T* x, int32_t len, float64_t q);
367 
369  static T qnorm(T* x, int32_t len, float64_t q);
370 
372  static void vec1_plus_scalar_times_vec2(T* vec1,
373  const T scalar, const T* vec2, int32_t n);
374 
376  static inline float64_t dot(const bool* v1, const bool* v2, int32_t n)
377  {
378  float64_t r=0;
379  for (int32_t i=0; i<n; i++)
380  r+=((v1[i]) ? 1 : 0) * ((v2[i]) ? 1 : 0);
381  return r;
382  }
383 
385  static inline floatmax_t dot(const floatmax_t* v1, const floatmax_t* v2, int32_t n)
386  {
387  floatmax_t r=0;
388  for (int32_t i=0; i<n; i++)
389  r+=v1[i]*v2[i];
390  return r;
391  }
392 
393 
395  static float64_t dot(const float64_t* v1, const float64_t* v2, int32_t n);
396 
398  static float32_t dot(const float32_t* v1, const float32_t* v2, int32_t n);
399 
401  static inline float64_t dot(
402  const uint64_t* v1, const uint64_t* v2, int32_t n)
403  {
404  float64_t r=0;
405  for (int32_t i=0; i<n; i++)
406  r+=((float64_t) v1[i])*v2[i];
407 
408  return r;
409  }
411  static inline float64_t dot(
412  const int64_t* v1, const int64_t* v2, int32_t n)
413  {
414  float64_t r=0;
415  for (int32_t i=0; i<n; i++)
416  r+=((float64_t) v1[i])*v2[i];
417 
418  return r;
419  }
420 
422  static inline float64_t dot(
423  const int32_t* v1, const int32_t* v2, int32_t n)
424  {
425  float64_t r=0;
426  for (int32_t i=0; i<n; i++)
427  r+=((float64_t) v1[i])*v2[i];
428 
429  return r;
430  }
431 
433  static inline float64_t dot(
434  const uint32_t* v1, const uint32_t* v2, int32_t n)
435  {
436  float64_t r=0;
437  for (int32_t i=0; i<n; i++)
438  r+=((float64_t) v1[i])*v2[i];
439 
440  return r;
441  }
442 
444  static inline float64_t dot(
445  const uint16_t* v1, const uint16_t* v2, int32_t n)
446  {
447  float64_t r=0;
448  for (int32_t i=0; i<n; i++)
449  r+=((float64_t) v1[i])*v2[i];
450 
451  return r;
452  }
453 
455  static inline float64_t dot(
456  const int16_t* v1, const int16_t* v2, int32_t n)
457  {
458  float64_t r=0;
459  for (int32_t i=0; i<n; i++)
460  r+=((float64_t) v1[i])*v2[i];
461 
462  return r;
463  }
464 
466  static inline float64_t dot(
467  const char* v1, const char* v2, int32_t n)
468  {
469  float64_t r=0;
470  for (int32_t i=0; i<n; i++)
471  r+=((float64_t) v1[i])*v2[i];
472 
473  return r;
474  }
475 
477  static inline float64_t dot(
478  const uint8_t* v1, const uint8_t* v2, int32_t n)
479  {
480  float64_t r=0;
481  for (int32_t i=0; i<n; i++)
482  r+=((float64_t) v1[i])*v2[i];
483 
484  return r;
485  }
486 
488  static inline float64_t dot(
489  const int8_t* v1, const int8_t* v2, int32_t n)
490  {
491  float64_t r=0;
492  for (int32_t i=0; i<n; i++)
493  r+=((float64_t) v1[i])*v2[i];
494 
495  return r;
496  }
497 
499  static inline float64_t dot(
500  const float64_t* v1, const char* v2, int32_t n)
501  {
502  float64_t r=0;
503  for (int32_t i=0; i<n; i++)
504  r+=((float64_t) v1[i])*v2[i];
505 
506  return r;
507  }
508 
510  static inline void vector_multiply(
511  T* target, const T* v1, const T* v2,int32_t len)
512  {
513  for (int32_t i=0; i<len; i++)
514  target[i]=v1[i]*v2[i];
515  }
516 
517 
519  static inline void add(
520  T* target, T alpha, const T* v1, T beta, const T* v2,
521  int32_t len)
522  {
523  for (int32_t i=0; i<len; i++)
524  target[i]=alpha*v1[i]+beta*v2[i];
525  }
526 
528  static inline void add_scalar(T alpha, T* vec, int32_t len)
529  {
530  for (int32_t i=0; i<len; i++)
531  vec[i]+=alpha;
532  }
533 
535  static void scale_vector(T alpha, T* vec, int32_t len);
536 
538  static inline T sum(T* vec, int32_t len)
539  {
540  T result=0;
541  for (int32_t i=0; i<len; i++)
542  result+=vec[i];
543 
544  return result;
545  }
546 
548  static inline T sum(SGVector<T> vec)
549  {
550  return sum(vec.vector, vec.vlen);
551  }
552 
554  static inline T product(T* vec, int32_t len)
555  {
556  T result=1;
557  for (int32_t i=0; i<len; i++)
558  result*=vec[i];
559 
560  return result;
561  }
562 
564  inline T product()
565  {
566  return product(vector, vlen);
567  }
568 
570  static T min(T* vec, int32_t len);
571 
573  static T max_abs(T* vec, int32_t len);
574 
576  static T max(T* vec, int32_t len);
577 
579  static int32_t arg_max(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);
580 
582  static int32_t arg_max_abs(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);
583 
585  static int32_t arg_min(T * vec, int32_t inc, int32_t len, T * minv_ptr = NULL);
586 
588  static T sum_abs(T* vec, int32_t len);
589 
591  static bool fequal(T x, T y, float64_t precision=1e-6);
592 
596  static int32_t unique(T* output, int32_t size);
597 
599  void display_size() const;
600 
602  void display_vector(const char* name="vector",
603  const char* prefix="") const;
604 
606  static void display_vector(
607  const T* vector, int32_t n, const char* name="vector",
608  const char* prefix="");
609 
611  static void display_vector(
612  const SGVector<T>, const char* name="vector",
613  const char* prefix="");
614 
618  SGVector<index_t> find(T elem);
619 
623  template <typename Predicate>
625  {
626  SGVector<index_t> idx(vlen);
627  index_t k=0;
628 
629  for (index_t i=0; i < vlen; ++i)
630  if (p(vector[i]))
631  idx[k++] = i;
632 
633  idx.vlen = k;
634  return idx;
635  }
636 
638  void scale(T alpha);
639 
644  float64_t mean() const;
645 
650  void load(CFile* loader);
651 
656  void save(CFile* saver);
657 
659  void abs();
661  void acos();
663  void asin();
665  void atan();
667  void atan2(T x);
669  void cos();
671  void cosh();
673  void exp();
675  void log();
677  void log10();
679  void pow(T q);
681  void sin();
683  void sinh();
685  void sqrt();
687  void tan();
689  void tanh();
690 
693 
696 
707  static SGMatrix<T> convert_to_matrix(SGVector<T> vector, index_t nrows, index_t ncols, bool fortran_order);
708 
709 
722  static void convert_to_matrix(T*& matrix, index_t nrows, index_t ncols, const T* vector, int32_t vlen, bool fortran_order);
723 
724  protected:
726  virtual void copy_data(const SGReferencedData &orig);
727 
729  virtual void init_data();
730 
732  virtual void free_data();
733 
734  public:
736  T* vector;
739 };
740 
741 #ifndef DOXYGEN_SHOULD_SKIP_THIS
743  const float64_t scalar, const float64_t* vec2, int32_t n);
744 
746  const float32_t scalar, const float32_t* vec2, int32_t n);
747 #endif // DOXYGEN_SHOULD_SKIP_THIS
748 }
749 #endif // __SGVECTOR_H__

SHOGUN Machine Learning Toolbox - Documentation