N1DArray.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2007  A.N. Yzelman
 *  Released under LGPL, see license.txt
 *
 *  Last modified at 8th of March, 2007, by A.N. Yzelman
 *
 *  N1DArray.h: Defines a multi-dimensional matrix.
 *
 */

#ifndef _H_N1DARRAY
#define _H_N1DARRAY

//#define _SET_INITIAL_ZERO

#include <vector>

//#define _DEBUG
//#define _VOID_CHECK
//#define _SMALLER_RESIZE_WARNING_ON

#define _HP

template<typename stored_type>
class N1DArray {
private:

#ifdef _VOID_CHECK

        void voidCheckDBG() {
                int c=0;
                for (int i=0; i<size; i++)
                        if ( _storage[i] == 0 )
                                c++;
                cout << "Number of stored void blocks: " << c << endl; fflush( stdout );
        }
#endif

protected:

        unsigned int size;
        
        unsigned int _dimension;
        
        vector< unsigned int > _sizes;
        
        vector< unsigned int > _cumulative_size;
        
        stored_type *_storage;

        bool checkIndex( vector< unsigned int > index ) {
                if ( index.size() == _dimension ) {
                        for ( unsigned int i=0; i<_dimension; i++ ) {
                                if ( index[i] >= _sizes[i] || index[i] < 0) {
                                        cerr << "Warning: wrong index vector in N1DArray::checkIndex index[" << i << "] = " << index[i] << " not in [0, " << _sizes[i] << "]!" << endl;
                                        return false;
                                } else {
                                        return true;
                                }
                        }
                }
                cerr << "Warning: wrong index vector size in N1DArray::checkIndex (" << index.size() << ")" << endl;
                return false;
        }

public:

        class Iterator : public std::iterator<std::forward_iterator_tag, stored_type> {
                private:
                
                unsigned int at;
                
                N1DArray< stored_type > *arr;

                public:
                
                Iterator( N1DArray< stored_type > *a ) {
                        at = 0;
                        arr = a;
                }

                Iterator( N1DArray< stored_type > *a, unsigned int b ) {
                        at = b;
                        arr = a;
                }

                Iterator& operator=( const Iterator& other ) {
                        at = other.at;
                        arr = other.arr;
                        return (*this);
                }

                bool operator==( const Iterator& other ) {
                        return ( at == other.at && arr == other.arr );
                }

                bool operator!=(const Iterator& other ) {
                        return ( at != other.at || arr != other.arr );
                }
        
                Iterator& operator++() {
                        at++;
                        return (*this);
                }

                stored_type operator*() {

                        return arr->_storage[ at ];
                }

        };

        Iterator begin() {
                return Iterator( this );
        }

        Iterator end() {
                return Iterator( this, size );
        }

        int get1D( vector< unsigned int > index ) {
        
                //first check the index vector
                if ( !checkIndex( index ) ) {
                        cerr << "N1DArray received bad index vector!" << endl;
                        exit(1);
                }
                
                unsigned int index_1d = 0;

#ifdef _DEBUG
                cout << "Index vector: < ";
#endif

                //the actual transformation
                for ( unsigned int i=0; i<_dimension; i++ ) {
                        index_1d += index[i] * _cumulative_size[i];

#ifdef _DEBUG
                        cout << index[i] << " ";
#endif
                }
#ifdef _DEBUG
                cout << "> maps to " << index_1d << "/" << size << endl;
#endif

#ifndef _HP
                //additional sanity checking
                if ( index_1d >= size ) {
                        cerr << "1D index exceeds allocated number!" << endl;
                        cerr << "Requested index vector: < ";
                        for ( unsigned int i=0; i<_dimension; i++ )
                                cerr << index[i] << " ";
                        cerr << ">" << endl;
                        cerr << "Size vector: < ";
                        for ( unsigned int i=0; i<_dimension; i++ )
                                cerr << _sizes[i] << " ";
                        cerr << ">" << endl;
                        cerr << "Cumulative size vector: < ";
                        for ( unsigned int i=0; i<_dimension; i++ )
                                cerr << _cumulative_size[i] << " ";
                        cerr << ">" << endl;
                        exit(1);
                }
#endif
                
                return index_1d;
        }

        N1DArray( vector< unsigned int > sizes ) {
        
        #ifdef _DEBUG
                cout << "Size vector: < ";
                for ( unsigned int i=0; i<sizes.size(); i++)
                        cout << sizes[i] << " ";
                cout << ">" << endl; fflush( stdout );
        #endif
        
                _dimension = sizes.size();
                _sizes = sizes;
                _cumulative_size = sizes;
                size = 1;
                for (int j=_dimension-1; j >=0; j--) {
                        size *= _sizes[j];
                }

                _storage = new stored_type[size];

#ifdef _DEBUG
                cout << "Allocated size: " << size << endl;
#endif

                _cumulative_size[0] = 1;
                for ( unsigned int i=1; i<_dimension; i++ ) {
                        _cumulative_size[i] = _sizes[i-1] * _cumulative_size[i-1];
#ifdef _DEBUG
                        cout << "Sumsiz[" << i << "]=" << _cumulative_size[i] << endl;
#endif
                }

#ifdef _SET_INITIAL_ZERO
                for (int i=0; i<size; i++)
                        _storage[i] = 0;
#endif

        }

        N1DArray( unsigned int x, unsigned int y, unsigned int z, unsigned int w) {
                //straightforward implementation. Uses the base constructor.
                vector< unsigned int > v(4);
                v[0]=x; v[1]=y; v[2]=z; v[3]=w;
                this(v);
        }

        ~N1DArray() {
                delete [] _storage;
        }

        stored_type get(vector< unsigned int > index) {

#ifdef _VOID_CHECK
                voidCheckDBG();
#endif
                //straightforward implementation
                unsigned int index_1d = get1D(index);
                return _storage[index_1d];
        }

        void set(vector< unsigned int > index, stored_type obj) {

#ifdef _VOID_CHECK
                voidCheckDBG();
#endif

                //straightforward implementation
        
#ifdef _DEBUG
                cout << "N1DArray::set called with index: < ";
                for ( unsigned int i=0; i<index.size(); i++ )
                        cout << index[i] << " ";
                cout << " >" << endl;
#endif

                unsigned int index_1d = get1D( index );

#ifdef _DEBUG
                cout << "1D location: " << index_1d << endl;
#endif

                _storage[index_1d] = obj;
        }

        void resize( vector< unsigned int > sizes ) {
        
#ifdef _VOID_CHECK
                voidCheckDBG();
#endif

#ifdef _DEBUG           
                cout << "New sizes: < ";
                for (int i=0; i<_dimension; i++)
                        cout << sizes[i] << " ";
                cout << ">" << endl;
#endif

                //check dimensions
                if ( sizes.size() != _sizes.size() ) {
                        cerr << "Cannot resize the vector dimension itself!" << endl;
                        exit(1);
                }

                //check sizes
                bool same = true;
                for ( unsigned int dim=0; dim<_dimension; dim++) {
                        if ( sizes[dim] != _sizes[dim] )
                                same = false;
                        if ( sizes[dim] < _sizes[dim] ) {
#ifdef _SMALLER_RESIZE_WARNING_ON
                                cerr << "Cannot resize to smaller sizes (would possibly lose data)!" << endl;
                                cerr << "Ignoring resize command (!)" << endl;
#endif
                                //exit(1);
                                return; //just ignore instead of crash
                        }
                }

                //if sizes are equal, do nothing
                if ( same )
                        return;

                //allocate larger array 
                N1DArray< stored_type > *replacement = new N1DArray< stored_type >( sizes );

                vector< unsigned int > copy_index;
                copy_index.resize( _dimension );
                for ( unsigned int i=0; i<_dimension; i++ )
                        copy_index[i] = 0;

                //copy elements
                while (true) {
                        stored_type element = get( copy_index );
                        replacement->set( copy_index, element );
                        copy_index[0]++;
                        for ( unsigned int i=0; i<(_dimension-1); i++ ) {
                                if (copy_index[i] == _sizes[i]) {
                                        copy_index[i] = 0;
                                        copy_index[i+1]++;
                                }
                        }
                        if ( copy_index[_dimension-1] == _sizes[_dimension-1] )
                                break;
                }

                //delete local storage
                delete [] _storage;
                _sizes.clear();
                _cumulative_size.clear();

                //become the new array
                //dimension =...
                size = replacement->size;
                _storage = replacement->_storage;
                _sizes = replacement->_sizes;
                _cumulative_size = replacement->_cumulative_size;

#ifdef _VOID_CHECK
                voidCheckDBG();
#endif

        }

};

#endif

---