| //+------------------------------------------------------------------+
|
| //| 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);
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
