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  public:
47  typedef T Scalar;
48 
50  SGVector();
51 
53  SGVector(T* v, index_t len, bool ref_counting=true);
54 
56  SGVector(T* m, index_t len, index_t offset)
57  : SGReferencedData(false), vector(m+offset), vlen(len) { }
58 
60  SGVector(index_t len, bool ref_counting=true);
61 
63  SGVector(const SGVector &orig);
64 
65 #ifndef SWIG // SWIG should skip this part
66 #ifdef HAVE_EIGEN3
67 
68  SGVector(EigenVectorXt& vec);
69 
71  SGVector(EigenRowVectorXt& vec);
72 
74  operator EigenVectorXtMap() const;
75 
77  operator EigenRowVectorXtMap() const;
78 #endif
79 #endif
80 
85  void set(SGVector<T> orig);
86 
88  virtual ~SGVector();
89 
91  inline int32_t size() const { return vlen; }
92 
94  operator T*() { return vector; };
95 
97  void zero();
98 
103  void set_const(T const_elem);
104 
109  void range_fill(T start=0);
110 
116  void random(T min_value, T max_value);
117 
119  void randperm();
120 
122  static SGVector<T> randperm_vec(int32_t n);
123 
130  static T* randperm(int32_t n);
131 
139  static SGVector<float64_t> linspace_vec(T start, T end, int32_t n);
140 
148  static float64_t* linspace(T start, T end, int32_t n);
149 
156  index_t find_position_to_insert(T element);
157 
161  void qsort();
162 
170 
175  bool is_sorted() const;
176 
178  SGVector<T> clone() const;
179 
181  static T* clone_vector(const T* vec, int32_t len);
182 
184  static void fill_vector(T* vec, int32_t len, T value);
185 
187  static void range_fill_vector(T* vec, int32_t len, T start=0);
188 
190  static void random_vector(T* vec, int32_t len, T min_value, T max_value);
191 
193  static void randperm(T* perm, int32_t n);
194 
196  static void permute(T* vec, int32_t n);
197 
199  static void permute(T* vec, int32_t n, CRandom * rand);
200 
207  {
208  return *this;
209  }
210 
216  const T& get_element(index_t index);
217 
224  void set_element(const T& p_element, index_t index);
225 
231  void resize_vector(int32_t n);
232 
238  inline const T& operator[](uint64_t index) const
239  {
240  return vector[index];
241  }
242 
248  inline const T& operator[](int64_t index) const
249  {
250  return vector[index];
251  }
252 
258  inline const T& operator[](uint32_t index) const
259  {
260  return vector[index];
261  }
262 
268  inline const T& operator[](int32_t index) const
269  {
270  return vector[index];
271  }
272 
278  inline T& operator[](uint64_t index)
279  {
280  return vector[index];
281  }
282 
288  inline T& operator[](int64_t index)
289  {
290  return vector[index];
291  }
292 
298  inline T& operator[](uint32_t index)
299  {
300  return vector[index];
301  }
302 
308  inline T& operator[](int32_t index)
309  {
310  return vector[index];
311  }
312 
317  void add(const SGVector<T> x);
318 
323  void add(const SGSparseVector<T>& x);
324 
329  void add(const T x);
330 
333 
336  {
337  add(x);
338  return *this;
339  }
340 
343  {
344  add(x);
345  return *this;
346  }
347 
353  bool equals(SGVector<T>& other);
354 
356  static void permute_vector(SGVector<T> vec);
357 
359  void permute();
360 
362  void permute(CRandom * rand);
363 
365  static T twonorm(const T* x, int32_t len);
366 
368  static float64_t onenorm(T* x, int32_t len);
369 
371  static T qsq(T* x, int32_t len, float64_t q);
372 
374  static T qnorm(T* x, int32_t len, float64_t q);
375 
377  static void vec1_plus_scalar_times_vec2(T* vec1,
378  const T scalar, const T* vec2, int32_t n);
379 
381  static inline float64_t dot(const bool* v1, const bool* v2, int32_t n)
382  {
383  float64_t r=0;
384  for (int32_t i=0; i<n; i++)
385  r+=((v1[i]) ? 1 : 0) * ((v2[i]) ? 1 : 0);
386  return r;
387  }
388 
390  static inline floatmax_t dot(const floatmax_t* v1, const floatmax_t* v2, int32_t n)
391  {
392  floatmax_t r=0;
393  for (int32_t i=0; i<n; i++)
394  r+=v1[i]*v2[i];
395  return r;
396  }
397 
398 
400  static float64_t dot(const float64_t* v1, const float64_t* v2, int32_t n);
401 
403  static float32_t dot(const float32_t* v1, const float32_t* v2, int32_t n);
404 
406  static inline float64_t dot(
407  const uint64_t* v1, const uint64_t* v2, int32_t n)
408  {
409  float64_t r=0;
410  for (int32_t i=0; i<n; i++)
411  r+=((float64_t) v1[i])*v2[i];
412 
413  return r;
414  }
416  static inline float64_t dot(
417  const int64_t* v1, const int64_t* v2, int32_t n)
418  {
419  float64_t r=0;
420  for (int32_t i=0; i<n; i++)
421  r+=((float64_t) v1[i])*v2[i];
422 
423  return r;
424  }
425 
427  static inline float64_t dot(
428  const int32_t* v1, const int32_t* v2, int32_t n)
429  {
430  float64_t r=0;
431  for (int32_t i=0; i<n; i++)
432  r+=((float64_t) v1[i])*v2[i];
433 
434  return r;
435  }
436 
438  static inline float64_t dot(
439  const uint32_t* v1, const uint32_t* v2, int32_t n)
440  {
441  float64_t r=0;
442  for (int32_t i=0; i<n; i++)
443  r+=((float64_t) v1[i])*v2[i];
444 
445  return r;
446  }
447 
449  static inline float64_t dot(
450  const uint16_t* v1, const uint16_t* v2, int32_t n)
451  {
452  float64_t r=0;
453  for (int32_t i=0; i<n; i++)
454  r+=((float64_t) v1[i])*v2[i];
455 
456  return r;
457  }
458 
460  static inline float64_t dot(
461  const int16_t* v1, const int16_t* v2, int32_t n)
462  {
463  float64_t r=0;
464  for (int32_t i=0; i<n; i++)
465  r+=((float64_t) v1[i])*v2[i];
466 
467  return r;
468  }
469 
471  static inline float64_t dot(
472  const char* v1, const char* v2, int32_t n)
473  {
474  float64_t r=0;
475  for (int32_t i=0; i<n; i++)
476  r+=((float64_t) v1[i])*v2[i];
477 
478  return r;
479  }
480 
482  static inline float64_t dot(
483  const uint8_t* v1, const uint8_t* v2, int32_t n)
484  {
485  float64_t r=0;
486  for (int32_t i=0; i<n; i++)
487  r+=((float64_t) v1[i])*v2[i];
488 
489  return r;
490  }
491 
493  static inline float64_t dot(
494  const int8_t* v1, const int8_t* v2, int32_t n)
495  {
496  float64_t r=0;
497  for (int32_t i=0; i<n; i++)
498  r+=((float64_t) v1[i])*v2[i];
499 
500  return r;
501  }
502 
504  static inline float64_t dot(
505  const float64_t* v1, const char* v2, int32_t n)
506  {
507  float64_t r=0;
508  for (int32_t i=0; i<n; i++)
509  r+=((float64_t) v1[i])*v2[i];
510 
511  return r;
512  }
513 
515  static inline void vector_multiply(
516  T* target, const T* v1, const T* v2,int32_t len)
517  {
518  for (int32_t i=0; i<len; i++)
519  target[i]=v1[i]*v2[i];
520  }
521 
522 
524  static inline void add(
525  T* target, T alpha, const T* v1, T beta, const T* v2,
526  int32_t len)
527  {
528  for (int32_t i=0; i<len; i++)
529  target[i]=alpha*v1[i]+beta*v2[i];
530  }
531 
533  static inline void add_scalar(T alpha, T* vec, int32_t len)
534  {
535  for (int32_t i=0; i<len; i++)
536  vec[i]+=alpha;
537  }
538 
540  static void scale_vector(T alpha, T* vec, int32_t len);
541 
543  static inline T sum(T* vec, int32_t len)
544  {
545  T result=0;
546  for (int32_t i=0; i<len; i++)
547  result+=vec[i];
548 
549  return result;
550  }
551 
553  static inline T sum(SGVector<T> vec)
554  {
555  return sum(vec.vector, vec.vlen);
556  }
557 
559  static inline T product(T* vec, int32_t len)
560  {
561  T result=1;
562  for (int32_t i=0; i<len; i++)
563  result*=vec[i];
564 
565  return result;
566  }
567 
569  inline T product()
570  {
571  return product(vector, vlen);
572  }
573 
575  static T min(T* vec, int32_t len);
576 
578  static T max_abs(T* vec, int32_t len);
579 
581  static T max(T* vec, int32_t len);
582 
584  static int32_t arg_max(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);
585 
587  static int32_t arg_max_abs(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);
588 
590  static int32_t arg_min(T * vec, int32_t inc, int32_t len, T * minv_ptr = NULL);
591 
593  static T sum_abs(T* vec, int32_t len);
594 
596  static bool fequal(T x, T y, float64_t precision=1e-6);
597 
601  static int32_t unique(T* output, int32_t size);
602 
604  void display_size() const;
605 
607  void display_vector(const char* name="vector",
608  const char* prefix="") const;
609 
611  static void display_vector(
612  const T* vector, int32_t n, const char* name="vector",
613  const char* prefix="");
614 
616  static void display_vector(
617  const SGVector<T>, const char* name="vector",
618  const char* prefix="");
619 
623  SGVector<index_t> find(T elem);
624 
628  template <typename Predicate>
630  {
631  SGVector<index_t> idx(vlen);
632  index_t k=0;
633 
634  for (index_t i=0; i < vlen; ++i)
635  if (p(vector[i]))
636  idx[k++] = i;
637 
638  idx.vlen = k;
639  return idx;
640  }
641 
643  void scale(T alpha);
644 
649  float64_t mean() const;
650 
655  void load(CFile* loader);
656 
661  void save(CFile* saver);
662 
664  void abs();
666  void acos();
668  void asin();
670  void atan();
672  void atan2(T x);
674  void cos();
676  void cosh();
678  void exp();
680  void log();
682  void log10();
684  void pow(T q);
686  void sin();
688  void sinh();
690  void sqrt();
692  void tan();
694  void tanh();
695 
698 
701 
712  static SGMatrix<T> convert_to_matrix(SGVector<T> vector, index_t nrows, index_t ncols, bool fortran_order);
713 
714 
727  static void convert_to_matrix(T*& matrix, index_t nrows, index_t ncols, const T* vector, int32_t vlen, bool fortran_order);
728 
729  protected:
731  virtual void copy_data(const SGReferencedData &orig);
732 
734  virtual void init_data();
735 
737  virtual void free_data();
738 
739  public:
741  T* vector;
744 };
745 
746 #ifndef DOXYGEN_SHOULD_SKIP_THIS
748  const float64_t scalar, const float64_t* vec2, int32_t n);
749 
751  const float32_t scalar, const float32_t* vec2, int32_t n);
752 #endif // DOXYGEN_SHOULD_SKIP_THIS
753 }
754 #endif // __SGVECTOR_H__

SHOGUN Machine Learning Toolbox - Documentation