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 template <class T> class CArray3;
00019 
00026 template <class T> class CArray3: public CArray<T>
00027 {
00028     public:
00030         CArray3()
00031         : CArray<T>(1), dim1_size(1), dim2_size(1), dim3_size(1)
00032         {
00033         }
00034 
00041         CArray3(int32_t dim1, int32_t dim2, int32_t dim3)
00042         : CArray<T>(dim1*dim2*dim3), dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00043         {
00044         }
00045 
00055         CArray3(T* p_array, int32_t dim1, int32_t dim2, int32_t dim3,
00056             bool p_free_array=true, bool p_copy_array=false)
00057         : CArray<T>(p_array, dim1*dim2*dim3, p_free_array, p_copy_array),
00058             dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00059         {
00060         }
00061 
00062 
00070         CArray3(const T* p_array, int32_t dim1, int32_t dim2, int32_t dim3)
00071         : CArray<T>(p_array, dim1*dim2*dim3),
00072             dim1_size(dim1), dim2_size(dim2), dim3_size(dim3)
00073         {
00074         }
00075 
00076         virtual ~CArray3() {}
00077 
00082         inline void set_name(const char * p_name)
00083         {
00084             CArray<T>::set_name(p_name);
00085         }
00086 
00093         inline void get_array_size(int32_t & dim1, int32_t & dim2, int32_t & dim3)
00094         {
00095             dim1=dim1_size;
00096             dim2=dim2_size;
00097             dim3=dim3_size;
00098         }
00099 
00104         inline int32_t get_dim1() { return dim1_size; }
00105 
00110         inline int32_t get_dim2() { return dim2_size; }
00111 
00116         inline int32_t get_dim3() { return dim3_size ;
00117         }
00118 
00120         inline void zero() { CArray<T>::zero(); }
00121 
00129         inline T* get_array() { return CArray<T>::array; }
00130 
00140         inline void set_array(T* p_array, int32_t dim1, int32_t dim2, int32_t dim3, bool p_free_array, bool copy_array=false)
00141         {
00142             dim1_size=dim1;
00143             dim2_size=dim2;
00144             dim3_size=dim3;
00145             CArray<T>::set_array(p_array, dim1*dim2*dim3, p_free_array, copy_array);
00146         }
00147 
00155         inline bool resize_array(int32_t dim1, int32_t dim2, int32_t dim3)
00156         {
00157             dim1_size=dim1;
00158             dim2_size=dim2;
00159             dim3_size=dim3;
00160             return CArray<T>::resize_array(dim1*dim2*dim3);
00161         }
00162 
00170         inline T get_element(int32_t idx1, int32_t idx2, int32_t idx3) const
00171         {
00172             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00173             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00174             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00175             return CArray<T>::get_element(idx1+dim1_size*(idx2+dim2_size*idx3));
00176         }
00177 
00186         inline bool set_element(T p_element, int32_t idx1, int32_t idx2, int32_t idx3)
00187         {
00188             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00189             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00190             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00191             return CArray<T>::set_element(p_element, idx1+dim1_size*(idx2+dim2_size*idx3));
00192         }
00193 
00201         inline const T& element(int32_t idx1, int32_t idx2, int32_t idx3) const
00202         {
00203             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00204             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00205             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00206             return CArray<T>::element(idx1+dim1_size*(idx2+dim2_size*idx3));
00207         }
00208 
00216         inline T& element(int32_t idx1, int32_t idx2, int32_t idx3)
00217         {
00218             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00219             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00220             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00221             return CArray<T>::element(idx1+dim1_size*(idx2+dim2_size*idx3));
00222         }
00223 
00232         inline T& element(T* p_array, int32_t idx1, int32_t idx2, int32_t idx3)
00233         {
00234             ARRAY_ASSERT(p_array==CArray<T>::array);
00235             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00236             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00237             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00238             return p_array[idx1+dim1_size*(idx2+dim2_size*idx3)];
00239         }
00240 
00251         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)
00252         {
00253             ARRAY_ASSERT(p_array==CArray<T>::array);
00254             ARRAY_ASSERT(p_dim1_size==dim1_size);
00255             ARRAY_ASSERT(p_dim2_size==dim2_size);
00256             ARRAY_ASSERT(idx1>=0 && idx1<p_dim1_size);
00257             ARRAY_ASSERT(idx2>=0 && idx2<p_dim2_size);
00258             ARRAY_ASSERT(idx3>=0 && idx3<dim3_size);
00259             return p_array[idx1+p_dim1_size*(idx2+p_dim2_size*idx3)];
00260         }
00261 
00267         CArray3<T>& operator=(const CArray3<T>& orig)
00268         {
00269             CArray<T>::operator=(orig);
00270             dim1_size=orig.dim1_size;
00271             dim2_size=orig.dim2_size;
00272             dim3_size=orig.dim3_size;
00273             return *this;
00274         }
00275 
00277         void display_size() const
00278         {
00279             CArray<T>::SG_PRINT( "3d-Array of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size);
00280         }
00281 
00283         void display_array() const
00284         {
00285             if (CArray<T>::get_name())
00286                 CArray<T>::SG_PRINT( "3d-Array '%s' of size: %dx%dx%d\n", CArray<T>::get_name(), dim1_size, dim2_size, dim3_size);
00287             else
00288                 CArray<T>::SG_PRINT( "2d-Array of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size);
00289             for (int32_t k=0; k<dim3_size; k++)
00290                 for (int32_t i=0; i<dim1_size; i++)
00291                 {
00292                     CArray<T>::SG_PRINT( "element(%d,:,%d) = [ ",i, k);
00293                     for (int32_t j=0; j<dim2_size; j++)
00294                         CArray<T>::SG_PRINT( "%1.1f,", (float32_t)element(i,j,k));
00295                     CArray<T>::SG_PRINT( " ]\n");
00296                 }
00297         }
00298 
00300         inline virtual const char* get_name() { return "Array3"; }
00301 
00302     protected:
00304         int32_t dim1_size;
00306         int32_t dim2_size;
00308         int32_t dim3_size;
00309 };
00310 #endif

SHOGUN Machine Learning Toolbox - Documentation