SHOGUN  4.1.0
 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_const(T const_elem);
86 
93  {
94  return *this;
95  }
96 
97 #ifndef SWIG // SWIG should skip this part
98 
102  void set(SGVector<T> orig);
103 
105  virtual ~SGVector();
106 
108  inline int32_t size() const { return vlen; }
109 
111  operator T*() { return vector; };
112 
114  void zero();
115 
120  void range_fill(T start=0);
121 
127  void random(T min_value, T max_value);
128 
135  index_t find_position_to_insert(T element);
136 
138  SGVector<T> clone() const;
139 
141  static T* clone_vector(const T* vec, int32_t len);
142 
144  static void fill_vector(T* vec, int32_t len, T value);
145 
147  static void range_fill_vector(T* vec, int32_t len, T start=0);
148 
150  static void random_vector(T* vec, int32_t len, T min_value, T max_value);
151 
157  const T& get_element(index_t index);
158 
165  void set_element(const T& p_element, index_t index);
166 
172  void resize_vector(int32_t n);
173 
179  inline const T& operator[](uint64_t index) const
180  {
181  return vector[index];
182  }
183 
189  inline const T& operator[](int64_t index) const
190  {
191  return vector[index];
192  }
193 
199  inline const T& operator[](uint32_t index) const
200  {
201  return vector[index];
202  }
203 
209  inline const T& operator[](int32_t index) const
210  {
211  return vector[index];
212  }
213 
219  inline T& operator[](uint64_t index)
220  {
221  return vector[index];
222  }
223 
229  inline T& operator[](int64_t index)
230  {
231  return vector[index];
232  }
233 
239  inline T& operator[](uint32_t index)
240  {
241  return vector[index];
242  }
243 
249  inline T& operator[](int32_t index)
250  {
251  return vector[index];
252  }
253 
258  void add(const SGVector<T> x);
259 
264  void add(const SGSparseVector<T>& x);
265 
270  void add(const T x);
271 
274 
277  {
278  add(x);
279  return *this;
280  }
281 
284  {
285  add(x);
286  return *this;
287  }
288 
294  bool equals(SGVector<T>& other);
295 
297  static T twonorm(const T* x, int32_t len);
298 
300  static float64_t onenorm(T* x, int32_t len);
301 
303  static T qsq(T* x, int32_t len, float64_t q);
304 
306  static T qnorm(T* x, int32_t len, float64_t q);
307 
309  static void vec1_plus_scalar_times_vec2(T* vec1,
310  const T scalar, const T* vec2, int32_t n);
311 
313  static inline void vector_multiply(
314  T* target, const T* v1, const T* v2,int32_t len)
315  {
316  for (int32_t i=0; i<len; i++)
317  target[i]=v1[i]*v2[i];
318  }
319 
320 
322  static inline void add(
323  T* target, T alpha, const T* v1, T beta, const T* v2,
324  int32_t len)
325  {
326  for (int32_t i=0; i<len; i++)
327  target[i]=alpha*v1[i]+beta*v2[i];
328  }
329 
331  static inline void add_scalar(T alpha, T* vec, int32_t len)
332  {
333  for (int32_t i=0; i<len; i++)
334  vec[i]+=alpha;
335  }
336 
338  static void scale_vector(T alpha, T* vec, int32_t len);
339 
341  static inline T sum(T* vec, int32_t len)
342  {
343  T result=0;
344  for (int32_t i=0; i<len; i++)
345  result+=vec[i];
346 
347  return result;
348  }
349 
351  static inline T sum(SGVector<T> vec)
352  {
353  return sum(vec.vector, vec.vlen);
354  }
355 
357  static inline T product(T* vec, int32_t len)
358  {
359  T result=1;
360  for (int32_t i=0; i<len; i++)
361  result*=vec[i];
362 
363  return result;
364  }
365 
367  inline T product()
368  {
369  return product(vector, vlen);
370  }
371 
373  static T sum_abs(T* vec, int32_t len);
374 
378  static int32_t unique(T* output, int32_t size);
379 
381  void display_size() const;
382 
384  void display_vector(const char* name="vector",
385  const char* prefix="") const;
386 
388  static void display_vector(
389  const T* vector, int32_t n, const char* name="vector",
390  const char* prefix="");
391 
393  static void display_vector(
394  const SGVector<T>, const char* name="vector",
395  const char* prefix="");
396 
400  SGVector<index_t> find(T elem);
401 
405  template <typename Predicate>
407  {
408  SGVector<index_t> idx(vlen);
409  index_t k=0;
410 
411  for (index_t i=0; i < vlen; ++i)
412  if (p(vector[i]))
413  idx[k++] = i;
414 
415  idx.vlen = k;
416  return idx;
417  }
418 
420  void scale(T alpha);
421 
426  void load(CFile* loader);
427 
432  void save(CFile* saver);
433 
436 
439 
450  static SGMatrix<T> convert_to_matrix(SGVector<T> vector, index_t nrows, index_t ncols, bool fortran_order);
451 
452 
465  static void convert_to_matrix(T*& matrix, index_t nrows, index_t ncols, const T* vector, int32_t vlen, bool fortran_order);
466 #endif // #ifndef SWIG // SWIG should skip this part
467  protected:
469  virtual void copy_data(const SGReferencedData &orig);
470 
472  virtual void init_data();
473 
475  virtual void free_data();
476 
477  public:
479  T* vector;
482 };
483 
484 #ifndef DOXYGEN_SHOULD_SKIP_THIS
486  const float64_t scalar, const float64_t* vec2, int32_t n);
487 
489  const float32_t scalar, const float32_t* vec2, int32_t n);
490 #endif // DOXYGEN_SHOULD_SKIP_THIS
491 }
492 #endif // __SGVECTOR_H__

SHOGUN Machine Learning Toolbox - Documentation