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 namespace Eigen
23 {
24  template <class, int, int, int, int, int> class Matrix;
25  template<int, int> class Stride;
26  template <class, int, class> class Map;
27 }
28 
29 namespace shogun
30 {
31  template <class T> class SGSparseVector;
32  template <class T> class SGMatrix;
33  class CFile;
34  class CRandom;
35 
37 template<class T> class SGVector : public SGReferencedData
38 {
39  typedef Eigen::Matrix<T,-1,1,0,-1,1> EigenVectorXt;
40  typedef Eigen::Matrix<T,1,-1,0x1,1,-1> EigenRowVectorXt;
41 
42  typedef Eigen::Map<EigenVectorXt,0,Eigen::Stride<0,0> > EigenVectorXtMap;
43  typedef Eigen::Map<EigenRowVectorXt,0,Eigen::Stride<0,0> > EigenRowVectorXtMap;
44 
45 
46 
47  public:
48  typedef T Scalar;
49 
51  SGVector();
52 
54  SGVector(T* v, index_t len, bool ref_counting=true);
55 
57  SGVector(T* m, index_t len, index_t offset)
58  : SGReferencedData(false), vector(m+offset), vlen(len) { }
59 
61  SGVector(index_t len, bool ref_counting=true);
62 
64  SGVector(const SGVector &orig);
65 
66 #ifndef SWIG // SWIG should skip this part
67 #ifdef HAVE_EIGEN3
68 
69  SGVector(EigenVectorXt& vec);
70 
72  SGVector(EigenRowVectorXt& vec);
73 
75  operator EigenVectorXtMap() const;
76 
78  operator EigenRowVectorXtMap() const;
79 #endif
80 #endif
81 
86  void set(SGVector<T> orig);
87 
89  virtual ~SGVector();
90 
92  inline int32_t size() const { return vlen; }
93 
95  operator T*() { return vector; };
96 
98  void zero();
99 
104  void set_const(T const_elem);
105 
110  void range_fill(T start=0);
111 
117  void random(T min_value, T max_value);
118 
120  void randperm();
121 
123  static SGVector<T> randperm_vec(int32_t n);
124 
131  static T* randperm(int32_t n);
132 
140  static SGVector<float64_t> linspace_vec(T start, T end, int32_t n);
141 
149  static float64_t* linspace(T start, T end, int32_t n);
150 
157  index_t find_position_to_insert(T element);
158 
162  void qsort();
163 
171 
176  bool is_sorted() const;
177 
179  SGVector<T> clone() const;
180 
182  static T* clone_vector(const T* vec, int32_t len);
183 
185  static void fill_vector(T* vec, int32_t len, T value);
186 
188  static void range_fill_vector(T* vec, int32_t len, T start=0);
189 
191  static void random_vector(T* vec, int32_t len, T min_value, T max_value);
192 
194  static void randperm(T* perm, int32_t n);
195 
197  static void permute(T* vec, int32_t n);
198 
200  static void permute(T* vec, int32_t n, CRandom * rand);
201 
208  {
209  return *this;
210  }
211 
217  const T& get_element(index_t index);
218 
225  void set_element(const T& p_element, index_t index);
226 
232  void resize_vector(int32_t n);
233 
239  inline const T& operator[](uint64_t index) const
240  {
241  return vector[index];
242  }
243 
249  inline const T& operator[](int64_t index) const
250  {
251  return vector[index];
252  }
253 
259  inline const T& operator[](uint32_t index) const
260  {
261  return vector[index];
262  }
263 
269  inline const T& operator[](int32_t index) const
270  {
271  return vector[index];
272  }
273 
279  inline T& operator[](uint64_t index)
280  {
281  return vector[index];
282  }
283 
289  inline T& operator[](int64_t index)
290  {
291  return vector[index];
292  }
293 
299  inline T& operator[](uint32_t index)
300  {
301  return vector[index];
302  }
303 
309  inline T& operator[](int32_t index)
310  {
311  return vector[index];
312  }
313 
318  void add(const SGVector<T> x);
319 
324  void add(const SGSparseVector<T>& x);
325 
330  void add(const T x);
331 
334 
337  {
338  add(x);
339  return *this;
340  }
341 
344  {
345  add(x);
346  return *this;
347  }
348 
354  bool equals(SGVector<T>& other);
355 
357  static void permute_vector(SGVector<T> vec);
358 
360  void permute();
361 
363  void permute(CRandom * rand);
364 
366  static T twonorm(const T* x, int32_t len);
367 
369  static float64_t onenorm(T* x, int32_t len);
370 
372  static T qsq(T* x, int32_t len, float64_t q);
373 
375  static T qnorm(T* x, int32_t len, float64_t q);
376 
378  static void vec1_plus_scalar_times_vec2(T* vec1,
379  const T scalar, const T* vec2, int32_t n);
380 
382  static inline float64_t dot(const bool* v1, const bool* v2, int32_t n)
383  {
384  float64_t r=0;
385  for (int32_t i=0; i<n; i++)
386  r+=((v1[i]) ? 1 : 0) * ((v2[i]) ? 1 : 0);
387  return r;
388  }
389 
391  static inline floatmax_t dot(const floatmax_t* v1, const floatmax_t* v2, int32_t n)
392  {
393  floatmax_t r=0;
394  for (int32_t i=0; i<n; i++)
395  r+=v1[i]*v2[i];
396  return r;
397  }
398 
399 
401  static float64_t dot(const float64_t* v1, const float64_t* v2, int32_t n);
402 
404  static float32_t dot(const float32_t* v1, const float32_t* v2, int32_t n);
405 
407  static inline float64_t dot(
408  const uint64_t* v1, const uint64_t* v2, int32_t n)
409  {
410  float64_t r=0;
411  for (int32_t i=0; i<n; i++)
412  r+=((float64_t) v1[i])*v2[i];
413 
414  return r;
415  }
417  static inline float64_t dot(
418  const int64_t* v1, const int64_t* v2, int32_t n)
419  {
420  float64_t r=0;
421  for (int32_t i=0; i<n; i++)
422  r+=((float64_t) v1[i])*v2[i];
423 
424  return r;
425  }
426 
428  static inline float64_t dot(
429  const int32_t* v1, const int32_t* v2, int32_t n)
430  {
431  float64_t r=0;
432  for (int32_t i=0; i<n; i++)
433  r+=((float64_t) v1[i])*v2[i];
434 
435  return r;
436  }
437 
439  static inline float64_t dot(
440  const uint32_t* v1, const uint32_t* v2, int32_t n)
441  {
442  float64_t r=0;
443  for (int32_t i=0; i<n; i++)
444  r+=((float64_t) v1[i])*v2[i];
445 
446  return r;
447  }
448 
450  static inline float64_t dot(
451  const uint16_t* v1, const uint16_t* v2, int32_t n)
452  {
453  float64_t r=0;
454  for (int32_t i=0; i<n; i++)
455  r+=((float64_t) v1[i])*v2[i];
456 
457  return r;
458  }
459 
461  static inline float64_t dot(
462  const int16_t* v1, const int16_t* v2, int32_t n)
463  {
464  float64_t r=0;
465  for (int32_t i=0; i<n; i++)
466  r+=((float64_t) v1[i])*v2[i];
467 
468  return r;
469  }
470 
472  static inline float64_t dot(
473  const char* v1, const char* v2, int32_t n)
474  {
475  float64_t r=0;
476  for (int32_t i=0; i<n; i++)
477  r+=((float64_t) v1[i])*v2[i];
478 
479  return r;
480  }
481 
483  static inline float64_t dot(
484  const uint8_t* v1, const uint8_t* v2, int32_t n)
485  {
486  float64_t r=0;
487  for (int32_t i=0; i<n; i++)
488  r+=((float64_t) v1[i])*v2[i];
489 
490  return r;
491  }
492 
494  static inline float64_t dot(
495  const int8_t* v1, const int8_t* v2, int32_t n)
496  {
497  float64_t r=0;
498  for (int32_t i=0; i<n; i++)
499  r+=((float64_t) v1[i])*v2[i];
500 
501  return r;
502  }
503 
505  static inline float64_t dot(
506  const float64_t* v1, const char* v2, int32_t n)
507  {
508  float64_t r=0;
509  for (int32_t i=0; i<n; i++)
510  r+=((float64_t) v1[i])*v2[i];
511 
512  return r;
513  }
514 
516  static inline void vector_multiply(
517  T* target, const T* v1, const T* v2,int32_t len)
518  {
519  for (int32_t i=0; i<len; i++)
520  target[i]=v1[i]*v2[i];
521  }
522 
523 
525  static inline void add(
526  T* target, T alpha, const T* v1, T beta, const T* v2,
527  int32_t len)
528  {
529  for (int32_t i=0; i<len; i++)
530  target[i]=alpha*v1[i]+beta*v2[i];
531  }
532 
534  static inline void add_scalar(T alpha, T* vec, int32_t len)
535  {
536  for (int32_t i=0; i<len; i++)
537  vec[i]+=alpha;
538  }
539 
541  static void scale_vector(T alpha, T* vec, int32_t len);
542 
544  static inline T sum(T* vec, int32_t len)
545  {
546  T result=0;
547  for (int32_t i=0; i<len; i++)
548  result+=vec[i];
549 
550  return result;
551  }
552 
554  static inline T sum(SGVector<T> vec)
555  {
556  return sum(vec.vector, vec.vlen);
557  }
558 
560  static inline T product(T* vec, int32_t len)
561  {
562  T result=1;
563  for (int32_t i=0; i<len; i++)
564  result*=vec[i];
565 
566  return result;
567  }
568 
570  inline T product()
571  {
572  return product(vector, vlen);
573  }
574 
576  static T min(T* vec, int32_t len);
577 
579  static T max_abs(T* vec, int32_t len);
580 
582  static T max(T* vec, int32_t len);
583 
585  static int32_t arg_max(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);
586 
588  static int32_t arg_max_abs(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);
589 
591  static int32_t arg_min(T * vec, int32_t inc, int32_t len, T * minv_ptr = NULL);
592 
594  static T sum_abs(T* vec, int32_t len);
595 
597  static bool fequal(T x, T y, float64_t precision=1e-6);
598 
602  static int32_t unique(T* output, int32_t size);
603 
605  void display_size() const;
606 
608  void display_vector(const char* name="vector",
609  const char* prefix="") const;
610 
612  static void display_vector(
613  const T* vector, int32_t n, const char* name="vector",
614  const char* prefix="");
615 
617  static void display_vector(
618  const SGVector<T>, const char* name="vector",
619  const char* prefix="");
620 
624  SGVector<index_t> find(T elem);
625 
629  template <typename Predicate>
631  {
632  SGVector<index_t> idx(vlen);
633  index_t k=0;
634 
635  for (index_t i=0; i < vlen; ++i)
636  if (p(vector[i]))
637  idx[k++] = i;
638 
639  idx.vlen = k;
640  return idx;
641  }
642 
644  void scale(T alpha);
645 
650  float64_t mean() const;
651 
656  void load(CFile* loader);
657 
662  void save(CFile* saver);
663 
665  void abs();
667  void acos();
669  void asin();
671  void atan();
673  void atan2(T x);
675  void cos();
677  void cosh();
679  void exp();
681  void log();
683  void log10();
685  void pow(T q);
687  void sin();
689  void sinh();
691  void sqrt();
693  void tan();
695  void tanh();
696 
699 
702 
713  static SGMatrix<T> convert_to_matrix(SGVector<T> vector, index_t nrows, index_t ncols, bool fortran_order);
714 
715 
728  static void convert_to_matrix(T*& matrix, index_t nrows, index_t ncols, const T* vector, int32_t vlen, bool fortran_order);
729 
730  protected:
732  virtual void copy_data(const SGReferencedData &orig);
733 
735  virtual void init_data();
736 
738  virtual void free_data();
739 
740  public:
742  T* vector;
745 };
746 
747 #ifndef DOXYGEN_SHOULD_SKIP_THIS
749  const float64_t scalar, const float64_t* vec2, int32_t n);
750 
752  const float32_t scalar, const float32_t* vec2, int32_t n);
753 #endif // DOXYGEN_SHOULD_SKIP_THIS
754 }
755 #endif // __SGVECTOR_H__

SHOGUN Machine Learning Toolbox - Documentation