371 lines
17 KiB
MQL5
371 lines
17 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| 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;
| |||
}
| |||
//+------------------------------------------------------------------+
|