---

neuron.h

Go to the documentation of this file.

#ifndef __NEURON_H__
#define __NEURON_H__

#include <magic/mobject.h>
#include <magic/mcoord.h>
#include <magic/mpararr.h>

#include "connection.h"

// Externals
class NeuronInitializer;
class NeuronContainer;      // In freenet.h


// We can not be truly free before we can freely connect ourself in a
// global free network where we can freely control each other!


//                 ___          o                  __  ___                  //
//                |   | |          ___   ___   |  /  \ |  \                 //
//                |   | |---    | /   ) |   \ -+-  __/ |   |                //
//                |   | |   )   | |---  |      |     \ |   |                //
//                `___´ |__/  \_|  \__   \__/   \ \__/ |__/                 //

class Object3D {
  public:

    void                    copy            (const Object3D& other);
    
    const Coord3D&          getPlace        () const {return mCoord;}

    void                    getPlace        (double& x, double& y, double& z) const;

    void                    moveTo          (const Coord3D& o) {mCoord = o;}

    void                    moveTo          (double x, double y, double z=0.0) {mCoord.moveTo (x,y,z);}

  protected:
    Coord3D         mCoord;
};



//                      ----  o |   |          |                            //
//                      |   )   |\  |          |  ___                       //
//                      |---  | | \ |  __   ---| /   )                      //
//                      |   ) | |  \| /  \ (   | |---                       //
//                      |___  | |   | \__/  ---|  \__                       //

class BiNode : public Object {
    decl_dynamic (BiNode);
  public:
                            BiNode          () {}
                            BiNode          (const BiNode& orig) {copy (orig);}
    virtual                 ~BiNode         ();
    
    void                    addIncoming     (Connection* conn) {mIncoming.add (conn);}

    void                    addOutgoing     (Connection* conn) {mOutgoing.add (conn);}

    void                    connectFrom     (const BiNode& source);

    bool                    connectedFrom   (const BiNode& source) const;

    // Disconnecting

    void                    disconnectFrom  (const Connection& incoming);
    
    void                    disconnectTo    (const Connection& outgoing);

    void                    disconnectFrom  (const BiNode& source);

    void                    disconnectTo    (const BiNode& target);
    
    void                    disconnectAll   ();

    // Connection access
    
    Connection&             incoming        (int i) {return mIncoming[i];}
    const Connection&       incoming        (int i) const {return mIncoming[i];}

    Connection&             outgoing        (int i) {return mOutgoing[i];}
    const Connection&       outgoing        (int i) const {return mOutgoing[i];}

    int                     incomings       () const {return mIncoming.size();}

    int                     outgoings       () const {return mOutgoing.size();}

    int                     id              () const {return mId;}

    virtual void            copy            (const BiNode& orig);

    virtual void            check           (int netSize) const;

    //virtual void          writeXML        (OStream& out) const;

  private:
    int                 mId;

    Array<Connection>   mIncoming;

    Array<Connection>   mOutgoing;
    
    void                setId           (int id) {mId = id;}

    void                shallowDisconnectAll    ();
    
    friend class NeuronContainer;
};

//                     |   |                                                //
//                     |\  |  ___                   _                       //
//                     | \ | /   ) |   | |/\  __  |/ \                      //
//                     |  \| |---  |   | |   /  \ |   |                     //
//                     |   |  \__   \__! |   \__/ |   |                     //

class Neuron : public BiNode, public Object3D {
    decl_dynamic (Neuron);
  public:

                            Neuron      ();
                            Neuron      (const Neuron& orig) : mBias (0,0) {copy(orig);}
                            ~Neuron     ();

    virtual void            init            (double r=0.0);

    void                    reset           () {mActivation=0.0;}

    virtual void            transfer        (ANNetwork& net);

    // Manipulation

    inline double           activation      () const {return mActivation;}

    virtual void            setActivation   (double a) {mActivation = a;}
    
    void                    operator=		(double a) {mActivation=a;}
    
    virtual double          output          () const {return mActivation;}
    
                            operator const double	() const {return mActivation;}

    double                  bias            () const {return mBias.weight();}

    void                    setBias         (double b) {mBias = b;}

    Connection&             getBiasObj      () {return mBias;}

    int                     getType         () const {return mType;}
    
    void                    setType         (int t) {mType = t;}

    int                     transferFunc    () const {return mTransferFunc;}

    void                    setTFunc        (int f) {mTransferFunc = f;}

    void                    enable          (bool s=true) {mExists=s;}

    bool                    isEnabled       () const {return mExists;}

    // Connection manipulation

    void                    copy            (const Neuron& orig);

    virtual Neuron*     clone           () const {return new Neuron(*this);}

    virtual void            check           (int netSize) const;

    //virtual void          writeXML        (OStream& out) const;

    enum unitTypes {INPUTUNIT=0, HIDDENUNIT=1, OUTPUTUNIT=2};

    enum tfuncs {LOGISTIC_TF=0, LINEAR_TF=1, ELLIOTT_TF=2};

  protected:
    
    double          mActivation;

    Connection      mBias;

    int             mType;

    int             mTransferFunc;
    
    bool            mExists;
    
  private:
    //void          adjustAbove     (int targetIndex);

    void operator= (const Neuron& other); // Prevent

    friend class NeuronContainer;
    friend class ANNetwork;
};



//       |   |                            |   | o       o                    //
//       |\  |  ___                   _   |   |    ____    |                 //
//       | \ | /   ) |   | |/\  __  |/ \  |   | | (     | -+-  __  |/\       //
//       |  \| |---  |   | |   /  \ |   |  \ /  |  \__  |  |  /  \ |         //
//       |   |  \__   \__! |   \__/ |   |   V   | ____) |   \ \__/ |         //

class NeuronVisitor {
  public:
    virtual void    visit   (Neuron& neuron) const=0;
};

#endif

---