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-2008 Soeren Sonnenburg, Gunnar Raetsch
00008  * Copyright (C) 1999-2008 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 template <class T> class CArray3;
00019 
00020 
00022 template <class T> class CArray3: public CArray<T>
00023 {
00024     public:
00026         CArray3()
00027         : CArray<T>(1), dim1_size(1), dim2_size(1), dim3_size(1)
00028         {
00029         }
00030 
00037         CArray3(INT dim1, INT dim2, INT dim3)
00038         : CArray<T>(dim1*dim2*dim3), dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00039         {
00040         }
00041 
00051         CArray3(T* p_array, INT dim1, INT dim2, INT dim3,
00052             bool p_free_array=true, bool p_copy_array=false)
00053         : CArray<T>(p_array, dim1*dim2*dim3, p_free_array, p_copy_array),
00054             dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00055         {
00056         }
00057 
00058 
00066         CArray3(const T* p_array, INT dim1, INT dim2, INT dim3)
00067         : CArray<T>(p_array, dim1*dim2*dim3),
00068             dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00069         {
00070         }
00071 
00072         ~CArray3() {}
00073 
00078         inline void set_name(const char * p_name)
00079         {
00080             CArray<T>::set_name(p_name);
00081         }
00082 
00089         inline void get_array_size(INT & dim1, INT & dim2, INT & dim3)
00090         {
00091             dim1=dim1_size;
00092             dim2=dim2_size;
00093             dim3=dim3_size;
00094         }
00095 
00100         inline INT get_dim1() { return dim1_size; }
00101 
00106         inline INT get_dim2() { return dim2_size; }
00107 
00112         inline INT get_dim3() { return dim3_size ;
00113         }
00114 
00116         inline void zero() { CArray<T>::zero(); }
00117 
00125         inline T* get_array() { return CArray<T>::array; }
00126 
00136         inline void set_array(T* p_array, INT dim1, INT dim2, INT dim3, bool p_free_array, bool copy_array=false)
00137         {
00138             dim1_size=dim1;
00139             dim2_size=dim2;
00140             dim3_size=dim3;
00141             CArray<T>::set_array(p_array, dim1*dim2*dim3, p_free_array, copy_array);
00142         }
00143 
00151         inline bool resize_array(INT dim1, INT dim2, INT dim3)
00152         {
00153             dim1_size=dim1;
00154             dim2_size=dim2;
00155             dim3_size=dim3;
00156             return CArray<T>::resize_array(dim1*dim2*dim3);
00157         }
00158 
00166         inline T get_element(INT idx1, INT idx2, INT idx3) const
00167         {
00168             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00169             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00170             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00171             return CArray<T>::get_element(idx1+dim1_size*(idx2+dim2_size*idx3));
00172         }
00173 
00182         inline bool set_element(T p_element, INT idx1, INT idx2, INT idx3)
00183         {
00184             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00185             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00186             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00187             return CArray<T>::set_element(p_element, idx1+dim1_size*(idx2+dim2_size*idx3));
00188         }
00189 
00197         inline const T& element(INT idx1, INT idx2, INT idx3) const
00198         {
00199             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00200             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00201             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00202             return CArray<T>::element(idx1+dim1_size*(idx2+dim2_size*idx3));
00203         }
00204 
00212         inline T& element(INT idx1, INT idx2, INT idx3)
00213         {
00214             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00215             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00216             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00217             return CArray<T>::element(idx1+dim1_size*(idx2+dim2_size*idx3));
00218         }
00219 
00228         inline T& element(T* p_array, INT idx1, INT idx2, INT idx3)
00229         {
00230             ARRAY_ASSERT(p_array==CArray<T>::array);
00231             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00232             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00233             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00234             return p_array[idx1+dim1_size*(idx2+dim2_size*idx3)];
00235         }
00236 
00247         inline T& element(T* p_array, INT idx1, INT idx2, INT idx3, INT p_dim1_size, INT p_dim2_size)
00248         {
00249             ARRAY_ASSERT(p_array==CArray<T>::array);
00250             ARRAY_ASSERT(p_dim1_size==dim1_size);
00251             ARRAY_ASSERT(p_dim2_size==dim2_size);
00252             ARRAY_ASSERT(idx1>=0 && idx1<p_dim1_size);
00253             ARRAY_ASSERT(idx2>=0 && idx2<p_dim2_size);
00254             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00255             return p_array[idx1+p_dim1_size*(idx2+p_dim2_size*idx3)];
00256         }
00257 
00263         CArray3<T>& operator=(const CArray3<T>& orig)
00264         {
00265             CArray<T>::operator=(orig);
00266             dim1_size=orig.dim1_size;
00267             dim2_size=orig.dim2_size;
00268             dim3_size=orig.dim3_size;
00269             return *this;
00270         }
00271 
00273         void display_size() const
00274         {
00275             CArray<T>::SG_PRINT( "3d-Array of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size);
00276         }
00277 
00279         void display_array() const
00280         {
00281             if (CArray<T>::get_name())
00282                 CArray<T>::SG_PRINT( "3d-Array '%s' of size: %dx%dx%d\n", CArray<T>::get_name(), dim1_size, dim2_size, dim3_size);
00283             else
00284                 CArray<T>::SG_PRINT( "2d-Array of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size);
00285             for (INT k=0; k<dim3_size; k++)
00286                 for (INT i=0; i<dim1_size; i++)
00287                 {
00288                     CArray<T>::SG_PRINT( "element(%d,:,%d) = [ ",i, k);
00289                     for (INT j=0; j<dim2_size; j++)
00290                         CArray<T>::SG_PRINT( "%1.1f,", (float)element(i,j,k));
00291                     CArray<T>::SG_PRINT( " ]\n");
00292                 }
00293         }
00294 
00295     protected:
00297         INT dim1_size;
00299         INT dim2_size;
00301         INT dim3_size;
00302 };
00303 #endif

SHOGUN Machine Learning Toolbox - Documentation