Array2.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 _ARRAY2_H_
00012 #define _ARRAY2_H_
00013 
00014 #include "lib/common.h"
00015 #include "base/SGObject.h"
00016 #include "lib/Array.h"
00017 
00018 template <class T> class CArray2;
00019 
00021 template <class T> class CArray2: public CArray<T>
00022 {
00023     public:
00029         CArray2(INT dim1, INT dim2)
00030         : CArray<T>(dim1*dim2), dim1_size(dim1), dim2_size(dim2)
00031         {
00032         }
00033 
00042         CArray2(T* p_array, INT dim1, INT dim2, bool p_free_array=true, bool p_copy_array=false)
00043         : CArray<T>(p_array, dim1*dim2, p_free_array, p_copy_array),
00044             dim1_size(dim1), dim2_size(dim2)
00045         {
00046         }
00047 
00054         CArray2(const T* p_array, INT dim1, INT dim2)
00055         : CArray<T>(p_array, dim1*dim2), dim1_size(dim1), dim2_size(dim2)
00056         {
00057         }
00058 
00059         ~CArray2() {}
00060 
00066         inline void get_array_size(INT & dim1, INT & dim2)
00067         {
00068             dim1=dim1_size;
00069             dim2=dim2_size;
00070         }
00071 
00076         inline INT get_dim1() { return dim1_size; }
00077 
00082         inline INT get_dim2() { return dim2_size; }
00083 
00085         inline void zero() { CArray<T>::zero(); }
00086 
00094         inline T* get_array() { return CArray<T>::array; }
00095 
00100         inline void set_name(const char * p_name)
00101         {
00102             CArray<T>::set_name(p_name);
00103         }
00104 
00113         inline void set_array(T* p_array, INT dim1, INT dim2, bool p_free_array=true, bool copy_array=false)
00114         {
00115             dim1_size=dim1;
00116             dim2_size=dim2;
00117             CArray<T>::set_array(p_array, dim1*dim2, p_free_array, copy_array);
00118         }
00119 
00126         inline bool resize_array(INT dim1, INT dim2)
00127         {
00128             dim1_size=dim1;
00129             dim2_size=dim2;
00130             return CArray<T>::resize_array(dim1*dim2);
00131         }
00132 
00139         inline const T& get_element(INT idx1, INT idx2) const
00140         {
00141             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00142             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00143             return CArray<T>::get_element(idx1+dim1_size*idx2);
00144         }
00145 
00153         inline bool set_element(const T& p_element, INT idx1, INT idx2)
00154         {
00155             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00156             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00157             return CArray<T>::set_element(p_element, idx1+dim1_size*idx2);
00158         }
00159 
00166         inline const T& element(INT idx1, INT idx2) const
00167         {
00168             return get_element(idx1,idx2);
00169         }
00170 
00177         inline T& element(INT idx1, INT idx2)
00178         {
00179             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00180             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00181             return CArray<T>::element(idx1+dim1_size*idx2);
00182         }
00183 
00191         inline T& element(T* p_array, INT idx1, INT idx2)
00192         {
00193             ARRAY_ASSERT(CArray<T>::array==p_array);
00194             ARRAY_ASSERT(idx1>=0 && idx1<dim1_size);
00195             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00196             return p_array[idx1+dim1_size*idx2];
00197         }
00198 
00207         inline T& element(T* p_array, INT idx1, INT idx2, INT p_dim1_size) 
00208         {
00209             ARRAY_ASSERT(CArray<T>::array==p_array);
00210             ARRAY_ASSERT(p_dim1_size==dim1_size);
00211             ARRAY_ASSERT(idx1>=0 && idx1<p_dim1_size);
00212             ARRAY_ASSERT(idx2>=0 && idx2<dim2_size);
00213             return p_array[idx1+p_dim1_size*idx2];
00214         }
00215 
00221         CArray2<T>& operator=(CArray2<T>& orig)
00222         {
00223             CArray<T>::operator=(orig);
00224             dim1_size=orig.dim1_size;
00225             dim2_size=orig.dim2_size;
00226             return *this;
00227         }
00228 
00230         void display_array() const
00231         {
00232             if (CArray<T>::get_name())
00233                 CArray<T>::SG_PRINT( "2d-Array '%s' of size: %dx%d\n", CArray<T>::get_name(), dim1_size,dim2_size);
00234             else
00235                 CArray<T>::SG_PRINT( "2d-Array of size: %dx%d\n",dim1_size,dim2_size);
00236             for (INT i=0; i<dim1_size; i++)
00237             {
00238                 CArray<T>::SG_PRINT( "element(%d,:) = [ ",i);
00239                 for (INT j=0; j<dim2_size; j++)
00240                     CArray<T>::SG_PRINT( "%1.1f,", (float) element(i,j));
00241                 CArray<T>::SG_PRINT( " ]\n");
00242             }
00243         }
00244 
00246         void display_size() const
00247         {
00248             CArray<T>::SG_PRINT( "2d-Array of size: %dx%d\n",dim1_size,dim2_size);
00249         }
00250 
00251     protected:
00253         INT dim1_size;
00255         INT dim2_size;
00256 };
00257 #endif

SHOGUN Machine Learning Toolbox - Documentation