//+------------------------------------------------------------------+
//|                                                    TestFuzzy.mq5 |
//|                             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 <Math\Fuzzy\MamdaniFuzzySystem.mqh>
#include <Math\Fuzzy\SugenoFuzzySystem.mqh>
//+------------------------------------------------------------------+
//| Test_NormalCombinationMembershipFunction()                       |
//+------------------------------------------------------------------+
bool Test_NormalCombinationMembershipFunction()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4.0,5.1,0.1};
   double b1=1.2;
   double sigma1=0.45;
   double b2=3.1;
   double sigma2=0.9;
   CNormalCombinationMembershipFunction function(b1,sigma1,b2,sigma2);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=function.GetValue(x[i]);
      double expected=0.0;
      if(x[i]<1.2)
        {
         expected=MathExp(MathPow(x[i]-b1,2)/(-2.0*MathPow(0.45,2)));
        }
      else if(x[i]>3.1)
        {
         expected=MathExp(MathPow(x[i]-b2,2)/(-2.0*MathPow(0.9,2)));
        }
      if(MathAbs(actual-expected)>1e-20)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_GeneralizedBellShapedMembershipFunction()                   |
//+------------------------------------------------------------------+
bool Test_GeneralizedBellShapedMembershipFunction()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4,5.1,0.1};
   double a = 2.4;
   double b = 0.9;
   double c = 1.33;
   CGeneralizedBellShapedMembershipFunction function(a,b,c);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=function.GetValue(x[i]);
      double expected=1/(1+MathPow(MathAbs((x[i]-a)/c),2*b));
      if(actual!=expected)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_SigmoidalMembershipFunction()                               |
//+------------------------------------------------------------------+
bool Test_SigmoidalMembershipFunction()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4,4.1,0.1};
   double a = 1.75;
   double c = -M_PI/2;
   CSigmoidalMembershipFunction function(a,c);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=function.GetValue(x[i]);
      double expected=1/(1.0+MathExp(-a *(x[i]-c)));
      if(actual!=expected)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_ProductTwoSigmoidalMembershipFunctions()                    |
//+------------------------------------------------------------------+
bool Test_ProductTwoSigmoidalMembershipFunctions()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4.0,4.1,0.1};
   double a1 = -1.75;
   double c1 = -M_PI/2.0;
   double a2 = 0.972;
   double c2 = 0.43;
   CProductTwoSigmoidalMembershipFunctions function(a1,c1,a2,c2);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=function.GetValue(x[i]);
      double expected=((1.0/(1.0+MathExp(-a1 *(x[i]-c1)))) *
                       (1.0/(1.0+MathExp(-a2 *(x[i]-c2)))));
      if(actual!=expected)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_TrapezoidMembershipFunction()                               |
//+------------------------------------------------------------------+
bool Test_TrapezoidMembershipFunction()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4,3.1,0.1};
   double x1 = -4;
   double x2 = -4;
   double x3 = 2;
   double x4 = M_PI;
   CTrapezoidMembershipFunction function(x1,x2,x3,x4);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=function.GetValue(x[i]);
      double expected=1.0;
      if(x[i]>2 && x[i]<M_PI)
        {
         expected=(-x[i]/(x4-x3))+(x4/(x4-x3));
        }
      else if(x[i]>M_PI)
        {
         expected=0;
        }
      if(actual!=expected)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_NormalMembershipFunction()                                  |
//+------------------------------------------------------------------+
bool Test_NormalMembershipFunction()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4,5.1,0.1};
   double b=1.33;
   double sigma=0.45;
   CNormalMembershipFunction function(b,sigma);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=function.GetValue(x[i]);
      double expected=MathExp(MathPow(x[i]-1.33,2.0)/(-2.0*MathPow(0.45,2.0)));
      if(actual!=expected)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_TriangularMembershipFunction()                              |
//+------------------------------------------------------------------+
bool Test_TriangularMembershipFunction()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4,4.1,0.1};
   double x1 = -M_PI;
   double x2 = -M_E/2.0;
   double x3 = M_PI/5.0;
   CTriangularMembershipFunction function(x1,x2,x3);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=function.GetValue(x[i]);
      double expected=0;
      if(x[i]==x2)
        {
         expected=1;
        }
      else if(x[i]>x1 && x[i]<x2)
        {
         expected=(x[i]/(x2-x1)) -(x1/(x2-x1));
        }
      else if(x[i]>x2 && x[i]<x3)
        {
         expected=(-x[i]/(x3-x2))+(x3/(x3-x2));
        }
      if(actual!=expected)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_ConstantMembershipFunction()                                |
//+------------------------------------------------------------------+
bool Test_ConstantMembershipFunction()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4,4.1,0.1};
   double value=1.0;
   CConstantMembershipFunction function(1.0);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=function.GetValue(x[i]);
      double expected=value;
      if(actual!=expected)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_P_S_Z_ShapedMembershipFunction()                            |
//+------------------------------------------------------------------+
bool Test_P_S_Z_ShapedMembershipFunction()
  {
   bool result=true;
   double delta=1e-20;
   double x[]={-4.0,4.1,0.1};
   CS_ShapedMembershipFunction sfunction(-1.0/137.0,M_PI/2.0);
   CZ_ShapedMembershipFunction zfunction(MathExp(1.0),M_PI);
   CP_ShapedMembershipFunction pfunction(-1.0/137.0,M_PI/2.0,MathExp(1.0),M_PI);
   for(int i=0; i<ArraySize(x); i++)
     {
      double actual=pfunction.GetValue(x[i]);
      double expected=sfunction.GetValue(x[i])*zfunction.GetValue(x[i]);
      if(actual!=expected)
        {
         Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
         result=false;
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_Bisector()                                                  |
//+------------------------------------------------------------------+
bool Test_Bisector()
  {
   double delta=1e-10;
   CMamdaniFuzzySystem system();
   system.SetDefuzzificationMethod(BisectorDef);
   CTriangularMembershipFunction *function=new CTriangularMembershipFunction(0,5,5);
   double actual=system.Defuzzify(function,0,5);
   double expected=3.5;
   if(MathAbs(actual-expected)>=delta)
     {
      Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
      return (false);
     }
   return (true);
  }
//+------------------------------------------------------------------+
//| Test_Centroid()                                                  |
//+------------------------------------------------------------------+
bool Test_Centroid()
  {
   bool result=true;
   double delta=1e-1;
   CMamdaniFuzzySystem system();
   system.SetDefuzzificationMethod(CentroidDef);
   double mean[]={-5,-3,-1,1,3,5};
   double sigma[]={1,2};
   for(int i=0; i<ArraySize(mean); i++)
     {
      for(int j=0; j<ArraySize(sigma); j++)
        {
         CNormalMembershipFunction *function=new CNormalMembershipFunction(mean[i],sigma[j]);
         double actual=system.Defuzzify(function,-10,10);
         double expected=mean[i];
         if(MathAbs(actual-expected)>=delta)
           {
            Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
            result=false;
           }
        }
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_Defuzzification()                                           |
//+------------------------------------------------------------------+
bool Test_Defuzzification()
  {
   bool result=true;
   double delta=1e-12;
   CMamdaniFuzzySystem system();
   double actual=0.0;
   double expected=0.0;
//---  
   system.SetDefuzzificationMethod(CentroidDef);
   actual=system.Defuzzify(new CNormalMembershipFunction(0,2),-10,10);
   if(MathAbs(actual-expected)>=delta)
     {
      Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
      result=false;
     }
//---
   system.SetDefuzzificationMethod(BisectorDef);
   actual=system.Defuzzify(new CNormalMembershipFunction(0,2),-10,10);
   if(MathAbs(actual-expected)>=delta)
     {
      Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
      result=false;
     }
//---
   system.SetDefuzzificationMethod(AverageMaximumDef);
   actual=system.Defuzzify(new CNormalMembershipFunction(0,2),-10,10);
   if(MathAbs(actual-expected)>=delta)
     {
      Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
      result=false;
     }
//---
   system.SetDefuzzificationMethod(SmallestMaximumDef);
   actual=system.Defuzzify(new CNormalMembershipFunction(0,2),-10,10);
   if(MathAbs(actual-expected)>=delta)
     {
      Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
      result=false;
     }
//---
   system.SetDefuzzificationMethod(LargestMaximumDef);
   actual=system.Defuzzify(new CNormalMembershipFunction(0,2),-10,10);
   if(MathAbs(actual-expected)>=delta)
     {
      Print("Expected: ",expected," +/- ",delta," ; But was: ",actual);
      result=false;
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| Test_TipingProblem()                                             |
//+------------------------------------------------------------------+
bool Test_TipingProblem()
  {
//--- Mamdani Fuzzy System  
   CMamdaniFuzzySystem *fsTips=new CMamdaniFuzzySystem();
//--- Create first input variables for the system
   CFuzzyVariable *fvService=new CFuzzyVariable("service",0.0,10.0);
   fvService.Terms().Add(new CFuzzyTerm("poor", new CTriangularMembershipFunction(-5.0, 0.0, 5.0)));
   fvService.Terms().Add(new CFuzzyTerm("good", new CTriangularMembershipFunction(0.0, 5.0, 10.0)));
   fvService.Terms().Add(new CFuzzyTerm("excellent", new CTriangularMembershipFunction(5.0, 10.0, 15.0)));
   fsTips.Input().Add(fvService);
//--- Create second input variables for the system
   CFuzzyVariable *fvFood=new CFuzzyVariable("food",0.0,10.0);
   fvFood.Terms().Add(new CFuzzyTerm("rancid", new CTrapezoidMembershipFunction(0.0, 0.0, 1.0, 3.0)));
   fvFood.Terms().Add(new CFuzzyTerm("delicious", new CTrapezoidMembershipFunction(7.0, 9.0, 10.0, 10.0)));
   fsTips.Input().Add(fvFood);
//--- Create Output
   CFuzzyVariable *fvTips=new CFuzzyVariable("tips",0.0,30.0);
   fvTips.Terms().Add(new CFuzzyTerm("cheap", new CTriangularMembershipFunction(0.0, 5.0, 10.0)));
   fvTips.Terms().Add(new CFuzzyTerm("average", new CTriangularMembershipFunction(10.0, 15.0, 20.0)));
   fvTips.Terms().Add(new CFuzzyTerm("generous", new CTriangularMembershipFunction(20.0, 25.0, 30.0)));
   fsTips.Output().Add(fvTips);
//--- Create three Mamdani fuzzy rule
   CMamdaniFuzzyRule *rule1 = fsTips.ParseRule("if (service is poor )  or (food is rancid) then tips is cheap");
   CMamdaniFuzzyRule *rule2 = fsTips.ParseRule("if ((service is good)) then tips is average");
   CMamdaniFuzzyRule *rule3 = fsTips.ParseRule("if (service is excellent) or (food is delicious) then (tips is generous)");
//--- Add three Mamdani fuzzy rule in system
   fsTips.Rules().Add(rule1);
   fsTips.Rules().Add(rule2);
   fsTips.Rules().Add(rule3);
//--- Set input value
   CList *in=new CList;
   CDictionary_Obj_Double *p_od_Service=new CDictionary_Obj_Double;
   CDictionary_Obj_Double *p_od_Food=new CDictionary_Obj_Double;
//--- Testing values
   double Food=6.5;
   double Service=9.8;
   double expected=24.3;
   p_od_Service.SetAll(fvService,Service);
   p_od_Food.SetAll(fvFood,Food);
   in.Add(p_od_Service);
   in.Add(p_od_Food);
//--- Get result
   CList *result;
   CDictionary_Obj_Double *p_od_Tips;
   result=fsTips.Calculate(in);
   p_od_Tips=result.GetNodeAtIndex(0);
   double actual=NormalizeDouble(p_od_Tips.Value(),1);
   delete in;
   delete result;
   delete fsTips;
   if(expected!=actual)
     {
      Print("Expected: ",expected," ; But was: ",actual);
      //--- failed
      return (false);
     }
   else
     {
      //--- success
      return (true);
     }
  }
//+------------------------------------------------------------------+
//| Test_TypicalFuzzyControlSystem()                                 |
//+------------------------------------------------------------------+
bool Test_TypicalFuzzyControlSystem()
  {
//--- Sugeno Fuzzy System  
   CSugenoFuzzySystem *fsCruiseControl=new CSugenoFuzzySystem();
//--- Create first input variables for the system
   CFuzzyVariable *fvSpeedError=new CFuzzyVariable("SpeedError",-20.0,20.0);
   fvSpeedError.Terms().Add(new CFuzzyTerm("slower",new CTriangularMembershipFunction(-35.0,-20.0,-5.0)));
   fvSpeedError.Terms().Add(new CFuzzyTerm("zero", new CTriangularMembershipFunction(-15.0, -0.0, 15.0)));
   fvSpeedError.Terms().Add(new CFuzzyTerm("faster", new CTriangularMembershipFunction(5.0, 20.0, 35.0)));
   fsCruiseControl.Input().Add(fvSpeedError);
//--- Create second input variables for the system
   CFuzzyVariable *fvSpeedErrorDot=new CFuzzyVariable("SpeedErrorDot",-5.0,5.0);
   fvSpeedErrorDot.Terms().Add(new CFuzzyTerm("slower", new CTriangularMembershipFunction(-9.0, -5.0, -1.0)));
   fvSpeedErrorDot.Terms().Add(new CFuzzyTerm("zero", new CTriangularMembershipFunction(-4.0, -0.0, 4.0)));
   fvSpeedErrorDot.Terms().Add(new CFuzzyTerm("faster", new CTriangularMembershipFunction(1.0, 5.0, 9.0)));
   fsCruiseControl.Input().Add(fvSpeedErrorDot);
//--- Create Output
   CSugenoVariable *svAccelerate=new CSugenoVariable("Accelerate");
   double coeff1[3]={0.0,0.0,0.0};
   svAccelerate.Functions().Add(fsCruiseControl.CreateSugenoFunction("zero",coeff1));
   double coeff2[3]={0.0,0.0,1.0};
   svAccelerate.Functions().Add(fsCruiseControl.CreateSugenoFunction("faster",coeff2));
   double coeff3[3]={0.0,0.0,-1.0};
   svAccelerate.Functions().Add(fsCruiseControl.CreateSugenoFunction("slower",coeff3));
   double coeff4[3]={-0.04,-0.1,0.0};
   svAccelerate.Functions().Add(fsCruiseControl.CreateSugenoFunction("func",coeff4));
   fsCruiseControl.Output().Add(svAccelerate);
//--- Craete Sugeno fuzzy rules
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"slower","slower","faster");
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"slower","zero","faster");
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"slower","faster","zero");
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"zero","slower","faster");
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"zero","zero","func");
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"zero","faster","slower");
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"faster","slower","zero");
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"faster","zero","slower");
   AddSugenoFuzzyRule(fsCruiseControl,fvSpeedError,fvSpeedErrorDot,svAccelerate,"faster","faster","slower");
//--- Set input value and get result
   CList *in=new CList;
   CDictionary_Obj_Double *p_od_Error=new CDictionary_Obj_Double;
   CDictionary_Obj_Double *p_od_ErrorDot=new CDictionary_Obj_Double;
   double Speed_Error=18.3;
   double Speed_ErrorDot=-3.5;
   double expected=-16.7;
   p_od_Error.SetAll(fvSpeedError,Speed_Error);
   p_od_ErrorDot.SetAll(fvSpeedErrorDot,Speed_ErrorDot);
   in.Add(p_od_Error);
   in.Add(p_od_ErrorDot);
//--- Get result
   CList *result;
   CDictionary_Obj_Double *p_od_Accelerate;
   result=fsCruiseControl.Calculate(in);
   p_od_Accelerate=result.GetNodeAtIndex(0);
   double actual=NormalizeDouble(p_od_Accelerate.Value()*100,1);
   delete in;
   delete result;
   delete fsCruiseControl;
   if(expected!=actual)
     {
      Print("Expected: ",expected," ; But was: ",actual);
      //--- failed
      return (false);
     }
   else
     {
      //--- success
      return (true);
     }
  }
//+------------------------------------------------------------------+
//| AddSugenoFuzzyRule()                                             |
//+------------------------------------------------------------------+
void AddSugenoFuzzyRule(CSugenoFuzzySystem *fs,CFuzzyVariable *fv1,CFuzzyVariable *fv2,CSugenoVariable *sv,
                        const string value1,const string value2,const string result)
  {
   CSugenoFuzzyRule *rule=fs.EmptyRule();
   rule.Conclusion(new CSingleCondition());
   rule.Condition().Op(OperatorType::And);
   rule.Condition().ConditionsList().Add(rule.CreateCondition(fv1, fv1.GetTermByName(value1)));
   rule.Condition().ConditionsList().Add(rule.CreateCondition(fv2, fv2.GetTermByName(value2)));
   rule.Conclusion().Var(sv);
   INamedValue *sf=sv.GetFuncByName(result);
   rule.Conclusion().Term(sf);
   fs.Rules().Add(rule);
  }
//+------------------------------------------------------------------+
//| TestMembersipFunctions                                           |
//+------------------------------------------------------------------+
bool TestMembersipFunctions(const string test_name)
  {
   PrintFormat("%s started",test_name);
//--- test 1
   PrintFormat("%s: Test 1: calculation of the values for combination two normal membership function",test_name);
   if(!Test_NormalCombinationMembershipFunction())
      return (false);
//--- test 2
   PrintFormat("%s: Test 2: calculation of the values for generalized bell-shaped membership function",test_name);
   if(!Test_GeneralizedBellShapedMembershipFunction())
      return (false);
//--- test 3
   PrintFormat("%s: Test 3: calculation of the values for sigmoidal membership function",test_name);
   if(!Test_SigmoidalMembershipFunction())
      return (false);
//--- test 4
   PrintFormat("%s: Test 4: calculation of the values for product two sigmoidal membership function",test_name);
   if(!Test_ProductTwoSigmoidalMembershipFunctions())
      return (false);
//--- test 5
   PrintFormat("%s: Test 5: calculation of the values for trapezoid membership function",test_name);
   if(!Test_TrapezoidMembershipFunction())
      return (false);
//--- test 6
   PrintFormat("%s: Test 6: calculation of the values for normal membership function",test_name);
   if(!Test_NormalMembershipFunction())
      return (false);
//--- test 7
   PrintFormat("%s: Test 7: calculation of the values for triangular membership function",test_name);
   if(!Test_TriangularMembershipFunction())
      return (false);
//--- test 8
   PrintFormat("%s: Test 8: calculation of the values for constant membership function",test_name);
   if(!Test_ConstantMembershipFunction())
      return (false);
//--- test 9
   PrintFormat("%s: Test 9: comparing the results of calculations 'P' shaped function and product 'S' and 'Z' shaped function",test_name);
   if(!Test_P_S_Z_ShapedMembershipFunction())
      return (false);
//--- successful
   PrintFormat("%s passed",test_name);
   return (true);
  }
//+------------------------------------------------------------------+
//| TestDefuzzificationMethods                                       |
//+------------------------------------------------------------------+
bool TestDefuzzificationMethods(const string test_name)
  {
   PrintFormat("%s started",test_name);
//--- test 1
   PrintFormat("%s: Test 1: application of the Bisector defuzzification for a triangular membership function",test_name);
   if(!Test_Bisector())
      return (false);
//--- test 2
   PrintFormat("%s: Test 2: application of the Centroid defuzzification for a normal membership function",test_name);
   if(!Test_Centroid())
      return (false);
//--- test 3
   PrintFormat("%s: Test 3: application of the Bisector, Centroid, Middle, Smallest, and Largest of Maximum  defuzzification for a normal membership function",test_name);
   if(!Test_Defuzzification())
      return (false);
//--- successful
   PrintFormat("%s passed",test_name);
   return (true);
  }
//+------------------------------------------------------------------+
//| TestFuzzySystems                                                 |
//+------------------------------------------------------------------+
bool TestFuzzySystems(const string test_name)
  {
   PrintFormat("%s started",test_name);
//--- test 1
   PrintFormat("%s: Test 1: calculate result for Mamdani fuzzy system",test_name);
   if(!Test_TipingProblem())
      return (false);
//--- test 2
   PrintFormat("%s: Test 2: calculate result for Sugeno fuzzy system",test_name);
   if(!Test_TypicalFuzzyControlSystem())
      return (false);
//--- successful
   PrintFormat("%s passed",test_name);
   return (true);
  }
//+------------------------------------------------------------------+
//| TestFuzzy                                                        |
//+------------------------------------------------------------------+
void TestFuzzy(int &tests_performed,int &tests_passed)
  {
//--- Membersip functions
   tests_performed++;
   string test_name="Membersip functions test";
   if(TestMembersipFunctions(test_name))
      tests_passed++;
   else
      PrintFormat("%s failed",test_name);

//--- Defuzzification methods
   tests_performed++;
   test_name="Defuzzification methods test";
   if(TestDefuzzificationMethods(test_name))
      tests_passed++;
   else
      PrintFormat("%s failed",test_name);

//--- Fuzzy systems
   tests_performed++;
   test_name="Fuzzy systems test";
   if(TestFuzzySystems(test_name))
      tests_passed++;
   else
      PrintFormat("%s failed",test_name);
   return;
  }
//+------------------------------------------------------------------+
//| UnitTests()                                                      |
//+------------------------------------------------------------------+
void UnitTests(const string package_name)
  {
   PrintFormat("Unit tests for Package %s\n",package_name);
//--- initial values
   int tests_performed=0;
   int tests_passed=0;
//--- test distributions
   TestFuzzy(tests_performed,tests_passed);
//--- print statistics
   PrintFormat("\n%d of %d passed",tests_passed,tests_performed);
  }
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   UnitTests("Fuzzy");
  }
//+------------------------------------------------------------------+