include/matrixdata.h

Go to the documentation of this file.

/********************************************************************************
 *  Neural Network Framework.                                                   *
 *  Copyright (C) 2005-2008 Gianluca Massera <emmegian@yahoo.it>                *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program is distributed in the hope that it will be useful,             *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 *  GNU General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

// --- You can't include it directly
#ifndef TYPES_INCLUDES
#error "You can't include matrixdata.h directly; Instead, You have to include types.h"
// --- follow define avoid to get a lot of understandable error !
#define MATRIXDATA_H
#endif

#ifndef MATRIXDATA_H
#define MATRIXDATA_H

#include "memutils.h"
#include "vectordata.h"


namespace nnfw {

template<class T, class Vec = VectorData<T> >
class NNFW_TEMPLATE MatrixData : private Observer, private Observable {
public:

    MatrixData( u_int rows, u_int cols )
        : Observer(), Observable(), data(rows*cols), rowView(rows) {
        data.zeroing();
        nrows = rows;
        ncols = cols;
        tsize = nrows*ncols;
        for( u_int i=0; i<nrows; i++ ) {
            rowView[i].convertToView( data, i*ncols, (i+1)*ncols );
        }
        // --- view attributes
        view = false;
    };

    MatrixData( Vec& src, u_int rstart, u_int rend, u_int rows, u_int cols )
        : Observer(), Observable(), data(src, rstart, rend), rowView() {
        // --- Check the validity of dimensions
        if ( data.size() != rows*cols ) {
            nError() << "Wrongs dimensions specified in MatrixData view constructor; This MatrixData will be invalidate" ;
            rows = 0;
            cols = 0;
        }
        // --- view constructing
        view = true;
        // the local variable data is observed by this object
        data.addObserver( this );
        nrows = rows;
        ncols = cols;
        tsize = nrows*ncols;
        rowView.resize( tsize );
        for( u_int i=0; i<nrows; i++ ) {
            rowView[i].convertToView( data, i*ncols, (i+1)*ncols );
        }
    };

    ~MatrixData() {
        // --- nothing to do
    };



    u_int rows() const {
        return nrows;
    };
    u_int cols() const {
        return ncols;
    };
    u_int size() const {
        return tsize;
    };

    bool isView() const {
        return view;
    };

    bool operator==( const MatrixData<T,Vec>& b ) {
        // --- WARNING: don't implement this method using the operator== of private data vector
        // ---    perche' se la MatrixData e' una view, dopo un resizing sbagliato del vettore origine
        // ---    potrebbe rimanere una inconsistenza critica nei dati
        if ( this->size() != b.size() ) return false;
        for( u_int i=0; i<size(); i++ ) {
            if ( this->data[i] != b.data[i] ) {
                return false;
            }
        }
        return true;
    };

    bool operator!=( const VectorData<T>& b ) {
        return !( *this == b );
    };

    void resize( u_int rows, u_int cols ) {
        if ( view ) {
            nError() << "you can't resize a MatrixData view - use setView instead" ;
            return;
        }
        nrows = rows;
        ncols = cols;
        tsize = nrows*ncols;
        data.resize( tsize );
        rowView.resize( nrows );
        // --- Adjust the view of rows
        for( u_int i=0; i<nrows; i++ ) {
            if ( rowView[i].isView() ) {
                rowView[i].setView( i*ncols, (i+1)*ncols );
            } else {
                rowView[i].convertToView( data, i*ncols, (i+1)*ncols );
            }
        }
        // --- Notify the viewers
        // at this time, the notification has been launched by data.resize calling
        // the following methods will make sense only when Matrix-to-Matrix view will be implemented
        //notifyAll( NotifyEvent( datachanged ) );
    };



    T& at( u_int row, u_int col ) {
#ifdef NNFW_DEBUG
        if ( row >= nrows ) {
            nError() << "Accessing an element beyond Row boundary of matrix" ;
            return data[0];
        }
        if ( col >= ncols ) {
            nError() << "Accessing an element beyond Column boundary of matrix" ;
            return data[0];
        }
#endif
        return rowView[row][col];
    };

    const T& at( u_int row, u_int col ) const {
#ifdef NNFW_DEBUG
        if ( row >= nrows ) {
            nError() << "Accessing an element beyond Row boundary of matrix" ;
            return data[0];
        }
        if ( col >= ncols ) {
            nError() << "Accessing an element beyond Column boundary of matrix" ;
            return data[0];
        }
#endif
        return rowView[row][col];
    };

    Vec& operator[]( u_int row ) {
#ifdef NNFW_DEBUG
        if( row >= nrows ) {
            nError() << "Accessing elements outside boundary" ;
            return rowView[0];
        }
#endif
        return rowView[row];
    };

    const Vec& operator[]( u_int row ) const {
#ifdef NNFW_DEBUG
        if( row >= nrows ) {
            nError() << "Accessing elements outside boundary" ;
            return rowView[0];
        }
#endif
        return rowView[row];
    };

    MatrixData& assign( const MatrixData& src ) {
#ifdef NNFW_DEBUG
        if( rows() != src.rows() || cols() != src.cols() ) {
            nError() << "Different dimension" ;
            return (*this);
        }
#endif
        data.assign( src.data, tsize );
        return (*this);
    };

    void zeroing() {
        data.zeroing();
    };




    class matrixdataIterator;
    friend class matrixdataIterator;

    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    typedef matrixdataIterator iterator;
    typedef const matrixdataIterator const_iterator;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    size_type max_size() {
        return 300000; // <- FIXME it must return the maximum space of memory allocable
    };

    bool empty() {
        return (tsize==0);
    };

    void clear() {
        if ( view ) {
            nError() << "you can't clear a MatrixData view" ;
        } else {
            resize( 0, 0 );
        }
    };

    iterator begin() {
        return matrixdataIterator( *this );
    };
    const_iterator begin() const {
        return matrixdataIterator( ((MatrixData&)*this) );
    };

    iterator end() {
        return matrixdataIterator( *this, tsize );
    };
    const_iterator end() const {
        return matrixdataIterator( ((MatrixData&)*this), tsize );
    };

    class matrixdataIterator : public std::iterator<std::bidirectional_iterator_tag,T,ptrdiff_t> {
    public:
        matrixdataIterator( MatrixData& data, u_int startId = 0 ) : vecdata(data.data), id(startId), tsize(data.tsize) { /*nothing to do*/ };
        matrixdataIterator( const matrixdataIterator& src ) : vecdata(src.vecdata), id(src.id), tsize(src.tsize) { /* nothing to do */  };
        matrixdataIterator& operator=( const matrixdataIterator& src ) {
            vecdata = src.vecdata;
            id = src.id;
            tsize = src.tsize;
            return (*this);
        };
        bool operator==( const matrixdataIterator& x ) const {
            return ( &vecdata == &(x.vecdata) && id == x.id );
        };
        bool operator!=( const matrixdataIterator& x ) const {
            return ( &vecdata != &(x.vecdata) || id != x.id );
        };
        const T& operator*() const {
            return vecdata[id];
        };
        T& operator*() {
            return vecdata[id];
        };
        matrixdataIterator& operator++() {
            id = (id < tsize) ? id+1 : tsize;
            return (*this);
        };
        const matrixdataIterator& operator++() const {
            id = (id < tsize) ? id+1 : tsize;
            return (*this);
        };
        matrixdataIterator& operator--() {
            id = ( id > 0 ) ? id-1 : 0;
            return (*this);
        };
        const matrixdataIterator& operator--() const {
            id = ( id > 0 ) ? id-1 : 0;
            return (*this);
        };
        u_int getIndex() {
            return id;
        };
    private:
        Vec& vecdata;
        u_int id;
        u_int tsize;
    };

protected:
    friend class RealVec;

    Vec& rawdata() const {
        return (Vec&)data;
    };

private:
    u_int nrows;
    u_int ncols;
    u_int tsize;
    Vec data;
    VectorData< Vec > rowView;

    bool view;

    virtual void notify( const NotifyEvent& event ) {
        switch( event.type() ) {
        case Vec::datachanged:
#ifdef NNFW_DEBUG
            nWarning() << "Arrange a MatrixData view after a VectorData resizing can lead to inconsistent settings - see documentation if you not sure" ;
#endif
            ncols = data.size() / nrows ;
            if ( ncols == 0 ) {
                nrows = 0;
                ncols = 0;
                tsize = 0;
                rowView.clear();
            } else {
                tsize = ncols*nrows;
                // --- Adjust the view of rows
                for( u_int i=0; i<nrows; i++ ) {
                    rowView[i].setView( i*ncols, (i+1)*ncols );
                }
            }
            break;
        case Vec::datadestroying:
#ifdef NNFW_DEBUG
            nWarning() << "Destroying a VectorData before its views!!!" ;
#endif
            // --- reconvert to a regular MatrixData with size zero
            view = false;
            nrows = 0;
            ncols = 0;
            tsize = 0;
            rowView.clear();
            break;
        default:
            break;
        }
        // --- Propagate Notify to sub-viewers
        // --- Inutile fino a che non si implementano le viste tra Matrici
        //notifyAll( matdatachanged );
    };

    MatrixData( const MatrixData& src )
        : Observer(), Observable(), data(0), rowView(0) {
    };

};

}

#endif

Copyright © 2005-2008 G. Massera

Contact: emmegian (at) yahoo (dot) it

  Documentation generated by