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 
81 #ifndef SWIG // SWIG should skip this part
82 
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 
126  static SGVector<float64_t> linspace_vec(T start, T end, int32_t n);
127 
135  static float64_t* linspace(T start, T end, int32_t n);
136 
143  index_t find_position_to_insert(T element);
144 
148  void qsort();
149 
157 
162  bool is_sorted() const;
163 
165  SGVector<T> clone() const;
166 
168  static T* clone_vector(const T* vec, int32_t len);
169 
171  static void fill_vector(T* vec, int32_t len, T value);
172 
174  static void range_fill_vector(T* vec, int32_t len, T start=0);
175 
177  static void random_vector(T* vec, int32_t len, T min_value, T max_value);
178 
185  {
186  return *this;
187  }
188 
194  const T& get_element(index_t index);
195 
202  void set_element(const T& p_element, index_t index);
203 
209  void resize_vector(int32_t n);
210 
216  inline const T& operator[](uint64_t index) const
217  {
218  return vector[index];
219  }
220 
226  inline const T& operator[](int64_t index) const
227  {
228  return vector[index];
229  }
230 
236  inline const T& operator[](uint32_t index) const
237  {
238  return vector[index];
239  }
240 
246  inline const T& operator[](int32_t index) const
247  {
248  return vector[index];
249  }
250 
256  inline T& operator[](uint64_t index)
257  {
258  return vector[index];
259  }
260 
266  inline T& operator[](int64_t index)
267  {
268  return vector[index];
269  }
270 
276  inline T& operator[](uint32_t index)
277  {
278  return vector[index];
279  }
280 
286  inline T& operator[](int32_t index)
287  {
288  return vector[index];
289  }
290 
295  void add(const SGVector<T> x);
296 
301  void add(const SGSparseVector<T>& x);
302 
307  void add(const T x);
308 
311 
314  {
315  add(x);
316  return *this;
317  }
318 
321  {
322  add(x);
323  return *this;
324  }
325 
331  bool equals(SGVector<T>& other);
332 
334  static T twonorm(const T* x, int32_t len);
335 
337  static float64_t onenorm(T* x, int32_t len);
338 
340  static T qsq(T* x, int32_t len, float64_t q);
341 
343  static T qnorm(T* x, int32_t len, float64_t q);
344 
346  static void vec1_plus_scalar_times_vec2(T* vec1,
347  const T scalar, const T* vec2, int32_t n);
348 
350  static inline float64_t dot(const bool* v1, const bool* v2, int32_t n)
351  {
352  float64_t r=0;
353  for (int32_t i=0; i<n; i++)
354  r+=((v1[i]) ? 1 : 0) * ((v2[i]) ? 1 : 0);
355  return r;
356  }
357 
359  static inline floatmax_t dot(const floatmax_t* v1, const floatmax_t* v2, int32_t n)
360  {
361  floatmax_t r=0;
362  for (int32_t i=0; i<n; i++)
363  r+=v1[i]*v2[i];
364  return r;
365  }
366 
367 
369  static float64_t dot(const float64_t* v1, const float64_t* v2, int32_t n);
370 
372  static float32_t dot(const float32_t* v1, const float32_t* v2, int32_t n);
373 
375  static inline float64_t dot(
376  const uint64_t* v1, const uint64_t* v2, int32_t n)
377  {
378  float64_t r=0;
379  for (int32_t i=0; i<n; i++)
380  r+=((float64_t) v1[i])*v2[i];
381 
382  return r;
383  }
385  static inline float64_t dot(
386  const int64_t* v1, const int64_t* v2, int32_t n)
387  {
388  float64_t r=0;
389  for (int32_t i=0; i<n; i++)
390  r+=((float64_t) v1[i])*v2[i];
391 
392  return r;
393  }
394 
396  static inline float64_t dot(
397  const int32_t* v1, const int32_t* v2, int32_t n)
398  {
399  float64_t r=0;
400  for (int32_t i=0; i<n; i++)
401  r+=((float64_t) v1[i])*v2[i];
402 
403  return r;
404  }
405 
407  static inline float64_t dot(
408  const uint32_t* v1, const uint32_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  }
416 
418  static inline float64_t dot(
419  const uint16_t* v1, const uint16_t* v2, int32_t n)
420  {
421  float64_t r=0;
422  for (int32_t i=0; i<n; i++)
423  r+=((float64_t) v1[i])*v2[i];
424 
425  return r;
426  }
427 
429  static inline float64_t dot(
430  const int16_t* v1, const int16_t* v2, int32_t n)
431  {
432  float64_t r=0;
433  for (int32_t i=0; i<n; i++)
434  r+=((float64_t) v1[i])*v2[i];
435 
436  return r;
437  }
438 
440  static inline float64_t dot(
441  const char* v1, const char* v2, int32_t n)
442  {
443  float64_t r=0;
444  for (int32_t i=0; i<n; i++)
445  r+=((float64_t) v1[i])*v2[i];
446 
447  return r;
448  }
449 
451  static inline float64_t dot(
452  const uint8_t* v1, const uint8_t* v2, int32_t n)
453  {
454  float64_t r=0;
455  for (int32_t i=0; i<n; i++)
456  r+=((float64_t) v1[i])*v2[i];
457 
458  return r;
459  }
460 
462  static inline float64_t dot(
463  const int8_t* v1, const int8_t* v2, int32_t n)
464  {
465  float64_t r=0;
466  for (int32_t i=0; i<n; i++)
467  r+=((float64_t) v1[i])*v2[i];
468 
469  return r;
470  }
471 
473  static inline float64_t dot(
474  const float64_t* v1, const char* v2, int32_t n)
475  {
476  float64_t r=0;
477  for (int32_t i=0; i<n; i++)
478  r+=((float64_t) v1[i])*v2[i];
479 
480  return r;
481  }
482 
484  static inline void vector_multiply(
485  T* target, const T* v1, const T* v2,int32_t len)
486  {
487  for (int32_t i=0; i<len; i++)
488  target[i]=v1[i]*v2[i];
489  }
490 
491 
493  static inline void add(
494  T* target, T alpha, const T* v1, T beta, const T* v2,
495  int32_t len)
496  {
497  for (int32_t i=0; i<len; i++)
498  target[i]=alpha*v1[i]+beta*v2[i];
499  }
500 
502  static inline void add_scalar(T alpha, T* vec, int32_t len)
503  {
504  for (int32_t i=0; i<len; i++)
505  vec[i]+=alpha;
506  }
507 
509  static void scale_vector(T alpha, T* vec, int32_t len);
510 
512  static inline T sum(T* vec, int32_t len)
513  {
514  T result=0;
515  for (int32_t i=0; i<len; i++)
516  result+=vec[i];
517 
518  return result;
519  }
520 
522  static inline T sum(SGVector<T> vec)
523  {
524  return sum(vec.vector, vec.vlen);
525  }
526 
528  static inline T product(T* vec, int32_t len)
529  {
530  T result=1;
531  for (int32_t i=0; i<len; i++)
532  result*=vec[i];
533 
534  return result;
535  }
536 
538  inline T product()
539  {
540  return product(vector, vlen);
541  }
542 
544  static T min(T* vec, int32_t len);
545 
547  static T max_abs(T* vec, int32_t len);
548 
550  static T max(T* vec, int32_t len);
551 
553  static int32_t arg_max(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);
554 
556  static int32_t arg_max_abs(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);
557 
559  static int32_t arg_min(T * vec, int32_t inc, int32_t len, T * minv_ptr = NULL);
560 
562  static T sum_abs(T* vec, int32_t len);
563 
565  static bool fequal(T x, T y, float64_t precision=1e-6);
566 
570  static int32_t unique(T* output, int32_t size);
571 
573  void display_size() const;
574 
576  void display_vector(const char* name="vector",
577  const char* prefix="") const;
578 
580  static void display_vector(
581  const T* vector, int32_t n, const char* name="vector",
582  const char* prefix="");
583 
585  static void display_vector(
586  const SGVector<T>, const char* name="vector",
587  const char* prefix="");
588 
592  SGVector<index_t> find(T elem);
593 
597  template <typename Predicate>
599  {
600  SGVector<index_t> idx(vlen);
601  index_t k=0;
602 
603  for (index_t i=0; i < vlen; ++i)
604  if (p(vector[i]))
605  idx[k++] = i;
606 
607  idx.vlen = k;
608  return idx;
609  }
610 
612  void scale(T alpha);
613 
618  float64_t mean() const;
619 
624  void load(CFile* loader);
625 
630  void save(CFile* saver);
631 
633  void abs();
635  void acos();
637  void asin();
639  void atan();
641  void atan2(T x);
643  void cos();
645  void cosh();
647  void exp();
649  void log();
651  void log10();
653  void pow(T q);
655  void sin();
657  void sinh();
659  void sqrt();
661  void tan();
663  void tanh();
664 
667 
670 
681  static SGMatrix<T> convert_to_matrix(SGVector<T> vector, index_t nrows, index_t ncols, bool fortran_order);
682 
683 
696  static void convert_to_matrix(T*& matrix, index_t nrows, index_t ncols, const T* vector, int32_t vlen, bool fortran_order);
697 #endif // #ifndef SWIG // SWIG should skip this part
698  protected:
700  virtual void copy_data(const SGReferencedData &orig);
701 
703  virtual void init_data();
704 
706  virtual void free_data();
707 
708  public:
710  T* vector;
713 };
714 
715 #ifndef DOXYGEN_SHOULD_SKIP_THIS
717  const float64_t scalar, const float64_t* vec2, int32_t n);
718 
720  const float32_t scalar, const float32_t* vec2, int32_t n);
721 #endif // DOXYGEN_SHOULD_SKIP_THIS
722 }
723 #endif // __SGVECTOR_H__

SHOGUN Machine Learning Toolbox - Documentation