NetParams.h

#ifndef NetParams_H
#define NetParams_H

#include "Data.h"
#include "Mapcode.h"


#include <string>

using std::string;

class NetParams {
protected:
        string          _learnType;
        int             _learning_type;
        int             _init_type;
        Value_Type      _init_learning_rate;
        Value_Type      _init_neighbor;
        Mapcode *       _mapcode;
        SOMData *       _data;
        int             _num_iterations;
        TMatrix         _delta;
        
public:

        void setMapcode( Mapcode * mapcode );

        void setData( SOMData * data );
        
        void setDelta( TMatrix delta );

        TMatrix getDelta() const;

        NetParams();

        Mapcode * getMapcode() const;

        SOMData * getData() const;

        int             getNumIterations();

        void    setNumIterations( int i );

        int             getInitType();

        void    setInitType( int init );

        Value_Type      getInitLearningRate();

        void    setInitLearningRate( Value_Type init_rate );

        Value_Type      getInitNeighbor();

        void    setInitNeighbor( Value_Type init_neighbor );

        int             getLearningType();

        void    setLearningType( int t );

        void setLearnType( string str );

        string getLearnType();
};

void 
NetParams::setMapcode( Mapcode * mapcode ) {
        _mapcode = mapcode;
};

void 
NetParams::setData( SOMData * data ) {
        _data = data;
};

void 
NetParams::setLearnType( string str ) {
        _learnType = str;
};

string 
NetParams::getLearnType() {
        return _learnType;
};



NetParams::NetParams() {
        _data    = new SOMData;
        _mapcode = new Mapcode;
        _data->setEntries( 0 );
        _mapcode->setCodebook( 0 );
};

Mapcode *
NetParams::getMapcode() const {
        return _mapcode;
};

SOMData *       
NetParams::getData() const {
        return _data;
};

int 
NetParams::getNumIterations() {
        return _num_iterations;
};

void 
NetParams::setNumIterations( int i ) {
        _num_iterations = i;
};

int 
NetParams::getInitType() {
        return _init_type;
};

void 
NetParams::setInitType( int init ) {
        _init_type = init;
};

Value_Type 
NetParams::getInitLearningRate() {
        return _init_learning_rate;
};

void 
NetParams::setInitLearningRate( Value_Type init_rate ) {
        _init_learning_rate = init_rate;
};

Value_Type 
NetParams::getInitNeighbor() {
        return _init_neighbor;
};

void 
NetParams::setInitNeighbor( Value_Type init_neighbor ) {
        _init_neighbor = init_neighbor;
};

int 
NetParams::getLearningType() {
        return _learning_type;
};

void 
NetParams::setLearningType( int t ) {
        _learning_type = t;
};

void 
NetParams::setDelta( TMatrix delta ) {
        _delta = delta;
};

TMatrix
NetParams::getDelta() const {
        return _delta;
}

#endif

---