254 lines
11 KiB
MQL5
254 lines
11 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| sugenovariable.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 "Dictionary.mqh"
|
|
//+------------------------------------------------------------------+
|
|
//| Purpose: creating Sugeno variable. |
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
//| The base class for Linear Sugeno Function |
|
|
//+------------------------------------------------------------------+
|
|
class ISugenoFunction : public CNamedValueImpl
|
|
{
|
|
public:
|
|
//--- method to check type
|
|
virtual bool IsTypeOf(EnType type) { return(type==TYPE_CLASS_ISugenoFunction); }
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Lenear function for Sugeno Fuzzy System |
|
|
//+------------------------------------------------------------------+
|
|
class CLinearSugenoFunction : public ISugenoFunction
|
|
{
|
|
private:
|
|
CList *m_input; // List of input variables
|
|
CList *m_coeffs; // The dictionary which stores variables and their coefficients
|
|
double m_const_value; // The constant term of the linear equation
|
|
|
|
public:
|
|
CLinearSugenoFunction(const string name,CList *in);
|
|
CLinearSugenoFunction(const string name,CList *in,CList *coeffs,const double constValue);
|
|
CLinearSugenoFunction(const string name,CList *in,const double &coeffs[]);
|
|
~CLinearSugenoFunction(void);
|
|
//--- method to check type
|
|
virtual bool IsTypeOf(EnType type) { return(type==TYPE_CLASS_LinearSugenoFunction); }
|
|
//--- methods gets or sets constant coefficient
|
|
double ConstValue() { return(m_const_value); }
|
|
void ConstValue(const double value) { m_const_value=value; }
|
|
//--- methods gets or sets coefficient by fuzzy variable
|
|
double GetCoefficient(CFuzzyVariable *var);
|
|
void SetCoefficient(CFuzzyVariable *var,const double coeff);
|
|
//--- calculate
|
|
double Evaluate(CList *inputValues);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| First constructor with parameters |
|
|
//+------------------------------------------------------------------+
|
|
CLinearSugenoFunction::CLinearSugenoFunction(const string name,CList *in)
|
|
{
|
|
m_coeffs=new CList;
|
|
CNamedValueImpl::Name(name);
|
|
m_input=in;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Second constructor with parameters |
|
|
//+------------------------------------------------------------------+
|
|
CLinearSugenoFunction::CLinearSugenoFunction(const string name,CList *in,CList *coeffs,const double constValue)
|
|
{
|
|
CNamedValueImpl::Name(name);
|
|
m_input=in;
|
|
//--- Check that all coeffecients are related to the variable from input
|
|
for(int i=0; i<coeffs.Total(); i++)
|
|
{
|
|
CDictionary_Obj_Double *p_vd=coeffs.GetNodeAtIndex(i);
|
|
if((m_input.IndexOf(p_vd.Key())==-1) && (in.Total()==coeffs.Total()))
|
|
{
|
|
Print("Input of the fuzzy system does not contain all variable.");
|
|
}
|
|
}
|
|
m_coeffs=coeffs;
|
|
m_const_value=constValue;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Third constructor with parameters |
|
|
//+------------------------------------------------------------------+
|
|
CLinearSugenoFunction::CLinearSugenoFunction(const string name,CList *in,const double &coeffs[])
|
|
{
|
|
m_coeffs=new CList;
|
|
m_input=in;
|
|
CNamedValueImpl::Name(name);
|
|
//--- Check input values
|
|
if(ArraySize(coeffs)!=in.Total() && ArraySize(coeffs)!=(in.Total()+1))
|
|
{
|
|
Print("Wrong lenght of coefficients array");
|
|
}
|
|
//--- Fill list of coefficients
|
|
for(int i=0; i<in.Total(); i++)
|
|
{
|
|
CDictionary_Obj_Double *p_vd=new CDictionary_Obj_Double;
|
|
CFuzzyVariable *var=in.GetNodeAtIndex(i);
|
|
p_vd.SetAll(var,coeffs[i]);
|
|
m_coeffs.Add(p_vd);
|
|
}
|
|
if(ArraySize(coeffs)==(in.Total()+1))
|
|
{
|
|
m_const_value=coeffs[ArraySize(coeffs)-1];
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CLinearSugenoFunction::~CLinearSugenoFunction(void)
|
|
{
|
|
if(CheckPointer(m_input)==POINTER_DYNAMIC)
|
|
delete m_input;
|
|
if(CheckPointer(m_coeffs)==POINTER_DYNAMIC)
|
|
delete m_coeffs;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get coefficient by fuzzy variable |
|
|
//+------------------------------------------------------------------+
|
|
double CLinearSugenoFunction::GetCoefficient(CFuzzyVariable *var)
|
|
{
|
|
if(var==NULL)
|
|
{
|
|
//--- return const coefficient
|
|
return (m_const_value);
|
|
}
|
|
else
|
|
{
|
|
for(int i=0; i<m_coeffs.Total(); i++)
|
|
{
|
|
CDictionary_Obj_Double *p_vd=m_coeffs.GetNodeAtIndex(i);
|
|
if(p_vd.Key()==var)
|
|
{
|
|
//--- return coefficient
|
|
return (p_vd.Value());
|
|
}
|
|
}
|
|
}
|
|
//--- return NULL
|
|
return (NULL);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Set coefficient by fuzzy variable |
|
|
//+------------------------------------------------------------------+
|
|
void CLinearSugenoFunction::SetCoefficient(CFuzzyVariable *var,const double coeff)
|
|
{
|
|
if(var==NULL)
|
|
{
|
|
m_const_value=coeff;
|
|
}
|
|
else
|
|
{
|
|
for(int i=0; i<m_coeffs.Total(); i++)
|
|
{
|
|
CDictionary_Obj_Double *p_vd=m_coeffs.GetNodeAtIndex(i);
|
|
if(p_vd.Key()==var)
|
|
{
|
|
p_vd.Value(coeff);
|
|
}
|
|
m_coeffs.Delete(i);
|
|
m_coeffs.Insert(p_vd,i);
|
|
}
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate result of linear function |
|
|
//+------------------------------------------------------------------+
|
|
double CLinearSugenoFunction::Evaluate(CList *inputValues)
|
|
{
|
|
double result=0.0;
|
|
for(int i=0; i<m_coeffs.Total(); i++)
|
|
{
|
|
CDictionary_Obj_Double *p_vd1=m_coeffs.GetNodeAtIndex(i);
|
|
CDictionary_Obj_Double *p_vd2=inputValues.GetNodeAtIndex(i);
|
|
result+=(p_vd1.Value())*(p_vd2.Value());
|
|
}
|
|
result+=m_const_value;
|
|
//--- return result
|
|
return (result);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Used as an output variable in Sugeno fuzzy inference system |
|
|
//+------------------------------------------------------------------+
|
|
class CSugenoVariable : public CNamedVariableImpl
|
|
{
|
|
private:
|
|
CList *m_functions; // List of Sugeno functions
|
|
|
|
public:
|
|
CSugenoVariable(const string name);
|
|
~CSugenoVariable(void);
|
|
//--- method to check type
|
|
virtual bool IsTypeOf(EnType type) { return(type==TYPE_CLASS_SugenoVariable); }
|
|
//--- method gets the list of functions that belongs to the variable
|
|
CList *Functions() { return(m_functions); }
|
|
//--- overload gets the list of functions that belongs to the variable
|
|
CList *Values() { return(m_functions); }
|
|
//--- find function by name
|
|
ISugenoFunction *GetFuncByName(const string name);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor with parameters |
|
|
//+------------------------------------------------------------------+
|
|
CSugenoVariable::CSugenoVariable(const string name)
|
|
{
|
|
m_functions=new CList;
|
|
CNamedVariableImpl::Name(name);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CSugenoVariable::~CSugenoVariable(void)
|
|
{
|
|
delete m_functions;
|
|
}
|
|
//+--------------------------------------------------------------------------------------+
|
|
//| Find function by its name |
|
|
//+--------------------------------------------------------------------------------------+
|
|
ISugenoFunction *CSugenoVariable::GetFuncByName(const string name)
|
|
{
|
|
CList *values=CSugenoVariable::Values();
|
|
values.Total();
|
|
for(int i=0; i<values.Total(); i++)
|
|
{
|
|
CNamedValueImpl *func=values.GetNodeAtIndex(i);
|
|
if(func.Name()==name)
|
|
{
|
|
ISugenoFunction *result=m_functions.GetNodeAtIndex(i);
|
|
//--- return result
|
|
return (result);
|
|
}
|
|
}
|
|
Print("The function of the same name is not found");
|
|
//--- return
|
|
return (NULL);
|
|
}
|
|
//+------------------------------------------------------------------+
|