Neuron.h

/*
 *====================================================================
 * HISTORY:
 * -------
 * $Log: Neuron.h,v $
 * Revision 1.1  2008/08/23 14:28:48  samit_ahlawat
 * Feed forward neural network library
 *
 * Revision 1.1  2007/11/06 10:06:30  samit_ahlawat
 * Checking in first version of basic neural net infrastructure
 *
 * 
 * ID:
 * --
 * static const char *CvsId = "@(#)$Id: Neuron.h,v 1.1 2008/08/23 14:28:48 samit_ahlawat Exp $";
 *====================================================================
 */

#ifndef _AIMAGIK_NEURON_H_
#define _AIMAGIK_NEURON_H_

#include <vector>
#include "ActivationFunc.h"
#include <stdexcept>
#include <cstdlib>
#include <iostream>

typedef double (*ACTIVATION_FUNC) (double);
typedef double (*DERIV_ACTIVATION_FUNC) (double);

class Neuron
{
        private:
                double* pWeights;
                int iNumFrom;

                int iIndex;

    public:
#ifdef SAME_ACTIVATION
        static
#endif
                ACTIVATION_FUNC pActivationFunc;
#ifdef SAME_ACTIVATION
        static
#endif        
                DERIV_ACTIVATION_FUNC pDerivActivationFunc;

        public:
                Neuron();
                Neuron(int numInputs) throw (std::bad_alloc);
                Neuron(const Neuron& neuron) throw (std::bad_alloc);
        Neuron& operator= (const Neuron& neuron) throw (std::bad_alloc);

                void SetNumInputs(int num);
                int GetNumInputs() const { return iNumFrom; }
                void SetActivationFunc(ACTIVATION_FUNC activ_func) { pActivationFunc = activ_func; }
        void SetDerivActivationFunc(DERIV_ACTIVATION_FUNC deriv) { pDerivActivationFunc = deriv; }
                void SetWeight(int indx, double weight);
                void SetWeights(const std::vector<double>& weights);
                double GetWeight(int indx) const;
                void GetWeights(std::vector<double>& weights) const;
        double* GetWeights() { return pWeights; }
        /* Calculate the output from neuron for supplied input.
         * If inputs to neuron have not changed, it is more efficient
         * to call this function once to get the output and store result
         * since this function recomputes the output from input.
         * @param
         * inputs: The vector containing inputs (all of them need not
         * be feeding into this neuron)
         * indices: indices from inputs (vector) that feed into this 
         * neuron. indices must be a pointer to an array having elements
         * = iNumFrom
         */
                double GetOutput(const std::vector<double>& inputs, const int* indices);

        /* Overloaded version when total input for neuron is needed too.
         * total input to the neuron (which provides the 
         * activation) is returned in the last argument, net_input
         * Note neuron activation = g(net_input) where g is the activation
         * function.
         * Calculate the output from neuron for supplied input.
         * If inputs to neuron have not changed, it is more efficient
         * to call this function once to get the output and store result
         * since this function recomputes the output from input.
         * @param
         * inputs: The array containing inputs (all of them need not
         * be feeding into this neuron)
         * indices: indices from inputs (vector) that feed into this 
         * neuron. indices must be a pointer to an array having elements
         * = iNumFrom
         */        
        double GetOutput(const std::vector<double>& inputs, const int* indices, double& net_input);        

        /* Overloaded version when input is provided as array
         * Calculate the output from neuron for supplied input.
         * If inputs to neuron have not changed, it is more efficient
         * to call this function once to get the output and store result
         * since this function recomputes the output from input.
         * @param
         * inputs: The array containing inputs (all of them need not
         * be feeding into this neuron)
         * indices: indices from inputs (vector) that feed into this 
         * neuron. indices must be a pointer to an array having elements
         * = iNumFrom
         */
                double GetOutput(const double* inputs, const int* indices);

        /* Overloaded version when input is provided as array
         * and total input to the neuron (which provides the 
         * activation is returned in the last argument, net_input)
         * Note neuron activation = g(net_input) where g is the activation
         * function.
         * Calculate the output from neuron for supplied input.
         * If inputs to neuron have not changed, it is more efficient
         * to call this function once to get the output and store result
         * since this function recomputes the output from input.
         * @param
         * inputs: The array containing inputs (all of them need not
         * be feeding into this neuron)
         * indices: indices from inputs (vector) that feed into this 
         * neuron. indices must be a pointer to an array having elements
         * = iNumFrom
         */        
        double GetOutput(const double* inputs, const int* indices, double& net_input);

                void SetIndex(int i) { iIndex = i; }
                int GetIndex() const { return iIndex; }
        
                void Clear();

                ~Neuron();
};

std::ostream& operator<< (std::ostream& os, const Neuron& nr);
std::ostream& operator<< (std::ostream& os, const Neuron* nr);

#endif // _AIMAGIK_NEURON_H_

---