---

annetwork.h

Go to the documentation of this file.

#ifndef __INANNA_ANNETWORK_H__
#define __INANNA_ANNETWORK_H__

#include <magic/mobject.h>
#include <magic/mcoord.h>
#include <magic/mtable.h>
#include <magic/mattribute.h>
#include "inanna/learning.h"
#include "inanna/topology.h"
#include "inanna/neuron.h"

// External predeclarations
class NeuronInitializer;
class Equalizer;

// Internal predeclarations
class FreeWeight;
class Connection;
class Neuron;
class ANNetwork;



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


// We are so f*cking free that all this f*cking freedom restricts our
// f*cking lives so f*cking much

class NeuronContainer : public Array<Neuron> {
    decl_dynamic (NeuronContainer);
  public:
                        NeuronContainer     () : mUnits (*this) {}
                        NeuronContainer     (int size) : Array<Neuron> (size), mUnits (*this) {}
                        ~NeuronContainer    ();

    //void              makeNeurons     (int size) {make (size);}

    void                add             (Neuron* neuron);

    void                removeUnit      (int i);

    //void              writeXML        (OStream& out) const;

  private:
    void                disconnectAll   ();
    
  protected:
    Array<Neuron>&  mUnits;
};



//                                                                           //
//                _   |   | |   |                           |                //
//               / \  |\  | |\  |  ___   |                  |                //
//              /   \ | \ | | \ | /   ) -+- \    /  __  |/\ | /              //
//              |---| |  \| |  \| |---   |   \\//  /  \ |   |/               //
//              |   | |   | |   |  \__    \   VV   \__/ |   | \              //
//                                                                           //

class ANNetwork : public NeuronContainer, virtual public Learner, public Attributed {
    decl_dynamic (ANNetwork);
  public:

                        ANNetwork       (const char* description=NULL);
                        ANNetwork       (const ANNetwork& orig) {copy (orig);}
    virtual             ~ANNetwork  ();

    void                makeUnits       (const char* topology);

    virtual void        make            (const char* top) {makeUnits(top);}

    virtual void        empty           ();

    virtual void        copy            (const ANNetwork& fnet, bool onlyWeights=false);

    void                connectFfw      (const PackTable<int>& conns);

    void                connectFullFfw  (bool shortcuts);

    void                connectFull     ();

    void                setUnitPrototype    (Neuron* t) {delete mUnitTemplate; mUnitTemplate=t;}
    const Neuron    *   getUnitPrototype    () const {return mUnitTemplate;}

    virtual void        copyFreeNet     (const ANNetwork& orig, bool onlyWeights=false);

    virtual void        init            (double r=0.0);

    void                reset           ();

    virtual void        update   ();

    virtual Vector      testPattern     (const PatternSource& set, int pattern) const;

    const ANNTopology&  getTopology     () const {return *mTopology;}
    //const ANNLayering&    getLayering     () const {return *mTopology;}

    void                setInitializer  (NeuronInitializer* initer);    

    Equalizer*          getEqualizer    () {return mpEqualizer;}

    const Equalizer*    getEqualizer    () const {return mpEqualizer;}

    void                setEqualizer    (Equalizer* eq=NULL);

    // Tools

    Connection*         connect         (int i, int j);

    virtual OStream&    operator>>		(OStream& out) const;

    void                cleanup         (bool removeDisableds=false,
                                         bool removePassthroughs=false);

    String              drawEPS         (double xsize=-1, double ysize=-1) const;

    void                drawFeedForward ();

    void                check           () const;
    
  protected:
    ANNTopology*        mTopology;

    Neuron*             mUnitTemplate;

    NeuronInitializer*  mInitializer;

    Equalizer*          mpEqualizer;

  private:
    void                orderColumn     (int colStart, int colEnd);

    void operator= (const ANNetwork& other) {FORBIDDEN} // Prevent
};

// "Man is truly free only when man truly dies" -- Prince

#endif

---