SHOGUN  3.2.1
 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/lib/config.h>
15 
16 #include <shogun/base/SGObject.h>
17 #include <shogun/base/DynArray.h>
18 #include <shogun/base/Parameter.h>
19 
20 namespace shogun
21 {
30 template <class T> class CDynamicArray :public CSGObject
31 {
32  public:
35  : CSGObject(), m_array(), name("Array")
36  {
37  dim1_size=1;
38  dim2_size=1;
39  dim3_size=1;
40 
41  init();
42  }
43 
50  CDynamicArray(int32_t p_dim1_size, int32_t p_dim2_size=1, int32_t p_dim3_size=1)
51  : CSGObject(), m_array(p_dim1_size*p_dim2_size*p_dim3_size), name("Array")
52  {
53  dim1_size=p_dim1_size;
54  dim2_size=p_dim2_size;
55  dim3_size=p_dim3_size;
56 
57  init();
58  }
59 
67  CDynamicArray(T* p_array, int32_t p_dim1_size, bool p_free_array, bool p_copy_array)
68  : CSGObject(), m_array(p_array, p_dim1_size, p_free_array, p_copy_array), name("Array")
69  {
70  dim1_size=p_dim1_size;
71  dim2_size=1;
72  dim3_size=1;
73 
74  init();
75  }
76 
85  CDynamicArray(T* p_array, int32_t p_dim1_size, int32_t p_dim2_size,
86  bool p_free_array, bool p_copy_array)
87  : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size, p_free_array, p_copy_array), name("Array")
88  {
89  dim1_size=p_dim1_size;
90  dim2_size=p_dim2_size;
91  dim3_size=1;
92 
93  init();
94  }
95 
105  CDynamicArray(T* p_array, int32_t p_dim1_size, int32_t p_dim2_size,
106  int32_t p_dim3_size, bool p_free_array, bool p_copy_array)
107  : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size*p_dim3_size, p_free_array, p_copy_array), name("Array")
108  {
109  dim1_size=p_dim1_size;
110  dim2_size=p_dim2_size;
111  dim3_size=p_dim3_size;
112 
113  init();
114  }
115 
123  CDynamicArray(const T* p_array, int32_t p_dim1_size=1, int32_t p_dim2_size=1, int32_t p_dim3_size=1)
124  : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size*p_dim3_size), name("Array")
125  {
126  dim1_size=p_dim1_size;
127  dim2_size=p_dim2_size;
128  dim3_size=p_dim3_size;
129 
130  init();
131  }
132 
133  virtual ~CDynamicArray() {}
134 
140  inline int32_t set_granularity(int32_t g)
141  {
142  return m_array.set_granularity(g);
143  }
144 
149  inline int32_t get_array_size()
150  {
151  return m_array.get_array_size();
152  }
153 
159  inline void get_array_size(int32_t& dim1, int32_t& dim2)
160  {
161  dim1=dim1_size;
162  dim2=dim2_size;
163  }
164 
171  inline void get_array_size(int32_t& dim1, int32_t& dim2, int32_t& dim3)
172  {
173  dim1=dim1_size;
174  dim2=dim2_size;
175  dim3=dim3_size;
176  }
177 
182  inline int32_t get_dim1() { return dim1_size; }
183 
188  inline int32_t get_dim2() { return dim2_size; }
189 
194  inline int32_t get_dim3() { return dim3_size; }
195 
200  inline int32_t get_num_elements() const
201  {
202  return m_array.get_num_elements();
203  }
204 
212  inline const T& get_element(int32_t idx1, int32_t idx2=0, int32_t idx3=0) const
213  {
214  return m_array.get_array()[idx1+dim1_size*(idx2+dim2_size*idx3)];
215  }
216 
224  inline const T& element(int32_t idx1, int32_t idx2=0, int32_t idx3=0) const
225  {
226  return get_element(idx1, idx2, idx3);
227  }
228 
236  inline T& element(int32_t idx1, int32_t idx2=0, int32_t idx3=0)
237  {
238  return m_array.get_array()[idx1+dim1_size*(idx2+dim2_size*idx3)];
239  }
240 
249  inline T& element(T* p_array, int32_t idx1, int32_t idx2=0, int32_t idx3=0)
250  {
251  ASSERT(idx1>=0 && idx1<dim1_size)
252  ASSERT(idx2>=0 && idx2<dim2_size)
253  ASSERT(idx3>=0 && idx3<dim3_size)
254  return p_array[idx1+dim1_size*(idx2+dim2_size*idx3)];
255  }
256 
267  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)
268  {
269  ASSERT(p_dim1_size==dim1_size)
270  ASSERT(p_dim2_size==dim2_size)
271  ASSERT(idx1>=0 && idx1<p_dim1_size)
272  ASSERT(idx2>=0 && idx2<p_dim2_size)
273  ASSERT(idx3>=0 && idx3<dim3_size)
274  return p_array[idx1+p_dim1_size*(idx2+p_dim2_size*idx3)];
275  }
276 
281  inline T get_last_element() const
282  {
283  return m_array.get_last_element();
284  }
285 
293  inline T get_element_safe(int32_t index) const
294  {
295  return m_array.get_element_safe(index);
296  }
297 
306  inline bool set_element(T e, int32_t idx1, int32_t idx2=0, int32_t idx3=0)
307  {
308  return m_array.set_element(e, idx1+dim1_size*(idx2+dim2_size*idx3));
309  }
310 
317  inline bool insert_element(T e, int32_t index)
318  {
319  return m_array.insert_element(e, index);
320  }
321 
327  inline bool append_element(T e)
328  {
329  return m_array.append_element(e);
330  }
331 
337  inline void push_back(T e)
338  { m_array.push_back(e); }
339 
343  inline void pop_back()
344  {
345  m_array.pop_back();
346  }
347 
353  inline T back()
354  {
355  return m_array.back();
356  }
357 
364  inline int32_t find_element(T e)
365  {
366  return m_array.find_element(e);
367  }
368 
375  inline bool delete_element(int32_t idx)
376  {
377  return m_array.delete_element(idx);
378  }
379 
387  inline bool resize_array(int32_t ndim1, int32_t ndim2=1, int32_t ndim3=1)
388  {
389  dim1_size=ndim1;
390  dim2_size=ndim2;
391  dim3_size=ndim3;
392  return m_array.resize_array(ndim1*ndim2*ndim3);
393  }
394 
396  void set_const(const T& const_element)
397  {
398  m_array.set_const(const_element);
399  }
400 
408  inline T* get_array() const
409  {
410  return m_array.get_array();
411  }
412 
419  inline void set_array(T* p_array, int32_t p_num_elements,
420  int32_t array_size)
421  {
422  m_array.set_array(p_array, p_num_elements, array_size);
423  }
424 
432  inline void set_array(T* p_array, int32_t dim1,
433  bool p_free_array, bool copy_array)
434  {
435  dim1_size=dim1;
436  dim2_size=1;
437  dim3_size=1;
438  m_array.set_array(p_array, dim1, dim1, p_free_array, copy_array);
439  }
440 
449  inline void set_array(T* p_array, int32_t dim1,
450  int32_t dim2, bool p_free_array, bool copy_array)
451  {
452  dim1_size=dim1;
453  dim2_size=dim2;
454  dim3_size=1;
455 
456  m_array.set_array(p_array, dim1*dim2, dim1*dim2, p_free_array, copy_array);
457  }
458 
468  inline void set_array(T* p_array, int32_t dim1,
469  int32_t dim2, int32_t dim3, bool p_free_array, bool copy_array)
470  {
471  dim1_size=dim1;
472  dim2_size=dim2;
473  dim3_size=dim3;
474  m_array.set_array(p_array, dim1*dim2*dim3, dim1*dim2*dim3, p_free_array, copy_array);
475  }
476 
482  inline void set_array(const T* p_array, int32_t p_size)
483  {
484  m_array.set_array(p_array, p_size, p_size);
485  }
486 
490  inline void clear_array(T value)
491  {
492  m_array.clear_array(value);
493  }
494 
496  inline void reset_array()
497  {
498  m_array.reset((T) 0);
499  }
500 
510  inline const T& operator[](int32_t index) const
511  {
512  return get_element(index);
513  }
514 
522  inline T& operator[](int32_t index)
523  {
524  return element(index);
525  }
526 
533  {
534  m_array=orig.m_array;
535  dim1_size=orig.dim1_size;
536  dim2_size=orig.dim2_size;
537  dim3_size=orig.dim3_size;
538 
539  return *this;
540  }
541 
543  inline void shuffle() { m_array.shuffle(); }
544 
546  inline void shuffle(CRandom * rand) { m_array.shuffle(rand); }
547 
552  inline void set_array_name(const char* p_name)
553  {
554  name=p_name;
555  }
556 
561  inline const char* get_array_name() const { return name; }
562 
564  inline void display_array()
565  {
566  if (get_name())
567  SG_PRINT("DynamicArray '%s' of size: %dx%dx%d\n", get_name(), dim1_size, dim2_size, dim3_size)
568  else
569  SG_PRINT("DynamicArray of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size)
570 
571  for (int32_t k=0; k<dim3_size; k++)
572  for (int32_t i=0; i<dim1_size; i++)
573  {
574  SG_PRINT("element(%d,:,%d) = [ ",i, k)
575  for (int32_t j=0; j<dim2_size; j++)
576  SG_PRINT("%1.1f,", (float32_t) element(i,j,k))
577  SG_PRINT(" ]\n")
578  }
579  }
580 
582  inline void display_size()
583  {
584  SG_PRINT("DynamicArray of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size)
585  }
586 
588  virtual const char* get_name() const
589  {
590  return "DynamicArray";
591  }
592 
601  virtual void load_serializable_pre() throw (ShogunException)
602  {
604 
605  m_array.resize_array(m_array.get_num_elements(), true);
606  }
607 
616  virtual void save_serializable_pre() throw (ShogunException)
617  {
619  m_array.resize_array(m_array.get_num_elements(), true);
620  }
621 
622 
623  private:
624 
626  virtual void init()
627  {
628  set_generic<T>();
629 
631  &m_array.current_num_elements, "array",
632  "Memory for dynamic array.");
633  SG_ADD(&m_array.num_elements,
634  "num_elements",
635  "Number of Elements.", MS_NOT_AVAILABLE);
636  SG_ADD(&m_array.resize_granularity,
637  "resize_granularity",
638  "shrink/grow step size.", MS_NOT_AVAILABLE);
639  SG_ADD(&m_array.use_sg_mallocs,
640  "use_sg_malloc",
641  "whether SG_MALLOC or malloc should be used",
643  SG_ADD(&m_array.free_array,
644  "free_array",
645  "whether array must be freed",
647  }
648 
649  protected:
650 
653 
655  int32_t dim1_size;
656 
658  int32_t dim2_size;
659 
661  int32_t dim3_size;
662 
664  const char* name;
665 };
666 }
667 #endif /* _DYNAMIC_ARRAY_H_ */

SHOGUN Machine Learning Toolbox - Documentation