include/realvec.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 realvec.h directly; Instead, You have to include types.h"
// --- follow define avoid to get a lot of understandable error !
#define REALVEC_H
#endif

#ifndef REALVEC_H
#define REALVEC_H

namespace nnfw {

class NNFW_API RealVec : public VectorData<Real> {
public:

    RealVec( u_int size );
    
    RealVec( u_int size, Real value );

    RealVec();

    RealVec( RealVec& src, u_int idStart, u_int idEnd );

    RealVec( const Real* r, u_int dim );

    RealVec( const RealVec& orig );

    RealVec& operator=( const RealVec& src ) {
        RealVec& self = *this;
        self.resize( src.size() );
        self.assign( src );
        return self;
    };



    RealVec& operator<<( const Real& value ) {
        append( value );
        return (*this);
    };



    RealVec& operator-() {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] = -data[i];
        }
        return (*this);
    };



    RealVec& operator+=(const RealVec& r ) {
#ifdef NNFW_DEBUG
        if( vsize != r.vsize ) {
            nError() << "Different numbers of element" ;
            return (*this);
        }
#endif
        for( u_int i=0; i<vsize; i++ ) {
            data[i] += r.data[i];
        }
        return (*this);
    };
    RealVec& operator+=(const Real& r ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] += r;
        }
        return (*this);
    };
    RealVec& operator-=(const RealVec& r ) {
#ifdef NNFW_DEBUG
        if( vsize != r.vsize ) {
            nError() << "Different numbers of element" ;
            return *this;
        }
#endif
        for( u_int i=0; i<vsize; i++ ) {
            data[i] -= r.data[i];
        }
        return (*this);
    };
    RealVec& operator-=(const Real& r ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] -= r;
        }
        return (*this);
    };
    RealVec& operator*=(const RealVec& r ) {
#ifdef NNFW_DEBUG
        if( vsize != r.vsize ) {
            nError() << "Different numbers of element" ;
            return (*this);
        }
#endif
        for( u_int i=0; i<vsize; i++ ) {
            data[i] *= r.data[i];
        }
        return (*this);
    };
    RealVec& operator*=(const Real& r ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] *= r;
        }
        return (*this);
    };
    RealVec& operator/=(const RealVec& r ) {
#ifdef NNFW_DEBUG
        if( vsize != r.vsize ) {
            nError() << "Different numbers of element" ;
            return (*this);
        }
#endif
        for( u_int i=0; i<vsize; i++ ) {
            data[i] /= r.data[i];
        }
        return (*this);
    };
    RealVec& operator/=(const Real& r ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] /= r;
        }
        return (*this);
    };

    Real dot( const RealVec& r ) {
#ifdef NNFW_DEBUG
        if( vsize != r.vsize ) {
            nError() << "Different numbers of element" ;
            return 0.0;
        }
#endif
        Real ret = 0.0;
        for( u_int i=0; i<vsize; i++ ) {
            ret += data[i] * r.data[i];
        }
        return ret;
    };



    RealVec& exp();

    RealVec& scale( const Real v ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] *= v;
        }
        return (*this);
    };

    RealVec& inv();

    Real norm();

    RealVec& square() {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] *= data[i];
        }
        return (*this);
    };
    
    Real sum() {
        Real s = 0.0;
        for( u_int i=0; i<vsize; i++ ) {
            s += data[i];
        }
        return s;
    };

    RealVec& normalize() {
        Real n = norm();
        if ( n==0.0 ) return (*this);
        for( u_int i=0; i<vsize; i++ ) {
            data[i] /= n;
        }
        return (*this);
    };

    RealVec& neg() {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] = !data[i];
        }
        return (*this);
    };

    void assign_xminusy( const RealVec& x, const RealVec& y ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] = x[i]-y[i];
        }
    };

    void assign_minusx( const RealVec& x ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] = -x[i];
        }
    };

    void assign_aminusx( Real a, const RealVec& x ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] = a-x[i];
        }
    };

    void assign_amulx( const Real a, const RealVec& x ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] = a*x[i];
        }
    };

    void assign_adivx( const Real a, const RealVec& x ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] = a/x[i];
        }
    };
        
    Real mean() {
        return this->sum() / vsize;
    };

    int maxIndex() {
        int mi = 0;
        for( u_int i=1; i<vsize; i++ ) {
            if ( data[i] > data[mi] ) mi=i;
        }
        return mi;
    }

    Real maxValue() {
        return data[maxIndex()];
    }

    int minIndex() {
        int mi = 0;
        for( u_int i=1; i<vsize; i++ ) {
            if ( data[i] < data[mi] ) mi=i;
        }
        return mi;
    }

    Real minValue() {
        return data[minIndex()];
    }

    RealVec& step( Real threshold ) {
        for ( u_int i = 0; i<vsize; i++ ) {
            ( data[i] > threshold ) ? data[i] = 1.0f : data[i] = 0.0f;
        }
        return (*this);
    }

    static void createAllBinaries( RealVec* vector, unsigned long int pats, u_int dims );

    static Real mse( const RealVec& target, const RealVec& actual );

    RealVec& deltarule( Real rate, const RealVec& x, const RealVec& y ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] += rate*x[i]*y[i];
        }
        return (*this);
    };



    static RealMat& outprod( RealMat& m, const RealVec& x, const RealVec& y );

    

protected:

    friend class RealMat;
    Real* rawdata() const {
        return VectorData<Real>::rawdata();
    };

    //--- for accessing from C interface implementation
    friend Real* getRawData( RealVec& );

};

}

#endif

Copyright © 2005-2008 G. Massera

Contact: emmegian (at) yahoo (dot) it

  Documentation generated by