nnfw/include/vectors.h

Go to the documentation of this file.

/********************************************************************************
 *  Neural Network Framework.                                                   *
 *  Copyright (C) 2005-2011 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  *
 ********************************************************************************/

#ifndef VECTORS_H
#define VECTORS_H

#include "memutils.h"
#include "QVector"
#include "nnfwexceptions.h"

namespace farsa {

class FARSA_NNFW_TEMPLATE doubleRef {
public:
    doubleRef() : ref(&dummy), ref2(&dummy) {
    };
    operator double() {
        return *ref;
    };
    doubleRef& operator=( const doubleRef& src ) {
        ref2 = src.ref2;
        return (*this);
    };
    doubleRef& operator=( const double& src ) {
        *ref2 = src;
        return (*this);
    };
    doubleRef& operator+=( const double& src ) {
        *ref2 += src;
        return (*this);
    };
    doubleRef& operator-=( const double& src ) {
        *ref2 -= src;
        return (*this);
    };
    doubleRef& operator*=( const double& src ) {
        *ref2 *= src;
        return (*this);
    };
    doubleRef& operator/=( const double& src ) {
        *ref2 /= src;
        return (*this);
    };
    void setRef( double* src) {
        ref = src;
        ref2 = src;
    };
    void setNoSteady() {
        ref2 = ref;
    };
    void setSteady() {
        ref2 = &dummy;
    };
    bool isSteady() {
        return ref != ref2;
    };
private:
    //--- How it works:
    //--- ref is always returned when the data is retrieved,
    //--- while ref2 is used during all assignments operation
    //--- FIXED data: ref2 points to dummy variable, in this way each assignment will change
    //---             the dummy variable and not the data pointed by ref
    //--- NOT FIXED : ref2 points to same variable of ref, in this way each assignement will change
    //---             the data pointed by ref (i.e. the source data)
    double* ref;
    double* ref2;
    static double dummy;
};

class FARSA_NNFW_TEMPLATE DoubleVector {
public:
    DoubleVector() {
        shData = new sharedData();
        shData->vsize = 0;
        //shData->data = 0;
        //shData->dataref = 0;
        shData->refcounts = 1;
        shData->temporary = false;
        shData->nodata = false;
        this->isinternal = false;
    };
    DoubleVector( unsigned int size, bool isinternal = false ) {
        shData = new sharedData();
        shData->vsize = size;
        shData->data = new double[size];
        memoryZeroing( shData->data, size );
        shData->dataref = new doubleRef[size];
        shData->refcounts = 1;
        shData->temporary = false;
        shData->nodata = false;
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i].setRef( shData->data + i );
        }
        this->isinternal = isinternal;
    };
    DoubleVector( unsigned int size, double value, bool isinternal = false ) {
        shData = new sharedData();
        shData->vsize = size;
        shData->data = new double[size];
        shData->dataref = new doubleRef[size];
        shData->refcounts = 1;
        shData->temporary = false;
        shData->nodata = false;
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->data[i] = value;
            shData->dataref[i].setRef( shData->data + i );
        }
        this->isinternal = isinternal;
    };
    DoubleVector( const double* r, unsigned int dim, bool isinternal = false ) {
        shData = new sharedData();
        shData->vsize = dim;
        shData->data = new double[dim];
        shData->dataref = new doubleRef[dim];
        shData->refcounts = 1;
        shData->temporary = false;
        shData->nodata = false;
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->data[i] = r[i];
            shData->dataref[i].setRef( shData->data + i );
        }
        this->isinternal = isinternal;
    };
    DoubleVector( const DoubleVector& src ) {
        shData = src.shData;
        shData->refcounts += 1;
        //--- is not a temporary anymore !
        shData->temporary = false;
        isinternal = false;
    };
    DoubleVector( unsigned int dim, bool temp, unsigned int dummy ) {
        (void)dummy; // This stops warnings. Assigning dummy a value would have produce a "parameter ‘dummy’ set but not used" warning
        shData = new sharedData();
        shData->vsize = dim;
        shData->data = new double[dim];
        shData->dataref = new doubleRef[dim];
        shData->refcounts = 1;
        shData->temporary = temp;
        shData->nodata = false;
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i].setRef( shData->data + i );
        }
        this->isinternal = false;
    };
    ~DoubleVector() {
        shData->refcounts -= 1;
        if ( shData->refcounts == 0 ) {
            //--- the last destroy the data
            if ( shData->vsize > 0 ) {
                delete [](shData->dataref);
                if ( !(shData->nodata) ) {
                    delete [](shData->data);
                }
            }
            delete shData;
        }
    };
    unsigned int size() const {
        return shData->vsize;
    };
    bool isNull() const {
        return (shData->vsize==0);
    };
    bool operator==( const DoubleVector& b ) const {
        if ( shData == b.shData ) return true;
        if ( shData->vsize != b.shData->vsize ) return false;
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            if ( shData->dataref[i] != b.shData->dataref[i] ) return false;
        }
        return true;
    };
    bool operator!=( const DoubleVector& b ) const {
        return !( *this == b );
    };
    DoubleVector& operator=( const DoubleVector& src ) {
        if ( isinternal ) throw VectorAssignmentNotAllowed();
        if ( src.shData == shData ) return (*this);
        //--- eliminate the previous data
        shData->refcounts -= 1;
        if ( shData->refcounts == 0 ) {
            //--- the last destroy the data
            if ( shData->vsize > 0 ) {
                delete [](shData->dataref);
                if ( !(shData->nodata) ) {
                    delete [](shData->data);
                }
            }
            delete shData;
        }
        //--- set the new data taken from src
        shData = src.shData;
        shData->refcounts++;
        //--- is not a temporary anymore !
        shData->temporary = false;
        return (*this);
    };
    DoubleVector& copyValues( const DoubleVector& src ) {
        // if shared data is the same, they already share the same values
        if ( shData == src.shData ) return (*this);
        detach();
        unsigned int max = qMin( shData->vsize, src.size() );
        for( unsigned int i=0; i<max; i++ ) {
            shData->dataref[i] = src[i];
        }
        return (*this);
    };
    DoubleVector& copyValues( const QVector<double>& src ) {
        detach();
        unsigned int max = qMin( shData->vsize, (unsigned int)(src.size()) );
        for( unsigned int i=0; i<max; i++ ) {
            shData->dataref[i] = src[i];
        }
        return (*this);
    };
    DoubleVector& copyValues( const DoubleVector& src, unsigned int srcOffset, unsigned int thisOffset ) {
        // if shared data is the same and offsets are zero, then there is nothing to do
        if ( shData == src.shData && srcOffset == 0 && thisOffset == 0 ) return (*this);
        detach();
        unsigned int max = qMin( shData->vsize-thisOffset, src.size()-srcOffset );
        for( unsigned int i=0; i<max; i++ ) {
            shData->dataref[i+thisOffset] = src[i+srcOffset];
        }
        return (*this);
    };
    DoubleVector& copyValues( const DoubleVector& src, unsigned int srcOffset, unsigned int thisOffset, unsigned int stride ) {
        if ( stride == 0 ) return (*this);
        // if shared data is the same and offsets are zero, then there is nothing to do
        if ( shData == src.shData && srcOffset == 0 && thisOffset == 0 ) return (*this);
        detach();
        unsigned int max = qMin( shData->vsize-thisOffset, src.size()-srcOffset );
        for( unsigned int i=0; i<max; i=i+stride ) {
            shData->dataref[i+thisOffset] = src[i+srcOffset];
        }
        return (*this);
    };
    DoubleVector& detach() {
        if ( shData->refcounts > 1 ) {
            sharedData* tmp = new sharedData();
            unsigned int size = shData->vsize;
            tmp->vsize = size;
            tmp->data = new double[size];
            if ( shData->nodata ) {
                for( unsigned int i=0; i<size; i++ ) {
                    tmp->data[i] = shData->dataref[i];
                }
            } else {
                memoryCopy( tmp->data, shData->data, size );
            }
            tmp->dataref = new doubleRef[size];
            tmp->refcounts = 1;
            tmp->temporary = false;
            tmp->nodata = false;
            for( unsigned int i=0; i<size; i++ ) {
                tmp->dataref[i].setRef( tmp->data + i );
            }
            shData->refcounts--;
            shData = tmp;
        }
        return (*this);
    };
    const DoubleVector& operator+() const {
        return (*this);
    };
    const DoubleVector operator-() const {
        if ( shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                shData->dataref[i] = -shData->dataref[i];
            }
            return (*this);
        } else {
            DoubleVector ret( shData->vsize, true, 0 );
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                ret.shData->dataref[i] = -shData->dataref[i];
            }
            return ret;
        }
    };
    const DoubleVector operator+( const DoubleVector& right ) const {
#ifdef FARSA_DEBUG
        if ( shData->vsize != right.shData->vsize ) {
            throw IncompatibleVectors("Incompatible DoubleVectors in operator+ (dimension must be equals)");
        }
#endif
        if ( right.shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                right.shData->dataref[i] = shData->dataref[i] + right.shData->dataref[i];
            }
            return right;
        } else if ( shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                shData->dataref[i] = shData->dataref[i] + right.shData->dataref[i];
            }
            return (*this);
        } else {
            DoubleVector ret( shData->vsize, true, 0 );
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                ret.shData->dataref[i] = shData->dataref[i] + right.shData->dataref[i];
            }
            return ret;
        }
    };
    const DoubleVector operator-( const DoubleVector& right ) const {
#ifdef FARSA_DEBUG
        if ( shData->vsize != right.shData->vsize ) {
            throw IncompatibleVectors("Incompatible DoubleVectors in operator- (dimension must be equals)");
        }
#endif
        if ( right.shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                right.shData->dataref[i] = shData->dataref[i] - right.shData->dataref[i];
            }
            return right;
        } else if ( shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                shData->dataref[i] = shData->dataref[i] - right.shData->dataref[i];
            }
            return (*this);
        } else {
            DoubleVector ret( shData->vsize, true, 0 );
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                ret.shData->dataref[i] = shData->dataref[i] - right.shData->dataref[i];
            }
            return ret;
        }
    };
    const DoubleVector operator*( const DoubleVector& right ) const {
#ifdef FARSA_DEBUG
        if ( shData->vsize != right.shData->vsize ) {
            throw IncompatibleVectors("Incompatible DoubleVectors in operator* (dimension must be equals)");
        }
#endif
        if ( right.shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                right.shData->dataref[i] = shData->dataref[i] * right.shData->dataref[i];
            }
            return right;
        } else if ( shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                shData->dataref[i] = shData->dataref[i] * right.shData->dataref[i];
            }
            return (*this);
        } else {
            DoubleVector ret( shData->vsize, true, 0 );
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                ret.shData->dataref[i] = shData->dataref[i] * right.shData->dataref[i];
            }
            return ret;
        }
    };
    const DoubleVector operator/( const DoubleVector& right ) const {
#ifdef FARSA_DEBUG
        if ( shData->vsize != right.shData->vsize ) {
            throw IncompatibleVectors("Incompatible DoubleVectors in operator/ (dimension must be equals)");
        }
#endif
        if ( right.shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                right.shData->dataref[i] = shData->dataref[i] / right.shData->dataref[i];
            }
            return right;
        } else if ( shData->temporary ) {
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                shData->dataref[i] = shData->dataref[i] / right.shData->dataref[i];
            }
            return (*this);
        } else {
            DoubleVector ret( shData->vsize, true, 0 );
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                ret.shData->dataref[i] = shData->dataref[i] / right.shData->dataref[i];
            }
            return ret;
        }
    };
    DoubleVector& operator+=( const DoubleVector& right ) {
#ifdef FARSA_DEBUG
        if ( shData->vsize != right.shData->vsize ) {
            throw IncompatibleVectors("Incompatible DoubleVectors in operator+= (dimension must be equals)");
        }
#endif
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = shData->dataref[i] + right.shData->dataref[i];
        }
        return (*this);
    };
    DoubleVector& operator-=( const DoubleVector& right ) {
#ifdef FARSA_DEBUG
        if ( shData->vsize != right.shData->vsize ) {
            throw IncompatibleVectors("Incompatible DoubleVectors in operator-= (dimension must be equals)");
        }
#endif
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = shData->dataref[i] - right.shData->dataref[i];
        }
        return (*this);
    };
    DoubleVector& operator*=( const DoubleVector& right ) {
#ifdef FARSA_DEBUG
        if ( shData->vsize != right.shData->vsize ) {
            throw IncompatibleVectors("Incompatible DoubleVectors in operator*= (dimension must be equals)");
        }
#endif
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = shData->dataref[i] * right.shData->dataref[i];
        }
        return (*this);
    };
    DoubleVector& operator/=( const DoubleVector& right ) {
#ifdef FARSA_DEBUG
        if ( shData->vsize != right.shData->vsize ) {
            throw IncompatibleVectors("Incompatible DoubleVectors in operator/= (dimension must be equals)");
        }
#endif
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = shData->dataref[i] / right.shData->dataref[i];
        }
        return (*this);
    };
    DoubleVector& operator+=( const double& right ) {
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = shData->dataref[i] + right;
        }
        return (*this);
    };
    DoubleVector& operator-=( const double& right ) {
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = shData->dataref[i] - right;
        }
        return (*this);
    };
    DoubleVector& operator*=( const double& right ) {
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = shData->dataref[i] * right;
        }
        return (*this);
    };
    DoubleVector& operator/=( const double& right ) {
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = shData->dataref[i] / right;
        }
        return (*this);
    };
    DoubleVector& steady( unsigned int i ) {
#ifdef FARSA_DEBUG
        if( i >= shData->vsize ) {
            throw OutsideVectorBoundaries("Fixating elements outside boundary");
        }
#endif
        detach();
        shData->dataref[i].setSteady();
        return (*this);
    };
    DoubleVector& unsteady( unsigned int i ) {
#ifdef FARSA_DEBUG
        if( i >= shData->vsize ) {
            throw OutsideVectorBoundaries("Un-Fixating elements outside boundary");
        }
#endif
        detach();
        shData->dataref[i].setNoSteady();
        return (*this);
    };
    bool isSteady( unsigned int i ) const {
#ifdef FARSA_DEBUG
        if( i >= shData->vsize ) {
            throw OutsideVectorBoundaries("isSteady - Accessing element outside boundary");
        }
#endif
        return shData->dataref[i].isSteady();
    };
    DoubleVector& zeroing() {
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = 0;
        }
        return (*this);
    };
    DoubleVector& setAll( const double value ) {
        detach();
        for( unsigned int i=0; i<shData->vsize; i++ ) {
            shData->dataref[i] = value;
        }
        return (*this);
    };
    doubleRef& operator[]( unsigned int index ) {
#ifdef FARSA_DEBUG
        if( index >= shData->vsize ) {
            throw OutsideVectorBoundaries("operator[] - Accessing elements outside boundary");
        }
#endif
        detach();
        return shData->dataref[index];
    };
    double operator[]( unsigned int index ) const {
#ifdef FARSA_DEBUG
        if( index >= shData->vsize ) {
            throw OutsideVectorBoundaries("operator[] - Accessing elements outside boundary");
        }
#endif
        return shData->dataref[index];
    };
    DoubleVector& resize( unsigned int newsize ) {
        if ( shData->nodata || isinternal ) {
            throw VectorResizeNotAllowed();
        }
        detach();
        if ( newsize > shData->vsize ) {
            double* newdata = new double[newsize];
            memoryCopy( newdata, shData->data, shData->vsize );
            delete [](shData->data);
            delete [](shData->dataref);
            shData->data = newdata;
            shData->vsize = newsize;
            shData->dataref = new doubleRef[ newsize ];
            for( unsigned int i=0; i<shData->vsize; i++ ) {
                shData->dataref[i].setRef( shData->data + i );
            }
        } else {
            shData->vsize = newsize;
        }
        return (*this);
    };
    DoubleVector& append( const double& value ) {
        //--- detach (and throw) done by resize
        resize( shData->vsize+1 );
        shData->data[ shData->vsize-1 ] = value;
        return (*this);
    };
    DoubleVector& operator<<( const double& value ) {
        //--- detach (and throw) done by resize (append)
        append( value );
        return (*this);
    };

private:
    class sharedData {
    public:
        unsigned int vsize;
        double* data;
        int refcounts;
        doubleRef* dataref;
        bool temporary;
        bool nodata;
    };
    sharedData* shData;
    bool isinternal;

    friend class DoubleMatrix;
    void resizeNoData( unsigned int newsize ) {
        if ( shData->vsize > 0 ) {
            if ( shData->data ) { delete [](shData->data); }
            delete [](shData->dataref);
        }
        shData->vsize = newsize;
        shData->dataref = new doubleRef[ newsize ];
        shData->nodata = true;
        isinternal = true;
    };
};

}

#endif