fis.h

2002年

#ifndef __FIS_H__
#define __FIS_H__

#include <stdio.h>

enum Bool {False, True};
enum AndMethod{
	MINAND,
	PRODAND	
};

enum ORMethod{
	MAXOR,
	PROBOR	
};

enum DEFZYMethod{
	CENTROID,
	WEIGHTSUM,
	WEIGHTAVERAGE	
};

enum RULECONNECTTYPE{
	ANDRULE,
	ORRULE
};

enum MEMFUNC{
	ATRIMF,
	TRIMF,
	TRAPMF,
	GAUSSMF,
	GAUSS2MF,
	GBELLMF,
	SIGMF,
	DSIGMF,
	PSIGMF,
	ZMF,
	PIMF,
	SMF,

	LINEAR,
	CONSTANT
};

enum SYSTYPE{
	SUGENO,
	MAMDANI,
	RL
};

#define STR_LEN 1024
#define MAXMFPARAMS 5
#define BUFFERLEN 1024

class FIS;

class MemFunc{
private:
	MEMFUNC mftype;
	char name[STR_LEN];
	int numparams;
	float params[MAXMFPARAMS];
	float input,output;
public:
	MemFunc();
	//~MemFunc();
	MEMFUNC GetMFType(){ return mftype;}
	void SetMFType(MEMFUNC mftype);
	float GetMembership(float input);	//input memfunc
	float GetOutput(){ return output;}
	char* MemFuncName(){ return name;}
	int NumParams(){ return numparams;}
	float Param(int idx){ if (idx <= 0 || idx > numparams) return 0; else return params[idx -1];}
	
//static function	
	/*  triangular membership function */
	static void trimf(float input,float& output,int numparams,float* params);

	/*	trapezoidal membership function	*/
	static void trapmf(float input,float& output,int numparams,float* params);

	/*GAUSSMF(X, [SIGMA, C]) = EXP(-(X - C).^2/(2*SIGMA^2))*/
	static void gaussmf(float input,float& output,int numparams,float* params);

	static void gauss2mf(float input,float& output,int numparams,float* params);

	/* GBELLMF(X, [A, B, C]) = 1./((1+ABS((X-C)/A))^(2*B))*/
	static void gbellmf(float input,float& output,int numparams,float* params);

	/*SIGMF(X, [A, C]) = 1./(1 + EXP(-A*(X-C)))*/
	static void sigmf(float input,float& output,int numparams,float* params);

	static void dsigmf(float input,float& output,int numparams,float* params);
	/*PSIGMF(X, PARAMS) = SIGMF(X, PARAMS(1:2)).*SIGMF(X, PARAMS(3:4));*/
	static void psigmf(float input,float& output,int numparams,float* params);

	static void zmf(float input,float& output,int numparams,float* params);

	static void smf(float input,float& output,int numparams,float* params);
	/*PIMF(X, PARAMS) = SMF(X, PARAMS(1:2)).*ZMF(X, PARAMS(3:4))*/
	static void pimf(float input,float& output,int numparams,float* params);
	/* Constant	*/
	static void cmf(float input, float& output, int numparams, float* params);

	/*	Linear	*/
	static void lmf(float input, float& output, int numparams, float* params);

	friend class FIS;
};

class FuzzyVariable{
private:
	float input, output;// input is for fuzzyinput, output is for fuzzy output
	int nummfs;
	float input_inf, input_sup;
	MemFunc * mfs;
	char name[STR_LEN];
public:
	FuzzyVariable();
	void SetInput(float input){ this->input = input;}
	float GetOutput(int idx);
	float GetMembership(int idx, float input);
	void Fuzzify();
	void ReleaseResource();
	friend class FIS;
};

class Rule{
private:
	RULECONNECTTYPE rc_type;
	float weight;
	int numinputs;
	int numoutputs;
	int* inputmfidx;
	int* outputmfidx;
	float firestrength;
public:
	Rule(int numinputs = 0, int numoutputs = 0);
	//~Rule();
	void SetRuleParams(int numinputs, int numoutputs);
	void ReleaseResource();
	RULECONNECTTYPE GetRuletype(){ return rc_type;}
	float GetFirestrength(){ return firestrength;}
	friend class FIS;
};

class FIS{
private:
	AndMethod	andtype;
	ORMethod	ortype;
	AndMethod	imptype;
	ORMethod	aggtype;
	DEFZYMethod defzytype;
	SYSTYPE systype;
	char name[STR_LEN];
	int numinputs;
	int numoutputs;
	int numrules;
	
	FuzzyVariable * fuzzyinputs;
	FuzzyVariable * fuzzyoutputs;
	Rule * rules;
/*	for restore a fis from file	*/
	Bool Islabel;
	char buf[BUFFERLEN], namebuf[STR_LEN], valuebuf[STR_LEN], stringbuf[STR_LEN];
	char* getNextLine(FILE* fp);
	Bool ParseLine();
	Bool AnalyzeNextEntry(FILE* fp);
	Bool getString();

/*	For weight func	*/
	int outputidx;
public:
	FIS();
	~FIS();
	AndMethod GetAndType(){ return andtype;}
	ORMethod  GetOrType(){ return ortype;}
	AndMethod GetImpType(){ return imptype;}
	DEFZYMethod  GetDFZType(){ return defzytype;}
	SYSTYPE GetSysType(){return systype;}
	void SetAndType(AndMethod andtype){ this->andtype = andtype;}
	void SetORType(ORMethod ortype){ this->ortype = ortype;}
	void SetImpType(AndMethod imptype){ this->imptype = imptype;}
	void SetDFZType(DEFZYMethod defzytype){ this->defzytype = defzytype;}
	void SetSysType(SYSTYPE systype){ this->systype = systype;}
	int NumInputs(){ return numinputs;}
	int NumOutputs(){ return numoutputs;}
	int NumRules(){ return numrules;}
	float AND(float x, float y, AndMethod and_type);
	float OR(float x, float y, ORMethod or_type);
	float AND(float x, float y);
	float OR(float x, float y);
/*	Restore a FIS from file	*/
	Bool RestoreFIS(char* filename);
/*	FIS Run	*/
	void FISRun(float* input, float* output);
	void SetInput(int idx, float input);
	void SetInput(float* input);
	void Fuzzify();
	void ApplyRule(int idx);
	float Imp_Defuzzy(int idx);
	float CentroidDefzy(int idx);
	float WeightFunc(float x, int no);
	float Simpson(int n, float a, float b, int no);
	float Gauss(int n, float a, float b, int no);
	float Romberg(int n, float a, float b, int no);
};

#endif //__FIS_H__