---

HopfieldNetwork.h

Go to the documentation of this file.

#ifndef _HOPFIELDNETWORK_H
#define _HOPFIELDNETWORK_H

#include "Network.h"
#include "RecurrentNeuron.h"
#include "Matrix.h"
#include <vector>

namespace annie
{

real isPositive(real x);

class HopfieldNetwork : public Network
{
protected:
        bool _bipolar;

        int _nPatterns;

        Matrix *_weightMatrix;

        RecurrentNeuron** _neurons;

        virtual bool _equal(std::vector<int> &p1, std::vector<int> &p2);
        int _time;

public:
        HopfieldNetwork(int size);

        HopfieldNetwork(int size, bool bias, bool bipolar);

        HopfieldNetwork(const char *filename);

        virtual ~HopfieldNetwork();

        virtual void addPattern(int pattern[]);

        virtual real getEnergy();

        virtual real getEnergy(int pattern[]);

        virtual int getSize();

        virtual void step();

        virtual int getTime();

        virtual int getPatternCount();

        virtual Matrix getWeightMatrix();

        virtual const char* getClassName();

        virtual void save(const char *filename);

        virtual void setWeight(int i, int j, real weight);

        /* Given an input pattern, keeps iterating through time till the network
          * output converges. Ofcourse, it is possible that this never happens
          * and hence a timeout has to be specified.
          * \todo Implement this!
          * @param pattern The initial input pattern given to the network
          * @param updateAll Determines type of updating (synchronous, asynchronous)
          * @param timeout The maximum number of iteration to try convergence for
      * @return false if the network output didn't converge till the timeout, true otherwise
          */
        //virtual bool converge(int pattern[], bool updateAll, int timeout);

        virtual real getBias(int i);

        virtual void setBias(int i, real bias);

        virtual void setInput(int pattern[]);
        
        virtual void setInput(std::vector<int> &pattern);
        
        virtual std::vector<int> getOutput();
        
        virtual std::vector<int> getNextOutput();
        
        virtual VECTOR getOutput(VECTOR &input);
        
        virtual bool propagate(int pattern[], int timeout);
        
        virtual bool propagate(std::vector<int> &pattern, int timeout);
};
}; //namespace annie
#endif // define _HOPFIELDNETWORK_H

---