---

array2d.h

Go to the documentation of this file.

/*
 * Copyright (c) 2001 The AUTHORS 
 *   Romeu Andre' Pieritz, Ph.D.        - romeu_pieritz@hotmail.com
 *   Rafael Mendes, Eng.                – mendes_rafael@yahoo.com
 *   Rodrigo Ferraz de Andrade, Eng.    – rferraz@iname.com 
 * All rights reserved.
 *
 * Permission to use, copy and distribute this software and its
 * documentation for educational and personal use, without fee is hereby granted, 
 * provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS
 * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE AUTHORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HERE UNDER IS
 * ON AN "AS IS" BASIS, AND THE AUTHORS HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * SINMEC Lab. - CFD Sinflow Project - http://www.sinmec.ufsc.br/cfd
 */


// File Define
#ifndef __CSFL_SYS_MATH_ARRAY2D_H__
#define __CSFL_SYS_MATH_ARRAY2D_H__


// Include
#include <csfl/sys/core/sflobject.h>
#include <csfl/sys/geom/point.h>
#include <csfl/sys/geom/size.h>


// Namespace
namespace csfl {


        
template <class T>
class IArray2D 

{
public:

        IArray2D( int _row, int _col, T ** _data = NULL );
        IArray2D( const ISize &, T ** = NULL );
        IArray2D( IArray2D<T> * );

        ~IArray2D();

        virtual IArray2D<T> & operator =( const IArray2D<T> & );

    inline T & operator () ( int _row, int _col )  { return data[_row][_col]; }

        inline T ** Data() { return data; }
        
        inline const ISize & Size() const { return size; }

        inline T Value( const IPoint &_p ) const { return data[_p.x][_p.y]; }
    inline T Value( int _x, int _y ) const { return data[_x][_y]; }

        inline T & Value( const IPoint &_p ) { return data[_p.x][_p.y]; }
        inline T & Value( int _x, int _y ) { return data[_x][_y]; }

    inline void SetValue( const IPoint &_p, T _value );
    inline void SetValue( int _x, int _y, T _value );

    inline void AddValue( const IPoint &_p, T _value );
        inline void AddValue( int _x, int _y, T _value );

        IArray2D<T> * Row( int _nrow );
        
        IArray2D<T> * Column( int _ncolumn);

private:
        void AllocData();
        void FreeData();
        bool CopyData( T ** );

protected:
        ISize size;
        T **data;
};

// Template Class Methods Implementation =======================================

template <class T>
IArray2D<T>::IArray2D( int _row, int _col, T **_data )
{
    size = ISize( _row, _col );
        AllocData();
        CopyData( _data );
}

template <class T>
IArray2D<T>::IArray2D( const ISize &_size, T **_data )
{
        size = _size;
        AllocData();
        CopyData( _data );
}

template <class T>
IArray2D<T>::IArray2D( IArray2D<T> *_m )
{
        size = _m->size;
        AllocData();
        CopyData( _m->data );
}

template <class T>
IArray2D<T>::~IArray2D()
{
        FreeData();
}

template <class T>
inline IArray2D<T> & IArray2D<T>::operator = ( const IArray2D<T> &_m )
{
        if (size != _m.size) {
                FreeData();
                size = _m.size;
                AllocData();
        }
        CopyData( _m.data );
                
        return *this;
}

template <class T>
void IArray2D<T>::AllocData()
{
        data = new T * [size.width];
        int i;
        for( i=0; i<size.width; i++ )
                data[i] = new T [size.height];
}

template <class T>
void IArray2D<T>::FreeData()
{
        if (data) {
                for( int i=0; i<size.width; i++ ) 
                        delete [] data[i];
                delete [] data;
        }
}

template <class T>
bool IArray2D<T>::CopyData( T **_data )
{
        if (_data) {
        
        int i;
                for( i=0; i<size.width; i++ )
                        memcpy( data[i], _data[i], sizeof( T )*size.height );

        return true;
        }
        else
                return false;
}

template <class T>
inline void IArray2D<T>::SetValue( const IPoint &_p, T _value )
{
        data[_p.x][_p.y] = _value;
}

template <class T>
inline void IArray2D<T>::SetValue( int _x, int _y, T _value )
{
        data[_x][_y] = _value;
}

template <class T>
inline void IArray2D<T>::AddValue( const IPoint &_p, T _value )
{
        data[_p.x][_p.y] += _value;
}

template <class T>
inline void IArray2D<T>::AddValue( int _x, int _y, T _value )
{
        data[_x][_y] += _value;
}

template <class T>
IArray2D<T> * IArray2D<T>::Row( int _nrow )
{
        if( nrow>=0 && nrow<size.width ) {
                IArray2D<T> *row = new IArray2D<T>( ISize(size.width,1) );
                for( int i=0; i<size.width; i++ )
                        (*row)(i,0) = data[i][_nrow];
                return row;
        }
        else
                return NULL;
}

template <class T>
IArray2D<T> * IArray2D<T>::Column( int _ncolumn )
{
        if( ncolumn>=0 && ncolumn<size.height ) {
                IArray2D<T> *column = new IArray2D<T>( ISize(size.height,1) );
                for( int j=0; j<size.height; j++ )
                        (*column)(j,0) = data[_ncolumn][j];
                return column;
        }
        else
                return NULL;
}

} // csfl namespace

#endif // __CSFL_SYS_MATH_ARRAY2D_H__

 

CFD Project | Documents | Downloads | Contact us | Use Terms
© SINMEC/EMC/UFSC, 2001.	All rights reserved.	Last Update: Jan. 18, 2002	Webmaster