第八章 結論與未來展望
8.2 未來展望
本論文主要是在於強調以物件導向程式設計以及運用設計模式 來設計與發展軟體。所以在設計與發展的過程中，並沒有提及以下三 個部份：
1. 異常處理（Exception Handling）[18][19]
所謂的異常（Exception），是指程式在執行時期發生的不正常情 況，例如考慮以下的程式碼：
………//以上省略
MyControl->DoCreateFuzzyValue( ); //建立模糊變數 MyControl->DoCreateRule( ); //建立控制規則庫 MyControl->CreateDefuzzifier( ); //建立解模糊化物件
MyControl->ChooseAlgo(new CenterAvg); //選擇中心平均法
………//以下省略
如果在執行 DoCreateFuzzyValue 之前，先執行了 DoCreateRule
（也就是順序顛倒了），就會發生程式死當的情況。原因是未建 模糊變數之前，是無法建立控制規則庫的。然而，本論文中並沒 有針對諸如此類的異常狀況加以防範。
2. 使用者介面規劃
本論文中，不論是模糊變數的建立，或是控制規則的訂定，都是 在程式的編譯時期才可做設定的工作。而無法在執行時期時動態 的變更模糊變數的內容和增減控制規則。不過，如果要加上使用 者介面的話，為了避免使用者的操作失當，異常處理也就必須要 在考量之中了。
3. 輸入和輸出模糊變數的數量
本論文中，輸入變數為兩個，輸出變數則為一個，而控制規則的 基本格式也為命題部兩個歸屬函數而推論部為一個歸屬函數。如 果今天所要處理的案例，輸入變數為三個，就無法利用類別庫建 立出能處理此案例的模糊控制器物件了。
以上三點是本論文中並未考量的地方，其實這樣的問題是可以解 決的，而在許許多多的設計模式中，也有著解決上述情境的模式存在 著。而將來的發展方向，就是令此類別庫能夠應付更多的外來變化，
而使它能進化到 Application Framework 的程度。
註：凝聚性強、組織化強的類別庫就可稱為 Application Framework。而比較 著名的，如徵軟的 MFC 以及 Borland 的 VCL。
參考文獻
[1] Grady Booch. “Object-Oriented Analysis and Design with Applications”. Benjamin/Cummings, Redwood City, CA, 1994.
Second Edition.
[2] Christopher Alexander, Sara Ishikawa, Murray Silverstein, Max
Jacobson, Ingrid Fiksdahl-King, Shlomo Angel. “A Pattern Language”.
Oxford University Press, New York, 1977.
[3] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. “Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P163-173.
[4] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. “Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P315-323.
[5] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. “Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P305-313.
[6] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. “Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P185-193.
[7] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. “Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P195-206.
[8] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. “Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P87-95.
[9] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. “Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P97-106.
[10] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides.
“Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P331-344.
[11] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides.
“Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P233-242.
[12] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides.
“Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P175-184.
[13] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides.
“Design Patterns: Elements of Reusable Object-Oriented Software”.
Addison-Wesley, 1995. P207-217.
[14] L. A. Zadeh. “Fuzzy Sets”. Information and Control, Vol.8, 1965.
[15] L. A. Zadeh. “Similarity Relations and Fuzzy Orderings”.
Information Sciences,3, 1971.
[16] “A Practical Handbook of Software Construction”. Redmond : Microsoft Press, 1993. P81.
[17] “A Practical Handbook of Software Construction”. Redmond : Microsoft Press, 1993. P87.
[18] Stanley B. Lappman, Josee Lajoie. “C++ Primer”. Addison Wesley, 1998. Third Edition 中譯本：侯捷 譯. 碁峰資訊. P547-570 [19] Herb Sutter. “Exceptional C++”. Addison Wesley, 1999
附錄 1 各類別的宣告（function.h）
#include<string> //引入 string 字串型式標頭檔
using namespace std; //使用標準名稱空間
struct Crisp //表示明確值的結構宣告（內含最大和最小明確值，可能兩者相同）
{
double m_min;
double m_max;
};
double Min(double value1, double value2); //比較兩個數字，並取小值的函式宣告 double Max(double value1, double value2); //比較兩個數字，並取大值的函式宣告
//--- /* BaseFunc 類別，定義歸屬函數的基本特性 */
//--- class BaseFunc
{ private:
string m_FuncName; //記錄此歸屬函數的名稱 double m_Min; //記錄函數最小值
double m_Max; //記錄函數最大值 public:
void SetFuncName(string); //設定歸屬函數名稱 string GetFuncName( ); //取得歸屬函數名稱
void SetMinValue(double Min); //設定歸屬函數範圍最小值 double GetMinValue( ); //取得歸屬函數範圍最小值
void SetMaxValue(double Max); //設定歸屬函數範圍最大值 double GetMaxValue( ); //取得歸屬函數範圍最大值
virtual void DoSetLZeroValue(double Value){}
virtual double DoGetLZeroValue( ){return 0;}
virtual void DoSetLOneValue(double Value){}
virtual double DoGetLOneValue( ){return 0;}
virtual void DoSetRZeroValue(double Value){}
virtual double DoGetRZeroValue( ){return 0;}
virtual void DoSetROneValue(double Value){}
virtual double DoGetROneValue( ){return 0;}
virtual void DoSetMOneValue(double Value){}
virtual double DoGetMOneValue( ){return 0;}
virtual Crisp* DoGetCrisp(double membership){return 0;}
virtual double DoGetResult(double Value){return 0;}
};
//---
//--- /* ZType 類別，定義 Z-Type 歸屬函數 */
//--- class ZType : public BaseFunc
{ private:
double m_MembershipZero;
double m_MembershipOne;
public:
virtual void DoSetRZeroValue(double Value);
virtual double DoGetRZeroValue( );
virtual void DoSetROneValue(double Value);
virtual double DoGetROneValue( );
virtual Crisp* DoGetCrisp(double membership);
virtual double DoGetResult(double Value);
};
//---
//--- /* SType 類別，定義 S-Type 歸屬函數 */
//--- class SType : public BaseFunc
{ private:
double m_MembershipZero;
double m_MembershipOne;
public:
virtual void DoSetLZeroValue(double Value);
virtual double DoGetLZeroValue( );
virtual void DoSetLOneValue(double Value);
virtual double DoGetLOneValue( );
virtual Crisp* DoGetCrisp(double membership);
virtual double DoGetResult(double Value);
};
//---
//--- /* PiType 類別，定義 Pi-Type 歸屬函數 */
//--- class PiType : public BaseFunc
{ private:
double m_LMembershipZero;
double m_LMembershipOne;
double m_RMembershipZero;
double m_RMembershipOne;
public:
virtual void DoSetLZeroValue(double Value);
virtual double DoGetLZeroValue( );
virtual void DoSetLOneValue(double Value);
virtual double DoGetLOneValue( );
virtual void DoSetRZeroValue(double Value);
virtual double DoGetRZeroValue( );
virtual void DoSetROneValue(double Value);
virtual double DoGetROneValue( );
virtual Crisp* DoGetCrisp(double membership);
virtual double DoGetResult(double Value);
};
//---
//--- /* LambdaType 類別，定義 Lambda-Type 歸屬函數 */
//--- class LambdaType : public BaseFunc
{ private:
double m_LMembershipZero;
double m_RMembershipZero;
double m_MMembershipOne;
public:
virtual void DoSetLZeroValue(double Value);
virtual double DoGetLZeroValue( );
virtual void DoSetRZeroValue(double Value);
virtual double DoGetRZeroValue( );
virtual void DoSetMOneValue(double Value);
virtual double DoGetMOneValue( );
virtual Crisp* DoGetCrisp(double membership);
virtual double DoGetResult(double Value);
};
//---
//--- /* FuzzyValue 類別，定義模糊變數的特性*/
//---
#include<map> //即將使用 MAP 資料結構，引入該表頭檔
typedef int TypeID; //自定資料型別
#define ZTYPE 1 //將常數“ZTYPE”定義為 1
#define STYPE 2 //將常數“STYPE”定義為 2
#define PITYPE 3 //將常數“PITYPE”定義為 3
#define LAMBDATYPE 4 //將常數“LAMBDATYPE”定義為 4
class FuzzyValue {
public:
void SetFuzzyValueName(string FuzzyValueName); //設定模糊變數名稱 string GetFuzzyValueName( ); //取得模糊變數名稱
void SetFuzzyValueMin(double min); //設定模糊變數數值範圍最小值 void SetFuzzyValueMax(double max); //設定模糊變數數值範圍最大值 double GetFuzzyValueMin( ); //取得模糊變數數值範圍最小值 double GetFuzzyValueMax( ); //取得模糊變數數值範圍最大值
BaseFunc* CreateFunc(TypeID FuncID, string FuncName, double min, double max);
//新增歸屬函數 void AddFunc(BaseFunc* Func); //加入歸屬函數至 MAP
BaseFunc* GetFunc(string FuncName); //取得歸屬函數
void SetZTypeFunc(string FuncName, double zero, double one); //修正 ZType 歸屬函數 void SetSTypeFunc(string FuncName, double zero, double one); //修正 SType 歸屬函數 void SetPiTypeFunc(string FuncName, double lzero, double lone, double rone, double rzero);
//修正 PiType 歸屬函數 void SetLambdaTypeFunc(string FuncName, double lzero, double mone, double rzero);
//修正 LambdaType 歸屬函數 private:
map<string, BaseFunc*> m_FuncMap;
string m_FuzzyValueName;
double m_min;
double m_max;
};
//---
//--- /* FuzzyValueBuilder 類別，負責模糊變數的生成程序 */
//--- class FuzzyValueBuilder
{ public:
void BuildFuzzyValue(string ValueName, double min, double max); //生成模糊變數 void BuildZTypeFunc(string FuncName, double one, double zero);
//生成 ZType 歸屬函數，並加入模糊變數中 void BuildSTypeFunc(string FuncName, double zero, double one);
//生成 SType 歸屬函數，並加入模糊變數中 void BuildPiTypeFunc(string FuncName, double lzero, double lone, double rone, double rzero); //生成 PiType 歸屬函數，並加入模糊變數中
void BuildLambdaTypeFunc(string FuncName, double lzero, double mone, double rzero);
//生成 LambdaType 歸屬函數，並加入模糊變數 FuzzyValue* GetFuzzyValue( ); //傳回已“組裝”好的模糊變數
private:
FuzzyValue* m_pCurrentFuzzyValue;
};
//---
//--- /* FuzzyRule 類別，描述控制規則的特性（限定命題部為雙變數）*/
//--- class FuzzyRule
{ public:
double GetRuleMembership(double value1, double value2); //求得規則的真實度（歸屬度）
Crisp* GetRuleCrisp(double membership); //以此規則的歸屬性求得明確值（兩個）
void SetIf_1(BaseFunc* basefunc); //設定第一個命題部的模糊變數 void SetIf_2(BaseFunc* basefunc); //設定第二個命題部的模糊變數 void SetThen(BaseFunc* basefunc); //設定推論部的模糊變數 private:
BaseFunc* m_pIf_1;
BaseFunc* m_pIf_2;
BaseFunc* m_pThen;
};
//---
//--- /* FuzzyRuleBase 類別，負責收集控制規則物件 */
//---
#include<vector> //即將使用 vector 資料結構，引入該表頭檔
class FuzzyRuleBase {
public:
void AddRule(BaseFunc* if_1, BaseFunc* if_2, BaseFunc* then); //收集控制規則物件 vector<FuzzyRule*> GetRuleBase(); //取得控制規則庫（為一 vector）
private:
vector<FuzzyRule*> m_RuleVec;
};
//---
//--- /* Algorithm 類別，解模糊化演算法的抽象介面 */
//--- class Algorithm
{ public:
virtual double GetResult(FuzzyRuleBase* RuleBase, double value1, double value2) = 0;
//純虛擬函式 };
//---
//--- /* CenterAvg 類別，中心平均法（Center Average Defuzzifier）*/
//--- class CenterAvg : public Algorithm
{ public:
virtual double GetResult(FuzzyRuleBase* RuleBase, double value1, double value2);
};
//---
//---
//ModMeanMax 類別，修正型最大平均法（Modified Mean of Maxima Defuzzifier）
//--- class ModMeanMax : public Algorithm
{ public:
virtual double GetResult(FuzzyRuleBase* RuleBase, double value1, double value2);
};
//---
//--- /* Defuzzifier 類別，負責解模糊化 */
//--- class Defuzzifier
{ public:
void LoadFuzzyRuleBase(FuzzyRuleBase* RuleBase); //讀取控制規則庫
void UseAlgorithm(Algorithm* Algorithm); //選擇解模糊化方法
double GetResult(double value1, double value2); //取得最終輸出的明確值 private:
Algorithm* m_pAlgorithm;
FuzzyRuleBase* m_pRuleBase;
};
//---
//--- /* FuzzyControl 類別，代表模糊控制器本體*/
//--- class FuzzyControl
{
protected:
FuzzyRuleBase* m_pFuzzyRuleBase;
Defuzzifier* m_pDefuzzifier;
FuzzyValue* m_pFirstValue;
FuzzyValue* m_pSecondValue;
FuzzyValue* m_pOutputValue;
public:
virtual void DoCreateFuzzyValue(){} //產生模糊變數（由子類別定義）
virtual void DoCreateRule(){} //產生控制規則（由子類別定義）
void CreateDefuzzifier(); //產生解模糊化物件
void ChooseAlgo(Algorithm* algorithm); //選擇解模糊化演算化物件
double CycleStart(double value1, double value2); //讀入輸入明確值，計算並產生輸出明確值 };
//---
附錄 2-1 BaseFunc 類別定義（BaseFunc.cpp）
#include "function.h"
void BaseFunc::SetFuncName(string FuncName) {
m_FuncName = FuncName;
}
string BaseFunc::GetFuncName( ) {
return m_FuncName;
}
void BaseFunc::SetMinValue(double Min) {
m_Min = Min;
}
double BaseFunc::GetMinValue( ) {
return m_Min;
}
void BaseFunc::SetMaxValue(double Max) {
m_Max = Max;
}
double BaseFunc::GetMaxValue ( ) {
return m_Max;
}
附錄 2-2 ZType 類別定義（ZType.cpp）
#include "function.h"
void ZType::DoSetRZeroValue(double Value) {
m_MembershipZero = Value;
}
double ZType::DoGetRZeroValue( ) {
return m_MembershipZero;
}
void ZType::DoSetROneValue(double Value) {
m_MembershipOne = Value;
}
double ZType::DoGetROneValue( ) {
return m_MembershipOne;
}
double ZType::DoGetResult(double Value) {
double Min = GetMinValue( );
double Max = GetMaxValue( );
double One = m_MembershipOne;
double Zero = m_MembershipZero;
if( Value>=Min && Value<=One ) {
return 1;
}
if(Value>=One && Value<=Zero ) {
return (Zero-Value)/(Zero-One);
}
if(Value>=Zero && Value<=Max) {
return 0;
}
return 0;
}
Crisp* ZType::DoGetCrisp(double membership) {
Crisp* tempCrisp = new Crisp;
tempCrisp->m_min = GetMinValue( );
tempCrisp->m_max = m_MembershipZero – (m_MembershipZero –m_MembershipOne) * membership;
return tempCrisp;
}
附錄 2-3 SType 類別定義（SType.cpp）
#include "function.h"
void SType::DoSetLZeroValue(double Value) {
m_MembershipZero = Value;
}
double SType::DoGetLZeroValue( ) {
return m_MembershipZero;
}
void SType::DoSetLOneValue(double Value) {
m_MembershipOne = Value;
}
double SType::DoGetLOneValue( ) {
return m_MembershipOne;
}
double SType::DoGetResult(double Value) {
double Min = GetMinValue( );
double Max = GetMaxValue( );
double One = m_MembershipOne;
double Zero = m_MembershipZero;
if( Value>=Min && Value<=Zero ) {
return 0;
}
if(Value>=Zero && Value<=One ) {
return (Value-Zero)/(One-Zero);
}
if(Value>=One && Value<=Max) {
return 1;
}
return 0;
}
Crisp* SType::DoGetCrisp(double membership) {
Crisp* tempCrisp = new Crisp;
tempCrisp->m_min = (m_MembershipOne – m_MembershipZero) * membership + m_MembershipZero;
tempCrisp->m_max = GetMaxValue( );
return tempCrisp;
}
附錄 2-4 PiType 類別定義（PiType.cpp）
#include "function.h"
void PiType::DoSetLZeroValue(double Value) {
m_LMembershipZero = Value;
}
double PiType::DoGetLZeroValue() {
return m_LMembershipZero;
}
void PiType::DoSetLOneValue(double Value) {
m_LMembershipOne = Value;
}
double PiType::DoGetLOneValue( ) {
return m_LMembershipOne;
}
void PiType::DoSetRZeroValue(double Value) {
m_RMembershipZero = Value;
}
double PiType::DoGetRZeroValue( ) {
return m_RMembershipZero;
}
void PiType::DoSetROneValue(double Value) {
m_RMembershipOne = Value;
}
double PiType::DoGetROneValue( ) {
return m_RMembershipOne;
}
double PiType::DoGetResult(double Value) {
double Min = GetMinValue( );
double Max = GetMaxValue( );
double LOne = m_LMembershipOne;
double LZero = m_LMembershipZero;
double ROne = m_RMembershipOne;
double RZero = m_RMembershipZero;
if( Value>=Min && Value<=LZero ) {
return 0;
}
if( Value>=LZero && Value<=LOne ) {
return (Value-LZero)/(LOne-LZero);
}
if( Value>=LOne && Value<=ROne ) {
return 1;
}
if(Value>=ROne && Value<=RZero ) {
return (RZero-Value)/(RZero-ROne);
}
if(Value>=RZero && Value<=Max) {
return 0;
} return 0;
}
Crisp* PiType::DoGetCrisp(double membership) {
Crisp* tempCrisp = new Crisp;
tempCrisp->m_min = (m_LMembershipOne – m_LMembershipZero) * membership + m_LMembershipZero;
tempCrisp->m_max = m_RMembershipZero – (m_RMembershipZero – m_RMembershipOne) * membership;
return tempCrisp;
}
附錄 2-5 LambdaType 類別定義（LambdaType.cpp）
#include "function.h"
void LambdaType::DoSetLZeroValue(double Value) {
m_LMembershipZero = Value;
}
double LambdaType::DoGetLZeroValue( ) {
return m_LMembershipZero;
}
void LambdaType::DoSetRZeroValue(double Value) {
m_RMembershipZero = Value;
}
double LambdaType::DoGetRZeroValue( ) {
return m_RMembershipZero;
}
void LambdaType::DoSetMOneValue(double Value) {
m_MMembershipOne = Value;
}
double LambdaType::DoGetMOneValue( ) {
return m_MMembershipOne;
}
double Lamb daType::DoGetResult(double Value) {
double Min = GetMinValue( );
double Max = GetMaxValue( );
double LZero = m_LMembershipZero;
double RZero = m_RMembershipZero;
double MOne = m_MMembershipOne;
if( Value>=Min && Value<=LZero ) {
return 0;
}
if( Value>=LZero && Value<=MOne ) {
return (Value-LZero)/(MOne-LZero);
}
if(Value>=MOne && Value<=RZero ) {
return (RZero-Value)/(RZero-MOne);
}
if(Value>=RZero && Value<=Max) {
return 0;
} return 0;
}
Crisp* LambdaType::DoGetCrisp(double membership) {
Crisp* tempCrisp = new Crisp;
tempCrisp->m_min = (m_MMembershipOne – m_LMembershipZero) * membership + m_LMembershipZero;
tempCrisp->m_max = m_RMembershipZero – (m_RMembershipZero - m_MMembershipOne) * membership;
return tempCrisp;
}
附錄 2-6 FuzzyValue 類別定義（FuzzyValue.cpp）
#include"function.h"
void FuzzyValue::SetFuzzyValueName(string FuzzyValueName) {
m_FuzzyValueName = FuzzyValueName;
}
string FuzzyValue::GetFuzzyValueName( ) {
return m_FuzzyValueName;
}
BaseFunc* FuzzyValue::CreateFunc(TypeID FuncID, string FuncName, double min, double max) {
BaseFunc *TempFunc;
switch(FuncID) {
case ZTYPE:
TempFunc = new ZType;
TempFunc->SetFuncName(FuncName);
TempFunc->SetMinValue(min);
TempFunc->SetMaxValue(max);
return TempFunc;
case STYPE:
TempFunc = new SType;
TempFunc->SetFuncName(FuncName);
TempFunc->SetMinValue(min);
TempFunc->SetMaxValue(max);
return TempFunc;
case PITYPE:
TempFunc = new PiType;
TempFunc->SetFuncName(FuncName);
TempFunc->SetMinValue(min);
TempFunc->SetMaxValue(max);
return TempFunc;
case LAMBDATYPE:
TempFunc = new LambdaType;
TempFunc->SetFuncName(FuncName);
TempFunc->SetMinValue(min);
TempFunc->SetMaxValue(max);
return TempFunc;
} }
void FuzzyValue::AddFunc(BaseFunc* Func) {
m_FuncMap[Func->GetFuncName( )] = Func;
}
BaseFunc* FuzzyValue::GetFunc(string FuncName) {
return m_FuncMap[FuncName];
}
void FuzzyValue::SetZTypeFunc(string FuncName, double zero, double one) {
BaseFunc* FuncTemp = m_FuncMap[FuncName];
FuncTemp ->DoSetROneValue(zero);
FuncTemp ->DoSetRZeroValue(one);
}
void FuzzyValue::SetSTypeFunc(string FuncName, double zero, double one) {
BaseFunc* FuncTemp = m_FuncMap[FuncName];
FuncTemp ->DoSetLZeroValue(zero);
FuncTemp ->DoSetLOneValue(one);
}
void FuzzyValue::SetPiTypeFunc(string FuncName, double lzero, double lone, double rone, double rzero) {
BaseFunc* FuncTemp = m_FuncMap[FuncName];
FuncTemp ->DoSetLZeroValue(lzero);
FuncTemp ->DoSetLOneValue(lone);
FuncTemp ->DoSetROneValue(rone);
FuncTemp ->DoSetRZeroValue(rzero);
}
void FuzzyValue::SetLambdaTypeFunc(string FuncName, double lzero, double mone, double rzero) {
BaseFunc* FuncTemp = m_FuncMap[FuncName];
FuncTemp ->DoSetLZeroValue(lzero);
FuncTemp ->DoSetMOneValue(mone);
FuncTemp ->DoSetRZeroValue(rzero);
}
void FuzzyValue::SetFuzzyValueMin(double min) {
m_min = min;
}
void FuzzyValue::SetFuzzyValueMax(double max) {
m_max = max;
}
double FuzzyValue::GetFuzzyValueMin( ) {
return m_min;
}
double FuzzyValue::GetFuzzyValueMax( ) {
return m_max;
}
附錄 2-7 FuzzyValueBuilder 類別定義（FuzzyValueBuilder.cpp）
#include"function.h"
void FuzzyValueBuilder::BuildFuzzyValue(string ValueName, double min, double max) {
m_pCurrentFuzzyValue = new FuzzyValue;
m_pCurrentFuzzyValue->SetFuzzyValueName(ValueName);
m_pCurrentFuzzyValue->SetFuzzyValueMin(min);
m_pCurrentFuzzyValue->SetFuzzyValueMax(max);
}
void FuzzyValueBuilder::BuildZTypeFunc(string FuncName, double one, double zero) {
double min = m_pCurrentFuzzyValue->GetFuzzyValueMin( );
double max = m_pCurrentFuzzyValue->GetFuzzyValueMax( );
m_pCurrentFuzzyValue->AddFunc(m_pCurrentFuzzyValue->CreateFunc(ZTYPE, FuncName, min, max));
m_pCurrentFuzzyValue->SetZTypeFunc(FuncName, one, zero);
}
void FuzzyValueBuilder::BuildSTypeFunc(string FuncName, double zero, double one) {
double min = m_pCurrentFuzzyValue->GetFuzzyValueMin( );
double max = m_pCurrentFuzzyValue->GetFuzzyValueMax( );
m_pCurrentFuzzyValue->AddFunc(m_pCurrentFuzzyValue->CreateFunc(STYPE, FuncName, min, max));
m_pCurrentFuzzyValue->SetSTypeFunc(FuncName, zero, one);
}
void FuzzyValueBuilder::BuildPiTypeFunc(string FuncName, double lzero, double lone, double rone, double rzero) {
double fmin = m_pCurrentFuzzyValue->GetFuzzyValueMin();
double fmax = m_pCurrentFuzzyValue->GetFuzzyValueMax();
m_pCurrentFuzzyValue->AddFunc(m_pCurrentFuzzyValue->CreateFunc(PITYPE, FuncName, fmin, fmax));
m_pCurrentFuzzyValue->SetPiTypeFunc(FuncName, lzero, lone, rone, rzero);
}
void FuzzyValueBuilder::BuildLambdaTypeFunc(string FuncName, double lzero, double mone, double rzero) {
double fmin = m_pCurrentFuzzyValue->GetFuzzyValueMin();
double fmax = m_pCurrentFuzzyValue->GetFuzzyValueMax();
m_pCurrentFuzzyValue->AddFunc(m_pCurrentFuzzyValue->CreateFunc(LAMBDATYPE, FuncName, fmin, fmax));
m_pCurrentFuzzyValue->SetLambdaTypeFunc(FuncName, lzero, mone, rzero);
}
FuzzyValue* FuzzyValueBuilder::GetFuzzyValue() {
return m_pCurrentFuzzyValue;
}
附錄 2-8 FuzzyRule 類別定義（FuzzyRule.cpp）
#include"function.h"
void FuzzyRule::SetIf_1(BaseFunc* basefunc) {
m_pIf_1 = basefunc;
}
void FuzzyRule::SetIf_2(BaseFunc* basefunc) {
m_pIf_2 = basefunc;
}
void FuzzyRule::SetThen(BaseFunc* basefunc) {
m_pThen = basefunc;
}
double FuzzyRule::GetRuleMembership(double value1, double value2) {
return Min(m_pIf_1->DoGetResult(value1), m_pIf_2->DoGetResult(value2));
}
Crisp* FuzzyRule::GetRuleCrisp(double membership) {
return m_pThen->DoGetCrisp(membership);
}
附錄 2-9 FuzzyRuleBase 類別定義（FuzzyRuleBase.cpp）
#include"function.h"
void FuzzyRuleBase::AddRule(BaseFunc* if_1, BaseFunc* if_2, BaseFunc* then) {
FuzzyRule* fuzzyRule = new FuzzyRule;
fuzzyRule->SetIf_1(if_1);
fuzzyRule->SetIf_2(if_2);
fuzzyRule->SetThen(then);
m_RuleVec.push_back(fuzzyRule);
}
vector<FuzzyRule*> FuzzyRuleBase::GetRuleBase() {
return m_RuleVec;
}
附錄 2-10 CenterAvg 類別定義（CenterAvg.cpp）
#include"function.h"
double CenterAvg::GetResult(FuzzyRuleBase* RuleBase, double value1, double value2) {
double result1 = 0;
double result2 = 0;
double membership;
Crisp crisp;
for(int index = 0 ; index < (RuleBase->GetRuleBase()).size() ; index++) {
membership = (RuleBase->GetRuleBase( ))[index]->GetRuleMembership(value1, value2);
crisp.m_min = ((RuleBase->GetRuleBase( ))[index]->GetRuleCrisp(membership))->m_min;
crisp.m_max = ((RuleBase->GetRuleBase( ))[index]->GetRuleCrisp(membership))->m_max;
result1 = result1 + membership * ((crisp.m_min + crisp.m_max)/2);
result2 = result2 + membership;
}
return result1/result2;
}
附錄 2-11 ModMeanMax 類別定義（ModMeanMax.cpp）
#include"function.h"
double ModMeanMax::GetResult(FuzzyRuleBase* RuleBase, double value1, double value2) {
double membership = 0;
double membershiptemp = 0;
Crisp crisp;
crisp.m_max = 0;
crisp.m_min = 0;
for(int index = 0 ; index < (RuleBase->GetRuleBase()).size() ; index++) {
membershiptemp = (RuleBase->GetRuleBase())[index]->GetRuleMembership(value1, value2);
if(membershiptemp > membership) {
crisp.m_min = ((RuleBase->GetRuleBase())[index]->GetRuleCrisp(membershiptemp))->m_min;
crisp.m_max = ((RuleBase->GetRuleBase())[index]->GetRuleCrisp(membershiptemp))->m_max;
}
membership = membershiptemp;
}
return (crisp.m_max + crisp.m_min) /2;
}
附錄 2-12 Defuzzifier 類別定義（Defuzzifier.cpp）
#include"function.h"
void Defuzzifier::LoadFuzzyRuleBase(FuzzyRuleBase* RuleBase) {
m_pRuleBase = RuleBase;
}
void Defuzzifier::UseAlgorithm(Algorithm* algorithm) {
m_pAlgorithm = algorithm;
}
double Defuzzifier::GetResult(double value1, double value2) {
return m_pAlgorithm->GetResult(m_pRuleBase, value1, value2);
}
附錄 2-13 FuzzyControl 類別定義（FuzzyControl.cpp）
#include"function.h"
double FuzzyControl::CycleStart(double value1, double value2) {
m_pDefuzzifier->LoadFuzzyRuleBase(m_pFuzzyRuleBase);
return m_pDefuzzifier->GetResult(value1,value2);
}
void FuzzyControl::ChooseAlgo(Algorithm* algorithm) {
m_pDefuzzifier->UseAlgorithm(algorithm);
}
void FuzzyControl::CreateDefuzzifier( ) {
m_pDefuzzifier = new Defuzzifier;
}
附錄 2-14 其它函式定義（Other.cpp）
#include"function.h"
double Min(double value1, double value2) {
if(value1<=value2) return value1;
else
return value2;
}
double Max(double value1, double value2) {
if(value1<=value2) return value2;
else
return value1;
}
附錄 3 類別庫使用實例（Main.cpp）
#include<iostream>
#include "function.h"
using namespace std;
class MyFuzzyControl : public FuzzyControl {
public:
virtual void DoCreateFuzzyValue() {
FuzzyValueBuilder FVBuilder;
FVBuilder.BuildFuzzyValue("Distance",0,1200);
FVBuilder.BuildZTypeFunc("VC",200,400);
FVBuilder.BuildLambdaTypeFunc("C",200,400,600);
FVBuilder.BuildLambdaTypeFunc("SF",400,600,800);
FVBuilder.BuildLambdaTypeFunc("F",600,800,1000);
FVBuilder.BuildSTypeFunc("VF",800,1000);
m_pFirstValue = FVBuilder.GetFuzzyValue();
FVBuilder.BuildFuzzyValue("Speed",0,600);
FVBuilder.BuildZTypeFunc("VLS",100,200);
FVBuilder.BuildLambdaTypeFunc("LS",100,200,300);
FVBuilder.BuildLambdaTypeFunc("MS",200,300,400);
FVBuilder.BuildLambdaTypeFunc("HS",300,400,500);
FVBuilder.BuildSTypeFunc("VHS",400,500);
m_pSecondValue = FVBuilder.GetFuzzyValue();
FVBuilder.BuildFuzzyValue("Output",0,600);
FVBuilder.BuildZTypeFunc("VLS",100,200);
FVBuilder.BuildLambdaTypeFunc("LS",100,200,300);
FVBuilder.BuildLambdaTypeFunc("MS",200,300,400);
FVBuilder.BuildLambdaTypeFunc("HS",300,400,500);
FVBuilder.BuildSTypeFunc("VHS",400,500);
m_pOutputValue = FVBuilder.GetFuzzyValue();
}
virtual void DoCreateRule() {
m_pFuzzyRuleBase = new FuzzyRuleBase;
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("VC"),
m_pSecondValue->GetFunc("VLS"), m_pOutputValue->GetFunc("VHS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("C"),
m_pSecondValue->GetFunc("VLS"), m_pOutputValue->GetFunc("VHS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("SF"),
m_pSecondValue->GetFunc("VLS"), m_pOutputValue->GetFunc("HS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("F"),
m_pSecondValue->GetFunc("VLS"), m_pOutputValue->GetFunc("MS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("VF"),
m_pSecondValue->GetFunc("VLS"), m_pOutputValue->GetFunc("VLS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("VC"),
m_pSecondValue->GetFunc("LS"), m_pOutputValue->GetFunc("VHS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("C"),
m_pSecondValue->GetFunc("LS"), m_pOutputValue->GetFunc("HS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("SF"),
m_pSecondValue->GetFunc("LS"), m_pOutputValue->GetFunc("HS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("F"),
m_pSecondValue->GetFunc("LS"), m_pOutputValue->GetFunc("MS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("VF"),
m_pSecondValue->GetFunc("LS"), m_pOutputValue->GetFunc("VLS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("VC"),
m_pSecondValue->GetFunc("MS"), m_pOutputValue->GetFunc("VHS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("C"),
m_pSecondValue->GetFunc("MS"), m_pOutputValue->GetFunc("HS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("SF"),
m_pSecondValue->GetFunc("MS"), m_pOutputValue->GetFunc("MS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("F"),
m_pSecondValue->GetFunc("MS"), m_pOutputValue->GetFunc("LS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("VF"),
m_pSecondValue->GetFunc("MS"), m_pOutputValue->GetFunc("VLS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("VC"),
m_pSecondValue->GetFunc("HS"), m_pOutputValue->GetFunc("VHS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("C"),
m_pSecondValue->GetFunc("HS"), m_pOutputValue->GetFunc("MS"));
m_pFuzzyRuleBase->AddRule(m_pFirstValue->GetFunc("SF"),