Princeec13/mql5
Watch
0
0
Fork
You've already forked mql5
 1
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions
mql5/Scripts/UnitTests/Fuzzy/TestFuzzy.mq5

661 lines
26 KiB
MQL5
RawPermalinkNormal ViewHistory

new files added
2025-08-05 01:57:33 -04:00
//+------------------------------------------------------------------+
//| 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");
}
//+------------------------------------------------------------------+
Reference in a new issueCopy permalink