cluster.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 CLUSTER_H
#define CLUSTER_H

#include "nnfwconfig.h"
#include "updatable.h"
#include "outputfunction.h"
#include <exception>
#include <memory>

namespace farsa {

class FARSA_NNFW_API Cluster : public Updatable {
public:
    Cluster( unsigned int numNeurons, QString name = "unnamed" );
    Cluster( ConfigurationParameters& params, QString prefix );
    virtual ~Cluster();
    unsigned int numNeurons() const {
        return numneurons;
    };
    bool needReset() {
        return needRst;
    };
    void setAccumulate( bool mode ) {
        accOff = !mode;
    };
    bool isAccumulate() const {
        return !accOff;
    };
    virtual void randomize( double min, double max ) = 0;
    void setInput( unsigned int neuron, double value );
    void setInputs( const DoubleVector& inputs );
    void setAllInputs( double value );
    void resetInputs();
    double getInput( unsigned int neuron ) const;
    DoubleVector& inputs() {
        return *inputdataptr;
    };
    DoubleVector inputs() const {
        return *inputdataptr;
    };
    void setOutput( unsigned int neuron, double value );
    void setOutputs( const DoubleVector& outputs );
    double getOutput( unsigned int neuron ) const;
    DoubleVector& outputs() {
        return *outputdataptr;
    };
    DoubleVector outputs() const {
        return *outputdataptr;
    };
    void setOutFunction( OutputFunction* up );
    OutputFunction* outFunction() const {
        return updater.get();
    };
    virtual void save(ConfigurationParameters& params, QString prefix);
    static void describe( QString type );
    typedef DoubleVector& (*getStateVectorFuncPtr)( Cluster* );
    getStateVectorFuncPtr getDelegateFor( QString stateVector ) {
        if ( stateDelegates.contains( stateVector ) ) {
            return stateDelegates[stateVector];
        }
        throw ClusterStateVectorNotPresent( (QString("The state vector named ") + stateVector + " is not part of this Cluster").toAscii().data() );
    };
protected:
    template <class T, DoubleVector& (T::*TMethod)()>
    void setDelegateFor( QString vectorName ) {
        stateDelegates[vectorName] = &staticDelegateMethod<T, TMethod>;
    }
    void setNeedReset( bool b ) {
        needRst = accOff && b;
    };
    DoubleVector* inputdataptr;
    DoubleVector* outputdataptr;
private:
    unsigned int numneurons;
    DoubleVector inputdata;
    DoubleVector outputdata;
    std::auto_ptr<OutputFunction> updater;
    bool needRst;
    bool accOff;

    QMap<QString, getStateVectorFuncPtr> stateDelegates;
    template <class T, DoubleVector& (T::*TMethod)()>
    static DoubleVector& staticDelegateMethod( Cluster* cluster_ptr ) {
        T* p = static_cast<T*>(cluster_ptr);
        //--- call the delegate method using pointer-to-member syntax
        return (p->*TMethod)();
    }
};

}

#endif