SHOGUN  v3.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DynamicArray.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) 1999-2009 Soeren Sonnenburg
8  * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
9  */
10 
11 #ifndef _DYNAMIC_ARRAY_H_
12 #define _DYNAMIC_ARRAY_H_
13 
14 #include <shogun/base/SGObject.h>
15 #include <shogun/base/DynArray.h>
16 #include <shogun/base/Parameter.h>
17 
18 namespace shogun
19 {
28 template <class T> class CDynamicArray :public CSGObject
29 {
30  public:
32  CDynamicArray()
33  : CSGObject(), m_array(), name("Array")
34  {
35  dim1_size=1;
36  dim2_size=1;
37  dim3_size=1;
38 
39  init();
40  }
41 
48  CDynamicArray(int32_t p_dim1_size, int32_t p_dim2_size=1, int32_t p_dim3_size=1)
49  : CSGObject(), m_array(p_dim1_size*p_dim2_size*p_dim3_size), name("Array")
50  {
51  dim1_size=p_dim1_size;
52  dim2_size=p_dim2_size;
53  dim3_size=p_dim3_size;
54 
55  init();
56  }
57 
65  CDynamicArray(T* p_array, int32_t p_dim1_size, bool p_free_array, bool p_copy_array)
66  : CSGObject(), m_array(p_array, p_dim1_size, p_free_array, p_copy_array), name("Array")
67  {
68  dim1_size=p_dim1_size;
69  dim2_size=1;
70  dim3_size=1;
71 
72  init();
73  }
74 
83  CDynamicArray(T* p_array, int32_t p_dim1_size, int32_t p_dim2_size,
84  bool p_free_array, bool p_copy_array)
85  : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size, p_free_array, p_copy_array), name("Array")
86  {
87  dim1_size=p_dim1_size;
88  dim2_size=p_dim2_size;
89  dim3_size=1;
90 
91  init();
92  }
93 
103  CDynamicArray(T* p_array, int32_t p_dim1_size, int32_t p_dim2_size,
104  int32_t p_dim3_size, bool p_free_array, bool p_copy_array)
105  : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size*p_dim3_size, p_free_array, p_copy_array), name("Array")
106  {
107  dim1_size=p_dim1_size;
108  dim2_size=p_dim2_size;
109  dim3_size=p_dim3_size;
110 
111  init();
112  }
113 
121  CDynamicArray(const T* p_array, int32_t p_dim1_size=1, int32_t p_dim2_size=1, int32_t p_dim3_size=1)
122  : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size*p_dim3_size), name("Array")
123  {
124  dim1_size=p_dim1_size;
125  dim2_size=p_dim2_size;
126  dim3_size=p_dim3_size;
127 
128  init();
129  }
130 
131  virtual ~CDynamicArray() {}
132 
138  inline int32_t set_granularity(int32_t g)
139  {
140  return m_array.set_granularity(g);
141  }
142 
147  inline int32_t get_array_size()
148  {
149  return m_array.get_array_size();
150  }
151 
157  inline void get_array_size(int32_t& dim1, int32_t& dim2)
158  {
159  dim1=dim1_size;
160  dim2=dim2_size;
161  }
162 
169  inline void get_array_size(int32_t& dim1, int32_t& dim2, int32_t& dim3)
170  {
171  dim1=dim1_size;
172  dim2=dim2_size;
173  dim3=dim3_size;
174  }
175 
180  inline int32_t get_dim1() { return dim1_size; }
181 
186  inline int32_t get_dim2() { return dim2_size; }
187 
192  inline int32_t get_dim3() { return dim3_size; }
193 
198  inline int32_t get_num_elements() const
199  {
200  return m_array.get_num_elements();
201  }
202 
210  inline const T& get_element(int32_t idx1, int32_t idx2=0, int32_t idx3=0) const
211  {
212  return m_array.get_array()[idx1+dim1_size*(idx2+dim2_size*idx3)];
213  }
214 
222  inline const T& element(int32_t idx1, int32_t idx2=0, int32_t idx3=0) const
223  {
224  return get_element(idx1, idx2, idx3);
225  }
226 
234  inline T& element(int32_t idx1, int32_t idx2=0, int32_t idx3=0)
235  {
236  return m_array.get_array()[idx1+dim1_size*(idx2+dim2_size*idx3)];
237  }
238 
247  inline T& element(T* p_array, int32_t idx1, int32_t idx2=0, int32_t idx3=0)
248  {
249  ASSERT(idx1>=0 && idx1<dim1_size)
250  ASSERT(idx2>=0 && idx2<dim2_size)
251  ASSERT(idx3>=0 && idx3<dim3_size)
252  return p_array[idx1+dim1_size*(idx2+dim2_size*idx3)];
253  }
254 
265  inline T& element(T* p_array, int32_t idx1, int32_t idx2, int32_t idx3, int32_t p_dim1_size, int32_t p_dim2_size)
266  {
267  ASSERT(p_dim1_size==dim1_size)
268  ASSERT(p_dim2_size==dim2_size)
269  ASSERT(idx1>=0 && idx1<p_dim1_size)
270  ASSERT(idx2>=0 && idx2<p_dim2_size)
271  ASSERT(idx3>=0 && idx3<dim3_size)
272  return p_array[idx1+p_dim1_size*(idx2+p_dim2_size*idx3)];
273  }
274 
279  inline T get_last_element() const
280  {
281  return m_array.get_last_element();
282  }
283 
291  inline T get_element_safe(int32_t index) const
292  {
293  return m_array.get_element_safe(index);
294  }
295 
304  inline bool set_element(T e, int32_t idx1, int32_t idx2=0, int32_t idx3=0)
305  {
306  return m_array.set_element(e, idx1+dim1_size*(idx2+dim2_size*idx3));
307  }
308 
315  inline bool insert_element(T e, int32_t index)
316  {
317  return m_array.insert_element(e, index);
318  }
319 
325  inline bool append_element(T e)
326  {
327  return m_array.append_element(e);
328  }
329 
335  inline void push_back(T e)
336  { m_array.push_back(e); }
337 
341  inline void pop_back()
342  {
343  m_array.pop_back();
344  }
345 
351  inline T back()
352  {
353  return m_array.back();
354  }
355 
362  inline int32_t find_element(T e)
363  {
364  return m_array.find_element(e);
365  }
366 
373  inline bool delete_element(int32_t idx)
374  {
375  return m_array.delete_element(idx);
376  }
377 
385  inline bool resize_array(int32_t ndim1, int32_t ndim2=1, int32_t ndim3=1)
386  {
387  dim1_size=ndim1;
388  dim2_size=ndim2;
389  dim3_size=ndim3;
390  return m_array.resize_array(ndim1*ndim2*ndim3);
391  }
392 
394  void set_const(const T& const_element)
395  {
396  m_array.set_const(const_element);
397  }
398 
406  inline T* get_array() const
407  {
408  return m_array.get_array();
409  }
410 
417  inline void set_array(T* p_array, int32_t p_num_elements,
418  int32_t array_size)
419  {
420  m_array.set_array(p_array, p_num_elements, array_size);
421  }
422 
430  inline void set_array(T* p_array, int32_t dim1,
431  bool p_free_array, bool copy_array)
432  {
433  dim1_size=dim1;
434  dim2_size=1;
435  dim3_size=1;
436  m_array.set_array(p_array, dim1, dim1, p_free_array, copy_array);
437  }
438 
447  inline void set_array(T* p_array, int32_t dim1,
448  int32_t dim2, bool p_free_array, bool copy_array)
449  {
450  dim1_size=dim1;
451  dim2_size=dim2;
452  dim3_size=1;
453 
454  m_array.set_array(p_array, dim1*dim2, dim1*dim2, p_free_array, copy_array);
455  }
456 
466  inline void set_array(T* p_array, int32_t dim1,
467  int32_t dim2, int32_t dim3, bool p_free_array, bool copy_array)
468  {
469  dim1_size=dim1;
470  dim2_size=dim2;
471  dim3_size=dim3;
472  m_array.set_array(p_array, dim1*dim2*dim3, dim1*dim2*dim3, p_free_array, copy_array);
473  }
474 
480  inline void set_array(const T* p_array, int32_t p_size)
481  {
482  m_array.set_array(p_array, p_size, p_size);
483  }
484 
488  inline void clear_array(T value)
489  {
490  m_array.clear_array(value);
491  }
492 
494  inline void reset_array()
495  {
496  m_array.reset((T) 0);
497  }
498 
508  inline const T& operator[](int32_t index) const
509  {
510  return get_element(index);
511  }
512 
520  inline T& operator[](int32_t index)
521  {
522  return element(index);
523  }
524 
530  inline CDynamicArray<T>& operator=(CDynamicArray<T>& orig)
531  {
532  m_array=orig.m_array;
533  dim1_size=orig.dim1_size;
534  dim2_size=orig.dim2_size;
535  dim3_size=orig.dim3_size;
536 
537  return *this;
538  }
539 
541  inline void shuffle() { m_array.shuffle(); }
542 
544  inline void shuffle(CRandom * rand) { m_array.shuffle(rand); }
545 
550  inline void set_array_name(const char* p_name)
551  {
552  name=p_name;
553  }
554 
559  inline const char* get_array_name() const { return name; }
560 
562  inline void display_array()
563  {
564  if (get_name())
565  SG_PRINT("DynamicArray '%s' of size: %dx%dx%d\n", get_name(), dim1_size, dim2_size, dim3_size)
566  else
567  SG_PRINT("DynamicArray of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size)
568 
569  for (int32_t k=0; k<dim3_size; k++)
570  for (int32_t i=0; i<dim1_size; i++)
571  {
572  SG_PRINT("element(%d,:,%d) = [ ",i, k)
573  for (int32_t j=0; j<dim2_size; j++)
574  SG_PRINT("%1.1f,", (float32_t) element(i,j,k))
575  SG_PRINT(" ]\n")
576  }
577  }
578 
580  inline void display_size()
581  {
582  SG_PRINT("DynamicArray of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size)
583  }
584 
586  virtual const char* get_name() const
587  {
588  return "DynamicArray";
589  }
590 
599  virtual void load_serializable_pre() throw (ShogunException)
600  {
601  CSGObject::load_serializable_pre();
602 
603  m_array.resize_array(m_array.get_num_elements(), true);
604  }
605 
614  virtual void save_serializable_pre() throw (ShogunException)
615  {
616  CSGObject::save_serializable_pre();
617  m_array.resize_array(m_array.get_num_elements(), true);
618  }
619 
620 
621  private:
622 
624  virtual void init()
625  {
626  set_generic<T>();
627 
628  m_parameters->add_vector(&m_array.array,
629  &m_array.current_num_elements, "array",
630  "Memory for dynamic array.");
631  SG_ADD(&m_array.num_elements,
632  "num_elements",
633  "Number of Elements.", MS_NOT_AVAILABLE);
634  SG_ADD(&m_array.resize_granularity,
635  "resize_granularity",
636  "shrink/grow step size.", MS_NOT_AVAILABLE);
637  SG_ADD(&m_array.use_sg_mallocs,
638  "use_sg_malloc",
639  "whether SG_MALLOC or malloc should be used",
640  MS_NOT_AVAILABLE);
641  SG_ADD(&m_array.free_array,
642  "free_array",
643  "whether array must be freed",
644  MS_NOT_AVAILABLE);
645  }
646 
647  protected:
648 
650  DynArray<T> m_array;
651 
653  int32_t dim1_size;
654 
656  int32_t dim2_size;
657 
659  int32_t dim3_size;
660 
662  const char* name;
663 };
664 }
665 #endif /* _DYNAMIC_ARRAY_H_ */
SHOGUN Machine Learning Toolbox - Documentation