//+------------------------------------------------------------------+
//|                                                    fuzzyrule.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 "FuzzyVariable.mqh"
#include "InferenceMethod.mqh"
//+------------------------------------------------------------------+
//| Purpose: Creating fuzzy rules                                    |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| And/Or operator type                                             |
//+------------------------------------------------------------------+ 
enum OperatorType
  {
   And,                               // And operator
   Or                                 // Or operator
  };
//+------------------------------------------------------------------+
//| Hedge modifiers                                                  |
//+------------------------------------------------------------------+ 
enum HedgeType
  {
   None,                              // None
   Slightly,                          // Cube root
   Somewhat,                          // Square root
   Very,                              // Square
   Extremely                          // Cube
  };
//+------------------------------------------------------------------+
//| Class of CConditions used in the 'if' expression                 |
//+------------------------------------------------------------------+
class ICondition : public CObject
  {
public:
   //--- method to check type 
   virtual bool      IsTypeOf(EnCondition type) { return(type==TYPE_CLASS_ICondition); }
  };
//+------------------------------------------------------------------+
//| Single condition                                                 |
//+------------------------------------------------------------------+
class CSingleCondition : public ICondition
  {
private:
   INamedVariable   *m_var;        // Type of variable
   INamedValue      *m_term;       // Type of value
   bool              m_not;        // Is MF inverted 

public:
                     CSingleCondition(void);
                     CSingleCondition(INamedVariable *var,INamedValue *term);
                     CSingleCondition(INamedVariable *var,INamedValue *term,bool not);
                    ~CSingleCondition(void);
   //--- methods gets or sets the varriable
   INamedVariable   *Var(void) { return(m_var); }
   void              Var(INamedVariable *value) { m_var=value;   }
   //--- methods gets or sets mark "Is MF inverted"
   bool              Not(void)      { return(m_not); }
   void              Not(bool not)  { m_not=not;     }
   //--- methods gets or sets term in expression
   INamedValue      *Term(void) { return(m_term); }
   void              Term(INamedValue *value) { m_term=value;   }
   //--- method to check type
   virtual bool      IsTypeOf(EnCondition type) { return(type==TYPE_CLASS_SingleCondition); }
  };
//+------------------------------------------------------------------+
//| Constructor without parameters                                   |
//+------------------------------------------------------------------+
CSingleCondition::CSingleCondition(void)
  {
   m_var = NULL;
   m_not = false;
   m_term=NULL;
  };
//+------------------------------------------------------------------+
//| First constructor with parameters                                |
//+------------------------------------------------------------------+
CSingleCondition::CSingleCondition(INamedVariable *var,INamedValue *term)
  {
   m_var=var;
   m_term=term;
  }
//+------------------------------------------------------------------+
//| Second constructor with parameters                               |
//+------------------------------------------------------------------+
CSingleCondition::CSingleCondition(INamedVariable *var,INamedValue *term,bool not)
  {
   m_var=var;
   m_term=term;
   m_not=not;
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+ 
CSingleCondition::~CSingleCondition(void)
  {
   if(CheckPointer(m_var)==POINTER_DYNAMIC)
      delete m_var;
   if(CheckPointer(m_term)==POINTER_DYNAMIC)
      delete m_term;
  }
//+------------------------------------------------------------------+
//| Condition of fuzzy rule for the both Mamdani and Sugeno systems  |
//+------------------------------------------------------------------+
class CFuzzyCondition : public CSingleCondition
  {
private:
   HedgeType         m_hedge;         // hedge type

public:
                     CFuzzyCondition(CFuzzyVariable *var,CFuzzyTerm *term,bool not);
                     CFuzzyCondition(CFuzzyVariable *var,CFuzzyTerm *term,bool not,HedgeType hedge);
                     CFuzzyCondition(CFuzzyVariable *var,CFuzzyTerm *term);
                    ~CFuzzyCondition(void);
   //--- methods gets or sets the hedge type
   HedgeType         Hedge(void)             { return (m_hedge); }
   void              Hedge(HedgeType value)  { m_hedge=value;    }
   //--- method to check type 
   virtual bool      IsTypeOf(EnCondition type) { return(type==TYPE_CLASS_FuzzyCondition); }
  };
//+------------------------------------------------------------------+
//| First constructor with parameters                                |
//+------------------------------------------------------------------+
CFuzzyCondition::CFuzzyCondition(CFuzzyVariable *var,CFuzzyTerm *term,bool not)
  {
   CSingleCondition::Var(var);
   CSingleCondition::Term(term);
   CSingleCondition::Not(not);
   m_hedge=None;
  }
//+------------------------------------------------------------------+
//| Second constructor with parameters                               |
//+------------------------------------------------------------------+     
CFuzzyCondition::CFuzzyCondition(CFuzzyVariable *var,CFuzzyTerm *term,bool not,HedgeType hedge)
  {
   CSingleCondition::Var(var);
   CSingleCondition::Term(term);
   CSingleCondition::Not(not);
   m_hedge=hedge;
  }
//+------------------------------------------------------------------+
//| Thrid constructor with parameters                                |
//+------------------------------------------------------------------+       
CFuzzyCondition::CFuzzyCondition(CFuzzyVariable *var,CFuzzyTerm *term)

  {
   CSingleCondition::Var(var);
   CSingleCondition::Term(term);
   CSingleCondition::Not(false);
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CFuzzyCondition::~CFuzzyCondition(void)
  {

  }
//+------------------------------------------------------------------+
//| Several CConditions linked by or/and operators                   |
//+------------------------------------------------------------------+
class CConditions : public ICondition
  {
private:
   bool              m_not;           // Default : false
   OperatorType      m_op;            // Type of operator. Default : And 
   CList            *m_conditions;    // List of CConditions

public:
                     CConditions(void);
                    ~CConditions(void);
   //--- methods gets or sets the mark "Is MF inverted"
   bool              Not(void)         { return(m_not); }
   void              Not(bool value)   { m_not=value;   }
   //--- methods gets or sets operator that links expressions (and/or)
   OperatorType      Op(void)                { return (m_op); }
   void              Op(OperatorType value)  { m_op=value;    }
   //--- method gets the list of CConditions (single or multiples)
   CList            *ConditionsList(void) { return(m_conditions); }
   //--- method to check type
   virtual bool      IsTypeOf(EnCondition type) { return(type==TYPE_CLASS_Conditions); }
  };
//+------------------------------------------------------------------+
//| Constructor without parameters                                   |
//+------------------------------------------------------------------+
CConditions::CConditions(void)
  {
   m_not=false;
   m_op = And;
   m_conditions=new CList;
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+ 
CConditions::~CConditions(void)
  {
   delete m_conditions;
  }
//+------------------------------------------------------------------+
//| Class used by rule parser                                        |
//+------------------------------------------------------------------+
class IParsableRule : public CObject
  {
public:
   //--- methods gets or sets the condition (IF) part of the rule
   virtual CConditions *Condition(void)                  { return(NULL); }
   virtual void      Condition(CConditions *value)       {  }
   //--- methods gets or sets the conclusion (THEN) part of the rule
   virtual  CSingleCondition *Conclusion(void)           { return(NULL); }
   virtual void      Conclusion(CSingleCondition *value) {  }
   //--- method to check type
   virtual bool      IsTypeOf(EnRule type) { return(type==TYPE_CLASS_IParsableRule); }
  };
//+------------------------------------------------------------------+
//| Implements common functionality of fuzzy rules                   |
//+------------------------------------------------------------------+
class CGenericFuzzyRule : public IParsableRule
  {
private:
   CConditions      *m_generic_condition; // Generic path of condition   

public:
                     CGenericFuzzyRule(void);
                    ~CGenericFuzzyRule(void);
   //--- methods gets or sets the condition (IF) part of the rule
   CConditions      *Condition(void)               { return(m_generic_condition); }
   void              Condition(CConditions *value) { m_generic_condition=value;   }
   //--- methods create a single condition
   CFuzzyCondition *CreateCondition(CFuzzyVariable *var,CFuzzyTerm *term);
   CFuzzyCondition *CreateCondition(CFuzzyVariable *var,CFuzzyTerm *term,bool not);
   CFuzzyCondition *CreateCondition(CFuzzyVariable *var,CFuzzyTerm *term,bool not,HedgeType hedge);
   //--- methods gets or sets the conclusion (THEN) part of the rule
   virtual CSingleCondition *Conclusion(void)            {  return(NULL);  }
   virtual void      Conclusion(CSingleCondition *value) {  }
   //--- method to check type
   virtual bool      IsTypeOf(EnRule type) { return(type==TYPE_CLASS_GenericFuzzyRule); }
  };
//+------------------------------------------------------------------+
//| Constructor without parameters                                   |
//+------------------------------------------------------------------+
CGenericFuzzyRule::CGenericFuzzyRule(void)
  {
   m_generic_condition=new CConditions();
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+ 
CGenericFuzzyRule::~CGenericFuzzyRule(void)
  {
   delete m_generic_condition;
  }
//+------------------------------------------------------------------+
//| Create a single condition(1)                                     |
//+------------------------------------------------------------------+ 
CFuzzyCondition *CGenericFuzzyRule::CreateCondition(CFuzzyVariable *var,CFuzzyTerm *term)
  {
//--- return fuzzy condition
   return new CFuzzyCondition(var, term);
  }
//+------------------------------------------------------------------+
//| Create a single condition(2)                                     |
//+------------------------------------------------------------------+ 
CFuzzyCondition *CGenericFuzzyRule::CreateCondition(CFuzzyVariable *var,CFuzzyTerm *term,bool not)
  {
//--- return fuzzy condition 
   return new CFuzzyCondition(var, term, not);
  }
//+------------------------------------------------------------------+
//| Create a single condition(3)                                     |
//+------------------------------------------------------------------+ 
CFuzzyCondition *CGenericFuzzyRule::CreateCondition(CFuzzyVariable *var,CFuzzyTerm *term,bool not,HedgeType hedge)
  {
//--- return fuzzy condition
   return new CFuzzyCondition(var, term, not, hedge);
  }
//+------------------------------------------------------------------+
//| Fuzzy rule for Mamdani fuzzy system.                             |
//| NOTE: a rule cannot be created directly, only via                |
//| MamdaniFuzzySystem::EmptyRule or MamdaniFuzzySystem::ParseRule   |
//+------------------------------------------------------------------+
class CMamdaniFuzzyRule : public CGenericFuzzyRule
  {
private:
   CSingleCondition *m_mamdani_conclusion;   // Mamdani conclusion
   double            m_weight;               // Weight of Mamdani rule

public:
                     CMamdaniFuzzyRule(void);
                    ~CMamdaniFuzzyRule(void);
   //--- methods gets or sets the conclusion (THEN) part of the rule
   CSingleCondition *Conclusion(void)                    { return(m_mamdani_conclusion); }
   void              Conclusion(CSingleCondition *value) { m_mamdani_conclusion=value;   }
   //--- methods gets or sets the rule weight 
   double            Weight(void)               { return(m_weight); }
   void              Weight(const double value) { m_weight=value;   }
   //--- method to check type
   virtual bool      IsTypeOf(EnRule type) { return(type==TYPE_CLASS_MamdaniFuzzyRule); }
  };
//+---------------------------------------------------------------+
//| Constructor without parameters                                |
//+---------------------------------------------------------------+
CMamdaniFuzzyRule::CMamdaniFuzzyRule(void)
  {
   m_weight=1.0;
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+ 
CMamdaniFuzzyRule::~CMamdaniFuzzyRule(void)
  {
   if(CheckPointer(m_mamdani_conclusion)==POINTER_DYNAMIC)
      delete m_mamdani_conclusion;
  }
//+------------------------------------------------------------------+
//| Fuzzy rule for Sugeno fuzzy system                               |
//| NOTE: a rule cannot be created directly, only via                |
//| SugenoFuzzySystem::EmptyRule or SugenoFuzzySystem::ParseRule     |
//+------------------------------------------------------------------+
class CSugenoFuzzyRule : public CGenericFuzzyRule
  {
private:
   CSingleCondition *m_sugeno_conclusion; // Sugeno conclusion

public:
                     CSugenoFuzzyRule(void);
                    ~CSugenoFuzzyRule(void);
   //--- methods gets or sets the conclusion (THEN) part of the rule
   CSingleCondition *Conclusion(void)                    { return(m_sugeno_conclusion); }
   void              Conclusion(CSingleCondition *value) { m_sugeno_conclusion=value;   }
   //--- method to check type
   virtual bool      IsTypeOf(EnRule type) { return(type==TYPE_CLASS_SugenoFuzzyRule); }
  };
//+------------------------------------------------------------------+
//| Constructor without parameters                                   |
//+-------------------------- ---------------------------------------+
CSugenoFuzzyRule::CSugenoFuzzyRule(void)
  {

  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+ 
CSugenoFuzzyRule::~CSugenoFuzzyRule(void)
  {
   if(CheckPointer(m_sugeno_conclusion)==POINTER_DYNAMIC)
      delete m_sugeno_conclusion;
  }
//+------------------------------------------------------------------+