Array3.h

Go to the documentation of this file.
00001 /*
00002  * This program is free software; you can redistribute it and/or modify
00003  * it under the terms of the GNU General Public License as published by
00004  * the Free Software Foundation; either version 3 of the License, or
00005  * (at your option) any later version.
00006  *
00007  * Written (W) 1999-2009 Soeren Sonnenburg, Gunnar Raetsch
00008  * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
00009  */
00010 
00011 #ifndef _ARRAY3_H_
00012 #define _ARRAY3_H_
00013 
00014 #include "lib/common.h"
00015 #include "base/SGObject.h"
00016 #include "lib/Array.h"
00017 
00018 namespace shogun
00019 {
00020 template <class T> class CArray3;
00021 
00028 template <class T> class CArray3: public CArray<T>
00029 {
00030     public:
00032         CArray3()
00033         : CArray<T>(1), dim1_size(1), dim2_size(1), dim3_size(1)
00034         {
00035         }
00036 
00043         CArray3(int32_t dim1, int32_t dim2, int32_t dim3)
00044         : CArray<T>(dim1*dim2*dim3), dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00045         {
00046         }
00047 
00057         CArray3(T* p_array, int32_t dim1, int32_t dim2, int32_t dim3,
00058             bool p_free_array=true, bool p_copy_array=false)
00059         : CArray<T>(p_array, dim1*dim2*dim3, p_free_array, p_copy_array),
00060             dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00061         {
00062         }
00063 
00064 
00072         CArray3(const T* p_array, int32_t dim1, int32_t dim2, int32_t dim3)
00073         : CArray<T>(p_array, dim1*dim2*dim3),
00074             dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00075         {
00076         }
00077 
00078         virtual ~CArray3() {}
00079 
00084         inline void set_name(const char * p_name)
00085         {
00086             CArray<T>::set_name(p_name);
00087         }
00088 
00095         inline void get_array_size(int32_t & dim1, int32_t & dim2, int32_t & dim3)
00096         {
00097             dim1=dim1_size;
00098             dim2=dim2_size;
00099             dim3=dim3_size;
00100         }
00101 
00106         inline int32_t get_dim1() { return dim1_size; }
00107 
00112         inline int32_t get_dim2() { return dim2_size; }
00113 
00118         inline int32_t get_dim3() { return dim3_size ;
00119         }
00120 
00122         inline void zero() { CArray<T>::zero(); }
00123 
00125         inline void set_const(T const_elem)
00126         {
00127             CArray<T>::set_const(const_elem) ;
00128         }
00129 
00137         inline T* get_array() { return CArray<T>::array; }
00138 
00148         inline void set_array(T* p_array, int32_t dim1, int32_t dim2, int32_t dim3, bool p_free_array, bool copy_array=false)
00149         {
00150             dim1_size=dim1;
00151             dim2_size=dim2;
00152             dim3_size=dim3;
00153             CArray<T>::set_array(p_array, dim1*dim2*dim3, p_free_array, copy_array);
00154         }
00155 
00163         inline bool resize_array(int32_t dim1, int32_t dim2, int32_t dim3)
00164         {
00165             dim1_size=dim1;
00166             dim2_size=dim2;
00167             dim3_size=dim3;
00168             return CArray<T>::resize_array(dim1*dim2*dim3);
00169         }
00170 
00178         inline T get_element(int32_t idx1, int32_t idx2, int32_t idx3) const
00179         {
00180             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00181             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00182             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00183             return CArray<T>::get_element(idx1+dim1_size*(idx2+dim2_size*idx3));
00184         }
00185 
00194         inline bool set_element(T p_element, int32_t idx1, int32_t idx2, int32_t idx3)
00195         {
00196             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00197             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00198             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00199             return CArray<T>::set_element(p_element, idx1+dim1_size*(idx2+dim2_size*idx3));
00200         }
00201 
00209         inline const T& element(int32_t idx1, int32_t idx2, int32_t idx3) const
00210         {
00211             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00212             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00213             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00214             return CArray<T>::element(idx1+dim1_size*(idx2+dim2_size*idx3));
00215         }
00216 
00224         inline T& element(int32_t idx1, int32_t idx2, int32_t idx3)
00225         {
00226             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00227             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00228             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00229             return CArray<T>::element(idx1+dim1_size*(idx2+dim2_size*idx3));
00230         }
00231 
00240         inline T& element(T* p_array, int32_t idx1, int32_t idx2, int32_t idx3)
00241         {
00242             ARRAY_ASSERT(p_array==CArray<T>::array);
00243             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00244             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00245             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00246             return p_array[idx1+dim1_size*(idx2+dim2_size*idx3)];
00247         }
00248 
00259         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)
00260         {
00261             ARRAY_ASSERT(p_array==CArray<T>::array);
00262             ARRAY_ASSERT(p_dim1_size==dim1_size);
00263             ARRAY_ASSERT(p_dim2_size==dim2_size);
00264             ARRAY_ASSERT(idx1>=0 && idx1<p_dim1_size);
00265             ARRAY_ASSERT(idx2>=0 && idx2<p_dim2_size);
00266             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00267             return p_array[idx1+p_dim1_size*(idx2+p_dim2_size*idx3)];
00268         }
00269 
00275         CArray3<T>& operator=(const CArray3<T>& orig)
00276         {
00277             CArray<T>::operator=(orig);
00278             dim1_size=orig.dim1_size;
00279             dim2_size=orig.dim2_size;
00280             dim3_size=orig.dim3_size;
00281             return *this;
00282         }
00283 
00285         void display_size() const
00286         {
00287             CArray<T>::SG_PRINT( "3d-Array of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size);
00288         }
00289 
00291         void display_array() const
00292         {
00293             if (CArray<T>::get_name())
00294                 CArray<T>::SG_PRINT( "3d-Array '%s' of size: %dx%dx%d\n", CArray<T>::get_name(), dim1_size, dim2_size, dim3_size);
00295             else
00296                 CArray<T>::SG_PRINT( "2d-Array of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size);
00297             for (int32_t k=0; k<dim3_size; k++)
00298                 for (int32_t i=0; i<dim1_size; i++)
00299                 {
00300                     CArray<T>::SG_PRINT( "element(%d,:,%d) = [ ",i, k);
00301                     for (int32_t j=0; j<dim2_size; j++)
00302                         CArray<T>::SG_PRINT( "%1.1f,", (float32_t)element(i,j,k));
00303                     CArray<T>::SG_PRINT( " ]\n");
00304                 }
00305         }
00306 
00308         inline virtual const char* get_name() { return "Array3"; }
00309 
00310     protected:
00312         int32_t dim1_size;
00314         int32_t dim2_size;
00316         int32_t dim3_size;
00317 };
00318 }
00319 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation