/*
 * MLPConfig.h
 *
 *  Created on: 09.06.2011
 *      Author: sven
 */

#ifndef MLPCONFIG_H_
#define MLPCONFIG_H_

#include <boost/cstdint.hpp>
#include <vector>
#include <fstream>

using namespace std;
using namespace boost;

typedef vector< vector<double> > Weights;

class MLPConfig {
public:
	MLPConfig();
	MLPConfig(const char* configfile);
	virtual ~MLPConfig();

    enum UPDATE_MODE
	{
		UPDATE_MODE_SINGLE,
		UPDATE_MODE_BATCH
	};
	enum OUTPUT_TRANSFER_FUNC
	{
		OUTPUT_TRANSFER_FUNC_NORMAL
	};

    double getLernrate() const
    {
        return mLernrate;
    }

    double getMomentum() const
    {
        return mMomentum;
    }

    uint32_t getNumHiddenNeurons() const
    {
        return mNumHiddenNeurons;
    }

    uint32_t getNumInputNeurons() const
    {
        return mNumInputNeurons;
    }

    uint32_t getNumOutputNeurons() const
    {
        return mNumOutputNeurons;
    }

    OUTPUT_TRANSFER_FUNC getOutputTransferFunc() const
    {
        return mOutputTransferFunc;
    }

    UPDATE_MODE getUpdateMode() const
    {
        return mUpdateMode;
    }

    void setLernrate(double mLernrate)
    {
        this->mLernrate = mLernrate;
    }

    void setMomentum(double mMomentum)
    {
        this->mMomentum = mMomentum;
    }

    void setNumHiddenNeurons(uint32_t mNumHiddenNeurons)
    {
        this->mNumHiddenNeurons = mNumHiddenNeurons;
    }

    void setNumInputNeurons(uint32_t mNumInputNeurons)
    {
        this->mNumInputNeurons = mNumInputNeurons;
    }

    void setNumOutputNeurons(uint32_t mNumOutputNeurons)
    {
        this->mNumOutputNeurons = mNumOutputNeurons;
    }

    void setOutputTransferFunc(OUTPUT_TRANSFER_FUNC mOutputTransferFunc)
    {
        this->mOutputTransferFunc = mOutputTransferFunc;
    }

    void setUpdateMode(UPDATE_MODE mUpdateMode)
    {
        this->mUpdateMode = mUpdateMode;
    }

    bool isValid(){
    	return mValid;
    }

    const Weights& getWeights() const {
    	return mWeights;
    }

    const double& getErrorThreshold() const {
    	return mErrorThreshold;
    }

    void setErrorThreshold(double e) {
    	mErrorThreshold = e;
    }

    const double& getConfigAcceptanceErrorThreshold() const {
    	return mConfigAcceptanceErrorThreshold;
    }

    void setConfigAcceptanceErrorThreshold(double e) {
    	mConfigAcceptanceErrorThreshold = e;
    }

    uint32_t getNumTrainingCycles() const {
    	return mNumTrainingCycles;
    }

    void setNumTrainingCycles(uint32_t c)
    {
    	mNumTrainingCycles=c;
    }

    void dump();
    void initWeights(bool);
    bool parseConfigfile(const char*);

private:
	uint32_t mNumInputNeurons;
	uint32_t mNumHiddenNeurons;
	uint32_t mNumOutputNeurons;
	UPDATE_MODE mUpdateMode;
	OUTPUT_TRANSFER_FUNC mOutputTransferFunc;
	double mLernrate;
	double mMomentum;
	Weights mWeights;
	bool mValid;
	double mErrorThreshold;
	uint32_t mNumTrainingCycles;
	double mConfigAcceptanceErrorThreshold;

	bool parseConfigfile(ifstream&);
	bool parseLine(string&);
	uint32_t toUint32(const string&);
	double toDouble(const string &);
	double getRandomWeight();
};

#endif /* MLPCONFIG_H_ */