//+------------------------------------------------------------------+
//|                                            sugenofuzzysystem.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 "GenericFuzzySystem.mqh"
#include "InferenceMethod.mqh"
#include "RuleParser.mqh"
#include "FuzzyRule.mqh"
#include "SugenoVariable.mqh"
//+------------------------------------------------------------------+
//| Purpose: Creating Sugeno fuzzy system                            |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Sugeno fuzzy inference system                                    |
//+------------------------------------------------------------------+
class CSugenoFuzzySystem : public CGenericFuzzySystem
  {
private:
   CList             *m_output;              // List of Sugeno variable
   CList             *m_rules;               // List of Sugeno fuzzy rule

public:
                     CSugenoFuzzySystem(void);
                    ~CSugenoFuzzySystem(void);
   //--- method gets the output linguistic variables
   CList*            Output(void) { return(m_output); }
   //--- method gets the fuzzy rule
   CList*            Rules(void)  { return(m_rules);  }
   //--- maethod gets the variable by name
   CSugenoVariable*  OutputByName(const string name);
   //--- method create new linear function
   CLinearSugenoFunction* CreateSugenoFunction(const string name,CList *coeffs,const double constValue);
   CLinearSugenoFunction* CreateSugenoFunction(const string name,const double &coeffs[]);
   //--- method create a new rule
   CSugenoFuzzyRule* EmptyRule(void);
   //--- method for calculate result
   CSugenoFuzzyRule* ParseRule(const string rule);
   CList*            EvaluateConditions(CList *fuzzifiedInput);
   CList*            EvaluateFunctions(CList *inputValues);
   CList*            CombineResult(CList *ruleWeights,CList *functionResults);
   CList*            Calculate(CList *inputValues);
  };
//+------------------------------------------------------------------+
//| Constructor without parameters                                   |
//+------------------------------------------------------------------+
CSugenoFuzzySystem::CSugenoFuzzySystem(void)
  {
   m_output=new CList;
   m_rules=new CList;
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CSugenoFuzzySystem::~CSugenoFuzzySystem(void)
  {
   delete m_output;
   delete m_rules;
  }
//+------------------------------------------------------------------+
//| Get the output variable of the system by name                    |
//+------------------------------------------------------------------+
CSugenoVariable *CSugenoFuzzySystem::OutputByName(const string name)
  {
   for(int i=0; i<m_output.Total(); i++)
     {
      CSugenoVariable *var=m_output.GetNodeAtIndex(i);
      if(var.Name()==name)
        {
         //--- return Sugeno variable
         return (var);
        }
     }
   Print("Variable with that name is not found");
//--- return
   return (NULL);
  }
//+------------------------------------------------------------------------+
//| Use this method to create a linear function for the Sugeno fuzzy system|
//+------------------------------------------------------------------------+
CLinearSugenoFunction *CSugenoFuzzySystem::CreateSugenoFunction(const string name,CList *coeffs,const double constValue)
  {
//--- return linear Sugeno function
   return new CLinearSugenoFunction(name, CGenericFuzzySystem::Input(), coeffs, constValue);
  }
//+------------------------------------------------------------------------+
//| Use this method to create a linear function for the Sugeno fuzzy system|
//+------------------------------------------------------------------------+
CLinearSugenoFunction *CSugenoFuzzySystem::CreateSugenoFunction(const string name,const double &coeffs[])
  {
//--- return linear Sugeno function
   return new CLinearSugenoFunction(name, Input(), coeffs);
  }
//+------------------------------------------------------------------+
//| Use this method to create an empty rule for the system           |
//+------------------------------------------------------------------+
CSugenoFuzzyRule *CSugenoFuzzySystem::EmptyRule()
  {
//--- return Sugeno fuzzy rule
   return new CSugenoFuzzyRule();
  }
//+------------------------------------------------------------------+
//| Use this method to create rule by its textual representation     |
//+------------------------------------------------------------------+
CSugenoFuzzyRule *CSugenoFuzzySystem::ParseRule(const string rule)
  {
//--- return Sugeno fuzzy rule
   return CRuleParser::Parse(rule, EmptyRule(), Input(), Output());
  }
//+------------------------------------------------------------------+
//| Evaluate conditions                                              |
//+------------------------------------------------------------------+
CList *CSugenoFuzzySystem::EvaluateConditions(CList *fuzzifiedInput)
  {
   CList *result=new CList;
   for(int i=0; i<Rules().Total(); i++)
     {
      CDictionary_Obj_Double *p_rd=new CDictionary_Obj_Double;
      CSugenoFuzzyRule *rule=Rules().GetNodeAtIndex(i);
      p_rd.SetAll(rule,EvaluateCondition(rule.Condition(),fuzzifiedInput));
      result.Add(p_rd);
     }
//--- return result
   return (result);
  }
//+------------------------------------------------------------------+
//| Calculate functions results                                      |
//+------------------------------------------------------------------+
CList *CSugenoFuzzySystem::EvaluateFunctions(CList *inputValues)
  {
   CList *result=new CList;
   for(int i=0; i<Output().Total(); i++)
     {
      CSugenoVariable *var=Output().GetNodeAtIndex(i);
      CList *varResult=new CList;
      for(int j=0; j<var.Functions().Total(); j++)
        {
         CDictionary_Obj_Double *p_fd=new CDictionary_Obj_Double;
         CLinearSugenoFunction *func=var.Functions().GetNodeAtIndex(j);
         p_fd.SetAll(func,func.Evaluate(inputValues));
         varResult.Add(p_fd);
        }
      CDictionary_Obj_Obj *p_vl=new CDictionary_Obj_Obj;
      p_vl.SetAll(var,varResult);
      result.Add(p_vl);
     }
//--- return result
   return (result);
  }
//+------------------------------------------------------------------+
//| Combine results of functions and rule evaluation                 |
//+------------------------------------------------------------------+
CList *CSugenoFuzzySystem::CombineResult(CList *ruleWeights,CList *functionResults)
  {
   CList *results=new CList;
   CList *numerators=new CList;
   CDictionary_Obj_Double *p_vd1;
   CList *denominators=new CList;
   CDictionary_Obj_Double *p_vd2;
//--- Calculate numerator and denominator separately for each output
   for(int i=0; i<Output().Total(); i++)
     {
      p_vd1=new CDictionary_Obj_Double;
      p_vd1.SetAll(Output().GetNodeAtIndex(i),0.0);
      numerators.Add(p_vd1);
      p_vd2=new CDictionary_Obj_Double;
      p_vd2.SetAll(Output().GetNodeAtIndex(i),0.0);
      denominators.Add(p_vd2);
     }
   for(int i=0; i<ruleWeights.Total(); i++)
     {
      double z=NULL;
      double w=NULL;
      CDictionary_Obj_Double *p_rd=ruleWeights.GetNodeAtIndex(i);
      CSugenoFuzzyRule *rule=p_rd.Key();
      CSugenoVariable *var=rule.Conclusion().Var();
      for(int j=0; j<functionResults.Total(); j++)
        {
         CDictionary_Obj_Obj *p_vl=functionResults.GetNodeAtIndex(j);
         if(p_vl.Key()==var)
           {
            CList *list=p_vl.Value();
            for(int k=0; k<list.Total(); k++)
              {
               CDictionary_Obj_Double *p_fd=list.GetNodeAtIndex(k);
               if(p_fd.Key()==rule.Conclusion().Term())
                 {
                  z=p_fd.Value();
                  break;
                 }
              }
            break;
           }
        }
      for(int j=0; j<ruleWeights.Total(); j++)
        {
         p_rd=ruleWeights.GetNodeAtIndex(j);
         if(p_rd.Key()==rule)
           {
            w=p_rd.Value();
            break;
           }
        }
      for(int j=0; j<numerators.Total(); j++)
        {
         p_vd1=numerators.GetNodeAtIndex(j);
         double num=p_vd1.Value();
         if(p_vd1.Key()==rule.Conclusion().Var())
           {
            num=num+(z*w);
            p_vd1.Value(num);
            break;
           }
        }
      for(int j=0; j<denominators.Total(); j++)
        {
         p_vd2=denominators.GetNodeAtIndex(j);
         double den=p_vd2.Value();
         if(p_vd2.Key()==rule.Conclusion().Var())
           {
            den=den+w;
            p_vd2.Value(den);
            break;
           }
        }
     }
//--- Calculate the fractions
   for(int i=0; i<Output().Total(); i++)
     {
      CSugenoVariable *var=Output().GetNodeAtIndex(i);
      CDictionary_Obj_Double *p_vd_res=new CDictionary_Obj_Double;
      CDictionary_Obj_Double *p_vd_num;
      CDictionary_Obj_Double *p_vd_den;
      for(int j=0; j<numerators.Total(); j++)
        {
         p_vd_num=numerators.GetNodeAtIndex(j);
         if(p_vd_num.Key()==var)
           {
            break;
           }
        }
      for(int j=0; j<denominators.Total(); j++)
        {
         p_vd_den=denominators.GetNodeAtIndex(j);
         if(p_vd_den.Key()==var)
           {
            break;
           }
        }
      if(p_vd_den.Value()==0.0)
        {
         p_vd_res.Value(0.0);
         results.Add(p_vd_res);
        }
      else
        {
         p_vd_res.Value(p_vd_num.Value()/p_vd_den.Value());
         results.Add(p_vd_res);
        }
     }
//--- return result
   delete numerators;
   delete denominators;
   return (results);
  }
//+------------------------------------------------------------------+
//| Calculate output of fuzzy system                                 |
//+------------------------------------------------------------------+
CList *CSugenoFuzzySystem::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 *ruleWeights=EvaluateConditions(fuzzifiedInput);
//--- Functions evaluation
   CList *functionsResult=EvaluateFunctions(inputValues);
//--- Combine output
   CList *result=CombineResult(ruleWeights,functionsResult);
//---
   for(int i=0; i<functionsResult.Total(); i++)
     {
      CDictionary_Obj_Obj *pair=functionsResult.GetNodeAtIndex(i);
      delete pair.Value();
     }
   delete functionsResult;
   delete ruleWeights;
   for(int i=0; i<fuzzifiedInput.Total(); i++)
     {
      CDictionary_Obj_Obj *pair=fuzzifiedInput.GetNodeAtIndex(i);
      delete pair.Value();
     }
   delete fuzzifiedInput;
//--- return result
   return (result);
  }
//+------------------------------------------------------------------+