557 lines
22 KiB
MQL5
557 lines
22 KiB
MQL5
|
//+------------------------------------------------------------------+
|
||
|
|
//| mandanifuzzysystem.mqh |
|
||
|
|
//| Copyright 2000-2025, MetaQuotes Ltd. |
|
||
|
|
//| https://www.mql5.com |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Implementation of Fuzzy library in MetaQuotes Language 5 |
|
||
|
|
//| |
|
||
|
|
//| The features of the library include: |
|
||
|
|
//| - Create Mamdani fuzzy model |
|
||
|
|
//| - Create Sugeno fuzzy model |
|
||
|
|
//| - Normal membership function |
|
||
|
|
//| - Triangular membership function |
|
||
|
|
//| - Trapezoidal membership function |
|
||
|
|
//| - Constant membership function |
|
||
|
|
//| - Defuzzification method of center of gravity (COG) |
|
||
|
|
//| - Defuzzification method of bisector of area (BOA) |
|
||
|
|
//| - Defuzzification method of mean of maxima (MeOM) |
|
||
|
|
//| |
|
||
|
|
//| This file is free software; you can redistribute it and/or |
|
||
|
|
//| modify it under the terms of the GNU General Public License as |
|
||
|
|
//| published by the Free Software Foundation (www.fsf.org); either |
|
||
|
|
//| version 2 of the License, or (at your option) any later version. |
|
||
|
|
//| |
|
||
|
|
//| This program is distributed in the hope that it will be useful, |
|
||
|
|
//| but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||
|
|
//| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||
|
|
//| GNU General Public License for more details. |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
#include <Arrays\List.mqh>
|
||
|
|
#include <Arrays\ArrayDouble.mqh>
|
||
|
|
#include "GenericFuzzySystem.mqh"
|
||
|
|
#include "InferenceMethod.mqh"
|
||
|
|
#include "RuleParser.mqh"
|
||
|
|
#include "FuzzyRule.mqh"
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Purpose: Creating Mamdani fuzzy system |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Mamdani fuzzy inference system |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
class CMamdaniFuzzySystem : public CGenericFuzzySystem
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
CList* m_output; // List of fuzzy variable
|
||
|
|
CList* m_rules; // List of Mamdani fuzzy rule
|
||
|
|
ImplicationMethod m_impl_method; // Implication method
|
||
|
|
AggregationMethod m_aggr_method; // Aggregation method
|
||
|
|
DefuzzificationMethod m_defuzz_method; // Defuzzification method
|
||
|
|
|
||
|
|
public:
|
||
|
|
CMamdaniFuzzySystem(void);
|
||
|
|
~CMamdaniFuzzySystem(void);
|
||
|
|
//--- method gets the output linguistic variables
|
||
|
|
CList* Output(void) { return(m_output); }
|
||
|
|
//--- method gets the fuzzy rule
|
||
|
|
CList* Rules(void) { return(m_rules); }
|
||
|
|
//--- methods gets or sets the implication method
|
||
|
|
ImplicationMethod GetImplicationMethod(void) const { return (m_impl_method); }
|
||
|
|
void SetImplicationMethod(ImplicationMethod value) { m_impl_method=value; }
|
||
|
|
//--- methods gets or sets the aggregation method
|
||
|
|
AggregationMethod GetAggregationMethod(void) const { return (m_aggr_method); }
|
||
|
|
void SetAggregationMethod(AggregationMethod value) { m_aggr_method=value; }
|
||
|
|
//--- methods gets or sets the defuzzification method
|
||
|
|
DefuzzificationMethod GetDefuzzificationMethod(void) const { return (m_defuzz_method); }
|
||
|
|
void SetDefuzzificationMethod(DefuzzificationMethod value) { m_defuzz_method=value; }
|
||
|
|
//--- maethod gets the variable by name
|
||
|
|
CFuzzyVariable* OutputByName(const string name);
|
||
|
|
//--- create a new rule
|
||
|
|
CMamdaniFuzzyRule* EmptyRule(void);
|
||
|
|
//--- parse rule
|
||
|
|
CMamdaniFuzzyRule* ParseRule(const string rule);
|
||
|
|
//--- method for calculate result
|
||
|
|
CList* Calculate(CList *inputValues);
|
||
|
|
CList* EvaluateConditions(CList *fuzzifiedInput);
|
||
|
|
CList* Implicate(CList *conditions);
|
||
|
|
CList* Aggregate(CList *conclusions);
|
||
|
|
CList* Defuzzify(CList *fuzzyResult);
|
||
|
|
double Defuzzify(IMembershipFunction *mf,const double min,const double max);
|
||
|
|
};
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Constructor without parameters |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CMamdaniFuzzySystem::CMamdaniFuzzySystem(void)
|
||
|
|
{
|
||
|
|
m_output = new CList;
|
||
|
|
m_rules = new CList;
|
||
|
|
m_impl_method = MinIpm; // Implication method default is Min
|
||
|
|
m_aggr_method = MaxAgg; // Aggregation method default is Max
|
||
|
|
m_defuzz_method = CentroidDef; // Defuzzification method default is Centroid
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Destructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CMamdaniFuzzySystem::~CMamdaniFuzzySystem(void)
|
||
|
|
{
|
||
|
|
delete m_output;
|
||
|
|
delete m_rules;
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get output linguistic variable by its name |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CFuzzyVariable *CMamdaniFuzzySystem::OutputByName(const string name)
|
||
|
|
{
|
||
|
|
for(int i=0; i<m_output.Total(); i++)
|
||
|
|
{
|
||
|
|
CFuzzyVariable *var=m_output.GetNodeAtIndex(i);
|
||
|
|
if(var.Name()==name)
|
||
|
|
{
|
||
|
|
//--- return varriable
|
||
|
|
return (var);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Print("Variable with that name is not found");
|
||
|
|
//--- return
|
||
|
|
return (NULL);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Create new empty rule |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CMamdaniFuzzyRule *CMamdaniFuzzySystem::EmptyRule()
|
||
|
|
{
|
||
|
|
//--- return empty rule
|
||
|
|
return new CMamdaniFuzzyRule();
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Parse rule from the string |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CMamdaniFuzzyRule *CMamdaniFuzzySystem::ParseRule(const string rule)
|
||
|
|
{
|
||
|
|
//--- return Mamdani fuzzy rule
|
||
|
|
return CRuleParser::Parse(rule, EmptyRule(), Input(), Output());
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate output values |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CList *CMamdaniFuzzySystem::Calculate(CList *inputValues)
|
||
|
|
{
|
||
|
|
//--- There should be one rule as minimum
|
||
|
|
if(m_rules.Total()==0)
|
||
|
|
{
|
||
|
|
Print("There should be one rule as minimum.");
|
||
|
|
//--- return
|
||
|
|
return (NULL);
|
||
|
|
}
|
||
|
|
//--- Fuzzification step
|
||
|
|
CList *fuzzifiedInput=Fuzzify(inputValues);
|
||
|
|
//--- Evaluate the conditions
|
||
|
|
CList *evaluatedConditions=EvaluateConditions(fuzzifiedInput);
|
||
|
|
//--- Do implication for each rule
|
||
|
|
CList *implicatedConclusions=Implicate(evaluatedConditions);
|
||
|
|
//--- Aggrerate the results
|
||
|
|
CList *fuzzyResult=Aggregate(implicatedConclusions);
|
||
|
|
//--- Defuzzify the result
|
||
|
|
CList *result=Defuzzify(fuzzyResult);
|
||
|
|
//---
|
||
|
|
delete fuzzyResult;
|
||
|
|
for(int i=0; i<implicatedConclusions.Total(); i++)
|
||
|
|
{
|
||
|
|
CDictionary_Obj_Obj *pair=implicatedConclusions.GetNodeAtIndex(i);
|
||
|
|
CCompositeMembershipFunction *composite=pair.Value();
|
||
|
|
delete composite.MembershipFunctions().GetNodeAtIndex(0);
|
||
|
|
delete composite;
|
||
|
|
}
|
||
|
|
delete implicatedConclusions;
|
||
|
|
delete evaluatedConditions;
|
||
|
|
for(int i=0; i<fuzzifiedInput.Total(); i++)
|
||
|
|
{
|
||
|
|
CDictionary_Obj_Obj *pair=fuzzifiedInput.GetNodeAtIndex(i);
|
||
|
|
delete pair.Value();
|
||
|
|
}
|
||
|
|
delete fuzzifiedInput;
|
||
|
|
//--- return result
|
||
|
|
return (result);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Evaluate conditions |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CList *CMamdaniFuzzySystem::EvaluateConditions(CList *fuzzifiedInput)
|
||
|
|
{
|
||
|
|
CList *result=new CList;
|
||
|
|
for(int i=0; i<Rules().Total(); i++)
|
||
|
|
{
|
||
|
|
CDictionary_Obj_Double *p_rd=new CDictionary_Obj_Double;
|
||
|
|
CMamdaniFuzzyRule *rule=Rules().GetNodeAtIndex(i);
|
||
|
|
p_rd.SetAll(rule,EvaluateCondition(rule.Condition(),fuzzifiedInput));
|
||
|
|
result.Add(p_rd);
|
||
|
|
}
|
||
|
|
//--- return result
|
||
|
|
return (result);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Implicate rule results |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CList *CMamdaniFuzzySystem::Implicate(CList *conditions)
|
||
|
|
{
|
||
|
|
CList *conclusions=new CList;
|
||
|
|
for(int i=0; i<conditions.Total(); i++)
|
||
|
|
{
|
||
|
|
CDictionary_Obj_Double *p_rd=conditions.GetNodeAtIndex(i);
|
||
|
|
CMamdaniFuzzyRule *rule=p_rd.Key();
|
||
|
|
MfCompositionType compType;
|
||
|
|
switch(m_impl_method)
|
||
|
|
{
|
||
|
|
case MinIpm :
|
||
|
|
{
|
||
|
|
compType=MinMF;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case ProductionImp :
|
||
|
|
{
|
||
|
|
compType=ProdMF;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default :
|
||
|
|
{
|
||
|
|
Print("Internal error.");
|
||
|
|
//---
|
||
|
|
return (NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
CFuzzyTerm *val=rule.Conclusion().Term();
|
||
|
|
IMembershipFunction *first_fun=new CConstantMembershipFunction(p_rd.Value());
|
||
|
|
IMembershipFunction *second_fun=val.MembershipFunction();
|
||
|
|
CCompositeMembershipFunction *resultMF=new CCompositeMembershipFunction(compType,first_fun,second_fun);
|
||
|
|
CDictionary_Obj_Obj *p_rf=new CDictionary_Obj_Obj;
|
||
|
|
p_rf.SetAll(rule,resultMF);
|
||
|
|
conclusions.Add(p_rf);
|
||
|
|
}
|
||
|
|
//--- return conclusions
|
||
|
|
return (conclusions);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Aggregate results |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CList *CMamdaniFuzzySystem::Aggregate(CList *conclusions)
|
||
|
|
{
|
||
|
|
CList *fuzzyResult=new CList;
|
||
|
|
for(int i=0; i<Output().Total(); i++)
|
||
|
|
{
|
||
|
|
CFuzzyVariable *var=Output().GetNodeAtIndex(i);
|
||
|
|
CList *mfList=new CList;
|
||
|
|
for(int j=0; j<conclusions.Total(); j++)
|
||
|
|
{
|
||
|
|
CDictionary_Obj_Obj *p_rf=conclusions.GetNodeAtIndex(j);
|
||
|
|
CMamdaniFuzzyRule *rule=p_rf.Key();
|
||
|
|
if(rule.Conclusion().Var()==var)
|
||
|
|
{
|
||
|
|
mfList.Add(p_rf.Value());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
MfCompositionType composType;
|
||
|
|
switch(m_aggr_method)
|
||
|
|
{
|
||
|
|
case MaxAgg:
|
||
|
|
composType=MaxMF;
|
||
|
|
break;
|
||
|
|
case SumAgg:
|
||
|
|
composType=SumMF;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
{
|
||
|
|
Print("Internal exception.");
|
||
|
|
//--- return
|
||
|
|
return (NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
CDictionary_Obj_Obj *p_vf=new CDictionary_Obj_Obj;
|
||
|
|
CCompositeMembershipFunction *func=new CCompositeMembershipFunction(composType,mfList);
|
||
|
|
p_vf.SetAll(var,func);
|
||
|
|
fuzzyResult.Add(p_vf);
|
||
|
|
}
|
||
|
|
//--- return result
|
||
|
|
return (fuzzyResult);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate crisp result for each rule |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CList *CMamdaniFuzzySystem::Defuzzify(CList *fuzzyResult)
|
||
|
|
{
|
||
|
|
CList *crispResult=new CList;
|
||
|
|
for(int i=0; i<fuzzyResult.Total(); i++)
|
||
|
|
{
|
||
|
|
CDictionary_Obj_Double *p_vd=new CDictionary_Obj_Double;
|
||
|
|
CDictionary_Obj_Obj *p_vf=fuzzyResult.GetNodeAtIndex(i);
|
||
|
|
CFuzzyVariable *var=p_vf.Key();
|
||
|
|
p_vd.SetAll(var,Defuzzify(p_vf.Value(),var.Min(),var.Max()));
|
||
|
|
crispResult.Add(p_vd);
|
||
|
|
}
|
||
|
|
//--- return result
|
||
|
|
return (crispResult);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Helpers |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CMamdaniFuzzySystem::Defuzzify(IMembershipFunction *mf,const double min,const double max)
|
||
|
|
{
|
||
|
|
if(m_defuzz_method==CentroidDef)
|
||
|
|
{
|
||
|
|
int k=50; // The function is divided into "k" steps
|
||
|
|
double step=(max-min)/k; // Calculate the step function
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate a center of gravity as integral |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double ptLeft=0.0;
|
||
|
|
double ptCenter= 0.0;
|
||
|
|
double ptRight = 0.0;
|
||
|
|
double valLeft=0.0;
|
||
|
|
double valCenter= 0.0;
|
||
|
|
double valRight = 0.0;
|
||
|
|
double val2Left=0.0;
|
||
|
|
double val2Center= 0.0;
|
||
|
|
double val2Right = 0.0;
|
||
|
|
double numerator=0.0;
|
||
|
|
double denominator=0.0;
|
||
|
|
for(int i=0; i<k; i++)
|
||
|
|
{
|
||
|
|
if(i==0)
|
||
|
|
{
|
||
|
|
ptRight=min;
|
||
|
|
valRight=mf.GetValue(ptRight);
|
||
|
|
val2Right=ptRight*valRight;
|
||
|
|
}
|
||
|
|
ptLeft=ptRight;
|
||
|
|
ptCenter= min+step *((double)i+0.5);
|
||
|
|
ptRight = min+step *(i+1);
|
||
|
|
valLeft=valRight;
|
||
|
|
valCenter= mf.GetValue(ptCenter);
|
||
|
|
valRight = mf.GetValue(ptRight);
|
||
|
|
val2Left=val2Right;
|
||
|
|
val2Center= ptCenter * valCenter;
|
||
|
|
val2Right = ptRight * valRight;
|
||
|
|
numerator+=step *(val2Left+4*val2Center+val2Right)/3.0;
|
||
|
|
denominator+=step *(valLeft+4*valCenter+valRight)/3.0;
|
||
|
|
}
|
||
|
|
delete mf;
|
||
|
|
if(denominator!=0)
|
||
|
|
{
|
||
|
|
//--- return result
|
||
|
|
return (numerator / denominator);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//--- return NAN
|
||
|
|
return (MathLog(-1));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
if(m_defuzz_method==BisectorDef)
|
||
|
|
{
|
||
|
|
//+-------------------------------------------------------------------------------------+
|
||
|
|
//| The method Bisector consists in finding the point on the abscissa, |
|
||
|
|
//| which divides the area under the curve of the membership function in two equal parts|
|
||
|
|
//+-------------------------------------------------------------------------------------+
|
||
|
|
double Area=0.0; // The area under the function
|
||
|
|
int k=50; // The function is divided into "k" steps
|
||
|
|
double now=min; // The current position
|
||
|
|
for(int i=0; i<k; i++)
|
||
|
|
{
|
||
|
|
Area+=mf.GetValue(now);
|
||
|
|
now=now+(max-min)/k;
|
||
|
|
}
|
||
|
|
now=min;
|
||
|
|
double halfArea=fabs(Area/2-mf.GetValue(min));
|
||
|
|
Area=0.0;
|
||
|
|
while(true)
|
||
|
|
{
|
||
|
|
Area+=mf.GetValue(now);
|
||
|
|
if(Area>=halfArea)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
now=now+(max-min)/k;
|
||
|
|
}
|
||
|
|
delete mf;
|
||
|
|
//--- return result
|
||
|
|
return (now);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
if(m_defuzz_method==AverageMaximumDef)
|
||
|
|
{
|
||
|
|
//+------------------------------------------------------------------------------------------+
|
||
|
|
//| AverageMaximum method is the arithmetic mean of all the maxima of the membership function|
|
||
|
|
//+------------------------------------------------------------------------------------------+
|
||
|
|
double sum_max=0; // Sum of local maxima
|
||
|
|
double count_max=0; // Count of local maxima
|
||
|
|
int k=50; // The function is divided into "k" steps
|
||
|
|
double now=min; // The current position
|
||
|
|
double step=(max-min)/k; // Calculate the step function
|
||
|
|
for(int i=1; i<k; i++)
|
||
|
|
{
|
||
|
|
double point_1 = mf.GetValue(now);
|
||
|
|
double point_0 = mf.GetValue(now - step);
|
||
|
|
double point_2 = mf.GetValue(now + step);
|
||
|
|
//--- check the first element
|
||
|
|
if(i==1)
|
||
|
|
{
|
||
|
|
if(mf.GetValue(min)>mf.GetValue(min+step))
|
||
|
|
{
|
||
|
|
sum_max+=mf.GetValue(min);
|
||
|
|
count_max++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//--- check the second element
|
||
|
|
if(i==k-1)
|
||
|
|
{
|
||
|
|
if(mf.GetValue(max)>mf.GetValue(max-step))
|
||
|
|
{
|
||
|
|
sum_max+=mf.GetValue(max);
|
||
|
|
count_max++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//--- check all the other elements
|
||
|
|
if((point_1>point_0) && (point_1>point_2))
|
||
|
|
{
|
||
|
|
sum_max+=point_1;
|
||
|
|
count_max++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(count_max==0)
|
||
|
|
{
|
||
|
|
delete mf;
|
||
|
|
//--- return result
|
||
|
|
return (0);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
delete mf;
|
||
|
|
//--- return result
|
||
|
|
return (sum_max/count_max);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
if(m_defuzz_method==LargestMaximumDef)
|
||
|
|
{
|
||
|
|
CArrayDouble *local_max=new CArrayDouble; // Array of all local maximum
|
||
|
|
double result; // Result of defuzzification method
|
||
|
|
int k=50; // The function is divided into "k" steps
|
||
|
|
double now=min; // The current position
|
||
|
|
double step=(max-min)/k; // Calculate the step function
|
||
|
|
for(int i=1; i<k; i++)
|
||
|
|
{
|
||
|
|
double point_1 = mf.GetValue(now);
|
||
|
|
double point_0 = mf.GetValue(now - step);
|
||
|
|
double point_2 = mf.GetValue(now + step);
|
||
|
|
//--- check the first element
|
||
|
|
if(i==1)
|
||
|
|
{
|
||
|
|
if(mf.GetValue(min)>mf.GetValue(min+step))
|
||
|
|
{
|
||
|
|
local_max.Add(mf.GetValue(min));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//--- check the second element
|
||
|
|
if(i==k-1)
|
||
|
|
{
|
||
|
|
if(mf.GetValue(max)>mf.GetValue(max-step))
|
||
|
|
{
|
||
|
|
local_max.Add(mf.GetValue(max));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//--- check all the other elements
|
||
|
|
if((point_1>point_0) && (point_1>point_2))
|
||
|
|
{
|
||
|
|
local_max.Add(point_1);
|
||
|
|
}
|
||
|
|
now+=step;
|
||
|
|
}
|
||
|
|
result=local_max.At(0);
|
||
|
|
for(int i=0; i<local_max.Total(); i++)
|
||
|
|
{
|
||
|
|
if(result<=local_max.At(i))
|
||
|
|
{
|
||
|
|
result=local_max.At(i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
now=min;
|
||
|
|
while(true)
|
||
|
|
{
|
||
|
|
if(mf.GetValue(now)==result)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
now+=step;
|
||
|
|
}
|
||
|
|
delete local_max;
|
||
|
|
delete mf;
|
||
|
|
//--- return result
|
||
|
|
return (now);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
if(m_defuzz_method==SmallestMaximumDef)
|
||
|
|
{
|
||
|
|
CArrayDouble *local_max=new CArrayDouble; // Array of all local maximum
|
||
|
|
double result; // Result of defuzzification method
|
||
|
|
int k=50; // The function is divided into "k" steps
|
||
|
|
double now=min; // The current position
|
||
|
|
double step=(max-min)/k; // Calculate the step function
|
||
|
|
for(int i=1; i<k; i++)
|
||
|
|
{
|
||
|
|
double point_1 = mf.GetValue(now);
|
||
|
|
double point_0 = mf.GetValue(now - step);
|
||
|
|
double point_2 = mf.GetValue(now + step);
|
||
|
|
//--- check the first element
|
||
|
|
if(i==1)
|
||
|
|
{
|
||
|
|
if(mf.GetValue(min)>mf.GetValue(min+step))
|
||
|
|
{
|
||
|
|
local_max.Add(mf.GetValue(min));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//--- check the second element
|
||
|
|
if(i==k-1)
|
||
|
|
{
|
||
|
|
if(mf.GetValue(max)>mf.GetValue(max-step))
|
||
|
|
{
|
||
|
|
local_max.Add(mf.GetValue(max));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//--- check all the other elements
|
||
|
|
if((point_1>point_0) && (point_1>point_2))
|
||
|
|
{
|
||
|
|
local_max.Add(point_1);
|
||
|
|
}
|
||
|
|
now+=step;
|
||
|
|
}
|
||
|
|
result=local_max.At(0);
|
||
|
|
for(int i=0; i<local_max.Total(); i++)
|
||
|
|
{
|
||
|
|
if(result>=local_max.At(i))
|
||
|
|
{
|
||
|
|
result=local_max.At(i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
now=min;
|
||
|
|
while(true)
|
||
|
|
{
|
||
|
|
if(mf.GetValue(now)==result)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
now+=step;
|
||
|
|
}
|
||
|
|
delete local_max;
|
||
|
|
delete mf;
|
||
|
|
//--- return result
|
||
|
|
return (now);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Print("Internal exception.");
|
||
|
|
delete mf;
|
||
|
|
//--- return
|
||
|
|
return (0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|