hnd1 = iRSI(_Symbol,0,9,PRICE_CLOSE);
hnd2 = iRSI(_Symbol,0,14,PRICE_CLOSE);
hnd3 = iRSI(_Symbol,0,21,PRICE_CLOSE);

double CalculateSignal()
{
 double res =0.5;
 CopyBuffer(hnd1,0,0,1,arr1);
 CopyBuffer(hnd2,0,0,1,arr2);
 CopyBuffer(hnd3,0,0,1,arr3);
 
 if(arr1[0]>70 && arr2[0]>70 && arr3[0]>70) res=1.0;                    // if all indicators are in the overbought area, sell
 if(arr1[0]<30 && arr2[0]<30 && arr3[0]<30) res=0.0;                    // if all indicators are in the oversold area, buy
 
 if(arr1[0]<30 && arr2[0]<30 && arr3[0]>70) res=0.5;                    // if 2 are oversold, and 1 is overbought, no signal
 if(arr1[0]<30 && arr2[0]>70 && arr3[0]<30) res=0.5;
 if(arr1[0]>70 && arr2[0]<30 && arr3[0]<30) res=0.5;
 
 if(arr1[0]>70 && arr2[0]>70 && arr3[0]<30) res=0.5;                    // if 2 are overbought, and 1 is oversold, no signal
 if(arr1[0]>70 && arr2[0]<30 && arr3[0]>70) res=0.5;
 if(arr1[0]<30 && arr2[0]>70 && arr3[0]>70) res=0.5;
 
 if(arr1[0]<30 && arr2[0]<30 && (arr3[0]>40 && arr3[0]<60)) res=0.0;    // if 2 are oversold, and 3rd is in the range of 40 to 60, the signal is to buy
 if(arr1[0]<30 && (arr2[0]>40 && arr2[0]<60) && arr3[0]<30) res=0.0;
 if((arr1[0]>40 && arr1[0]<60) && arr2[0]<30 && arr3[0]<30) res=0.0;
 
 if(arr1[0]>70 && arr2[0]>70 && (arr3[0]>40 && arr3[0]<60)) res=1.0;    // if 2 are overbought, and 3rd is in the range of 40 to 60, the signal is to sell
 if(arr1[0]>70 && (arr2[0]>40 && arr2[0]<60) && arr3[0]>70) res=1.0;
 if((arr1[0]>40 && arr1[0]<60) && arr2[0]>70 && arr3[0]>70) res=1.0;
 
 return(res);
}

#include <Math\Fuzzy\MamdaniFuzzySystem.mqh>
CMamdaniFuzzySystem *OurFuzzy=new CMamdaniFuzzySystem();

The number of inputs and outputs, as well as the membership functions are defined at the design stage. In our case, there will be 4 inputs, 1 output, and each of them will have 3 membership functions.

• Forming the rule base of the fuzzy inference system.

The procedure of determining the degree of truth of conditions for each rule of the fuzzy inference system.

• Activation

CFuzzyVariable *firstInput=new CFuzzyVariable("rsi1",0.0,1.0);
CFuzzyVariable *secondInput=new CFuzzyVariable("rsi2",0.0,1.0);
CFuzzyVariable *thirdInput=new CFuzzyVariable("rsi3",0.0,1.0);
CFuzzyVariable *fuzzyOut=new CFuzzyVariable("out",0.0,1.0);

CDictionary_Obj_Double *firstTerm=new CDictionary_Obj_Double;
CDictionary_Obj_Double *secondTerm=new CDictionary_Obj_Double;
CDictionary_Obj_Double *thirdTerm=new CDictionary_Obj_Double;
CDictionary_Obj_Double *Output;

firstInput.Terms().Add(new CFuzzyTerm("buy", new CZ_ShapedMembershipFunction(0.0,0.6)));
firstInput.Terms().Add(new CFuzzyTerm("neutral", new CNormalMembershipFunction(0.5, 0.2)));
firstInput.Terms().Add(new CFuzzyTerm("sell", new CS_ShapedMembershipFunction(0.4,1.0)));
OurFuzzy.Input().Add(firstInput);
   
secondInput.Terms().Add(new CFuzzyTerm("buy", new CZ_ShapedMembershipFunction(0.0,0.6)));
secondInput.Terms().Add(new CFuzzyTerm("neutral", new CNormalMembershipFunction(0.5, 0.2)));
secondInput.Terms().Add(new CFuzzyTerm("sell", new CS_ShapedMembershipFunction(0.4,1.0)));
OurFuzzy.Input().Add(secondInput);
   
thirdInput.Terms().Add(new CFuzzyTerm("buy", new CZ_ShapedMembershipFunction(0.0,0.6)));
thirdInput.Terms().Add(new CFuzzyTerm("neutral", new CNormalMembershipFunction(0.5, 0.2)));
thirdInput.Terms().Add(new CFuzzyTerm("sell", new CS_ShapedMembershipFunction(0.4,1.0)));
OurFuzzy.Input().Add(thirdInput);
   
fuzzyOut.Terms().Add(new CFuzzyTerm("buy", new CZ_ShapedMembershipFunction(0.0,0.6)));
fuzzyOut.Terms().Add(new CFuzzyTerm("neutral", new CNormalMembershipFunction(Gposition, Gsigma)));
fuzzyOut.Terms().Add(new CFuzzyTerm("sell", new CS_ShapedMembershipFunction(0.4,1.0)));
OurFuzzy.Output().Add(fuzzyOut);

//+------------------------------------------------------------------+ 
//|                                      Our MembershipFunctions.mq5 | 
//|                        Copyright 2016, MetaQuotes Software Corp. | 
//|                                             https://www.mql5.com | 
//+------------------------------------------------------------------+ 
#include <Math\Fuzzy\membershipfunction.mqh> 
#include <Graphics\Graphic.mqh> 
//--- Create membership functions 
CZ_ShapedMembershipFunction func2(0.0, 0.6);
CNormalMembershipFunction func1(0.5, 0.2); 
CS_ShapedMembershipFunction func3(0.4, 1.0);

//--- Create wrappers for membership functions 
double NormalMembershipFunction1(double x) { return(func1.GetValue(x)); } 
double ZShapedMembershipFunction(double x) { return(func2.GetValue(x)); }
double SShapedMembershipFunction(double x) { return(func3.GetValue(x)); }
 
//+------------------------------------------------------------------+ 
//| Script program start function                                    | 
//+------------------------------------------------------------------+ 
void OnStart() 
  { 
//--- create graphic 
   CGraphic graphic; 
   if(!graphic.Create(0,"Our MembershipFunctions",0,30,30,780,380)) 
     { 
      graphic.Attach(0,"Our MembershipFunctions"); 
     } 
   graphic.HistoryNameWidth(70); 
   graphic.BackgroundMain("Our MembershipFunctions"); 
   graphic.BackgroundMainSize(16); 
//--- create curve 
   graphic.CurveAdd(NormalMembershipFunction1,0.0,1.0,0.01,CURVE_LINES,"[0.5, 0.2]"); 
   graphic.CurveAdd(ZShapedMembershipFunction,0.0,1.0,0.01,CURVE_LINES,"[0.0, 0.6]"); 
   graphic.CurveAdd(SShapedMembershipFunction,0.0,1.0,0.01,CURVE_LINES,"[0.4, 1.0]"); 
//--- sets the X-axis properties 
   graphic.XAxis().AutoScale(false); 
   graphic.XAxis().Min(0.0); 
   graphic.XAxis().Max(1.0); 
   graphic.XAxis().DefaultStep(0.1); 
//--- sets the Y-axis properties 
   graphic.YAxis().AutoScale(false); 
   graphic.YAxis().Min(0.0); 
   graphic.YAxis().Max(1.1); 
   graphic.YAxis().DefaultStep(0.1); 
//--- plot 
   graphic.CurvePlotAll(); 
   graphic.Update(); 
  }

At this stage, we add a knowledge base to the system to be used when making fuzzy decisions.

   rule1 = OurFuzzy.ParseRule("if (rsi1 is buy) and (rsi2 is buy) and (rsi3 is buy) then (out is buy)");
   rule2 = OurFuzzy.ParseRule("if (rsi1 is sell) and (rsi2 is sell) and (rsi3 is sell) then (out is sell)");
   rule3 = OurFuzzy.ParseRule("if (rsi1 is neutral) and (rsi2 is neutral) and (rsi3 is neutral) then (out is neutral)"); 
   
   rule4 = OurFuzzy.ParseRule("if (rsi1 is buy) and (rsi2 is sell) and (rsi3 is buy) then (out is neutral)");
   rule5 = OurFuzzy.ParseRule("if (rsi1 is sell) and (rsi2 is sell) and (rsi3 is buy) then (out is neutral)");
   rule6 = OurFuzzy.ParseRule("if (rsi1 is buy) and (rsi2 is buy) and (rsi3 is sell) then (out is neutral)"); 
   
   rule7 = OurFuzzy.ParseRule("if (rsi1 is buy) and (rsi2 is buy) and (rsi3 is neutral) then (out is buy)");
   rule8 = OurFuzzy.ParseRule("if (rsi1 is sell) and (rsi2 is sell) and (rsi3 is neutral) then (out is sell)");
   rule9 = OurFuzzy.ParseRule("if (rsi1 is buy) and (rsi2 is neutral) and (rsi3 is buy) then (out is buy)");
   rule10 = OurFuzzy.ParseRule("if (rsi1 is sell) and (rsi2 is neutral) and (rsi3 is sell) then (out is sell)");
   rule11 = OurFuzzy.ParseRule("if (rsi1 is neutral) and (rsi2 is buy) and (rsi3 is buy) then (out is buy)");
   rule12 = OurFuzzy.ParseRule("if (rsi1 is neutral) and (rsi2 is sell) and (rsi3 is sell) then (out is sell)");

   OurFuzzy.Rules().Add(rule1);
   OurFuzzy.Rules().Add(rule2);
   OurFuzzy.Rules().Add(rule3);
   OurFuzzy.Rules().Add(rule4);
   OurFuzzy.Rules().Add(rule5);
   OurFuzzy.Rules().Add(rule6);
   OurFuzzy.Rules().Add(rule7);
   OurFuzzy.Rules().Add(rule8);
   OurFuzzy.Rules().Add(rule9);
   OurFuzzy.Rules().Add(rule10);
   OurFuzzy.Rules().Add(rule11);
   OurFuzzy.Rules().Add(rule12);

At least one logical condition must be added to the knowledge base: it is considered incomplete if at least one term is not involved in logical operations. There can be an indefinite amount of logical conditions.

The provided example sets 12 logical conditions, which influence the fuzzy inference when met. Thus, all terms participate in logical operations. By default, all logical operations are assigned the same weight coefficients equal to 1. They will not be changed in this example.

If all 3 indicators are within the fuzzy area for buying, a fuzzy buy signal will be output. The same applies to sell and neutral signals. (rules 1-3)

If 2 indicators show buy and one shows sell, the output value will be neutral, that is, uncertain. (rules 4-6)

If 2 indicators show buy or sell, and one is neutral, then buy or sell is assigned to the output value. (rules 7-12)

Obviously, this is not the only variant for creating a rule base, you are free to experiment. This rule base is founded merely on my "expert" judgment and vision of how the system should function.

Obtaining a crisp output value after defuzzification

It remains to calculate the model and obtain the result as a value from 0 to 1. Values close to 0 will indicate a strong buy signal, those close to 0.5 are neutral, and values close to 1 mean a strong sell signal.

double CalculateMamdani()

{
 CopyBuffer(hnd1,0,0,1,arr1);
 NormalizeArrays(arr1);
   
 CopyBuffer(hnd2,0,0,1,arr2);
 NormalizeArrays(arr2);
    
 CopyBuffer(hnd3,0,0,1,arr3);
 NormalizeArrays(arr3);
     
 firstTerm.SetAll(firstInput,arr1[0]);
 secondTerm.SetAll(secondInput,arr2[0]);
 thirdTerm.SetAll(thirdInput,arr2[0]);
       
 Inputs.Clear(); 
 Inputs.Add(firstTerm);
 Inputs.Add(secondTerm);
 Inputs.Add(thirdTerm);
      
 CList *FuzzResult=OurFuzzy.Calculate(Inputs);
 Output=FuzzResult.GetNodeAtIndex(0);
 double res = Output.Value();
 delete FuzzResult;

 return(res);
}

This function gets the values of three RSI oscillators with different periods, normalizes them to a range from 0 to 1 (values can be simply divided by 100), updates the list with objects of the Fuzzy dictionary (the latest indicator values), sends it to calculations, creates a list for the output variable and takes the result in the 'res' variable.

Adding service functions and optimizing/testing the resulting system

Since machine learning or at least its basics are also being considered, some parameters will be moved to inputs and optimized.

input string Fuzzy_Setings;        //Fuzzy optimization settings
input double Gsigma = 0.5;         //sigma From 0.05 to 0.5 with 0.05 step
input double Gposition=0.5;        //position From 0.0 to 1.0 with 0.1 step
input double MinNeutralSignal=0.4; //MinNeutralSignal from 0.3 to 0.5 with 0.1 step
input double MaxNeutralSignal=0.6; //MaxNeutralSignal from 0.5 to 0.7 with 0.1 step

The parameters of the Gaussian (membership function) will undergo optimization at the output of the fuzzy logic. It will have its center along the X axis shifted (parameter Gposition), its sigma changed (its bell narrowed and compressed, parameter Gsigma). This will give a better fine-tuning of the system in case the RSI signals for buying and selling are asymmetric.

Additionally, optimize the conditions for opening deals: the minimum value of a neutral signal and the maximum value (new positions will not be opened in the range between these values, as the signal is not defined).

The processing of a signal at the output of the fuzzy logic is shown in the following listing:

void OnTick()
  {
//---
   if(!isNewBar())
     {  
      return;
     }
     
   double TradeSignal=CalculateMamdani(); 
   
   if(CountOrders(0)!=0 || CountOrders(1)!=0)                                           // if there are open positions
      {
       for(int b=OrdersTotal()-1; b>=0; b--)
         {
          if(OrderSelect(b,SELECT_BY_POS)==true)
           {
            if(OrderSymbol()==_Symbol && OrderMagicNumber()==OrderMagic)
             {
              if(OrderType()==OP_BUY && TradeSignal>=MinNeutralSignal)                  // a buy order is selected and the trade signal is greater than the left boundary of the neutral signal
               {                                                                        // that is, there is either a neutral signal or a sell signal
                if(OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0,Red))       // then close the buy position
                 {
                  if(TradeSignal>MaxNeutralSignal)                     // if the order is closed and a sell signal exists (exceeds the right boundary of the neutral signal), immediately open a sell position
                  {
                   lots = LotsOptimized(); 
                   if(OrderSend(Symbol(),OP_SELL,lots,SymbolInfoDouble(_Symbol,SYMBOL_BID),0,0,0,NULL,OrderMagic,Red)){
                     };
                  }
                 }
               }
               if(OrderType()==OP_SELL && TradeSignal<=MaxNeutralSignal)                 // a sell order is selected....///.... the same as for buy positions, but all conditions are mirrored
               {
                if(OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0,Red))
                 {
                  if(TradeSignal<MinNeutralSignal)
                  {
                   lots = LotsOptimized(); 
                   if(OrderSend(Symbol(),OP_BUY,lots,SymbolInfoDouble(_Symbol,SYMBOL_ASK),0,0,0,NULL,OrderMagic,Green)){
                    };
                  }
                 }
               }
             }
            }
          }
         return;
        }
                 // if there are no positions, open positions according to signals
   lots = LotsOptimized(); 
   if(TradeSignal<MinNeutralSignal && CheckMoneyForTrade(_Symbol,lots,ORDER_TYPE_BUY))
     { 
      if(OrderSend(Symbol(),OP_BUY,lots,SymbolInfoDouble(_Symbol,SYMBOL_ASK),0,0,0,NULL,OrderMagic,Green)){
       };
     }
   else if(TradeSignal>MaxNeutralSignal && CheckMoneyForTrade(_Symbol,lots,ORDER_TYPE_SELL))
     {
      if(OrderSend(Symbol(),OP_SELL,lots,SymbolInfoDouble(_Symbol,SYMBOL_BID),0,0,0,NULL,OrderMagic,Red)){
       };
     }
   return;
     
  }

Calculations will be carried out on new bar to accelerate the demonstration. You are free to customize the logic at your discretion, for example, trade on every tick by simply removing the check for a new bar.

If there are open positions and the signal contradicts the current position or is not defined, close the position. If there is a condition for opening an opposite position, open it.

This system does not utilize stop loss, as it is not trade reversals, and closure/reopening of trades is based on signals.

The Expert Advisor uses the MT4Orders library to facilitate the work with orders and to make the code easily convertible into MQL4.

Testing process

Select the best optimization result:

Compare it with the testing results of the strict model:

The resulting membership functions at the output, after optimization (the inputs remain unchanged since they were not optimized):

Before the changes:

After:

Optimize the system with the same settings but on the M5 timeframe:

Compare it with the testing results of the strict model:

The resulting membership functions at the output, after optimization (the inputs remain unchanged since they were not optimized):

Before the changes:

After:

In both cases, the Gaussian (neutral zone) was shifted towards buys and the number of long positions prevails over the number of short positions. This means that the buy and sell signals turned out to be asymmetrical on this particular segment of history, which could not be discovered without such an experiment. It is possible that the system consisting of three RSI was in the oversold zone (area 1) more often than in the overbought zone (area 0), and optimization of the Gaussian helped smooth out this imbalance. As for the crispest output, it is analytically hard to imagine why such an output configuration contributed to the improvement of the trading system results, because the process of defuzzification using the center of gravity method, in conjunction with all the mapping of inputs to fuzzy sets, is already a complex system by itself.

The system proved to be quite stable for 8 months, even though only 4 parameters were optimized. And they can easily be reduced to two (Gsigma and Gposition), since the remaining 2 had little impact on the result and are always in the vicinity of 0.5. This is assumed a satisfactory result for an experimental system, aimed at showing how the number of optimized parameters can be reduced by introducing an element of fuzzy logic into the trading system. In contrast, it would have been necessary to create numerous optimization criteria for strict rules, which would increase the complexity of system development and the number of optimized parameters.

It should also be noted that this is still a very crude example of building a trading system based on fuzzy logic, as it uses a primitive RSI-based strategy without even using stop losses. However, this should be sufficient to understand the applicability of fuzzy logic to creation of trading systems.

Conclusion

Fuzzy logic allows for a quick creation of systems with fuzzy rules that are very simple to optimize. At the same time, the complex process of selecting the trading system parameters passes through genetic optimization, freeing the developer from the routine of searching for a trading strategy, developing and algorithmizing numerous rules of the trading system. Together with other machine learning methods (for example, neural networks), this approach allows achieving impressive results. It reduces the chance of overfitting and the dimension of the input data (3 RSI indicators with different periods narrowed down to a single signal, which describes the market situation more fully and more generalized than each indicator on its own).

If you still have troubles understanding how the fuzzy logic works, ask yourself how you think, what terms you operate and what rule bases your decision-making relies on.

Here is a reinforcement example. For instance, you have 3 wishes: go to a party, watch a movie at home or save the world. The term "watch a movie at home" has the greatest weight, because you are already at home and no further effort is necessary. Going to a party is viable if someone invites you and picks you up, but since it had not happened yet, the chances of going are average. And, finally, to save the world, you need to mobilize all your supernatural abilities, put on a superman costume and fight an alien monster. It is unlikely that you decide to do it today and not leave it until tomorrow, so the chances are slim.

The fuzzy inference will be something like this: I will most likely stay at home, and perhaps I will go to the party, but I am definitely not going to save the world today. After defuzzification, our chances could be evaluated on a scale of 0 to 10, where 0 is "stay at home", 5 is "go to the party", 10 is "fight a monster". Obviously, the crisp output would lie in the range of 0 to 3, i.e. you are most likely to stay at home. The same principle is used in the presented trading system: it compares the values of three indicators and uses logical conditions to determine the most preferable option at the current moment — buying, selling or doing nothing.

Possible ways to improve this example (for self-study):

• Increasing the number of inputs and logical conditions. This increases the capacity of the system and makes it more adaptive to the market.
• Optimizing not only the output Gaussian, but also all membership functions of inputs and output.
• Optimizing the rule base.
• Optimization the weights of logical expressions.
• Creating a committee of several fuzzy models responsible for different aspects of the trading system.
• Using fuzzy inferences as predictors ("features") and/or target variables for neural networks.

If there is enough interest in the article, and I receive sufficient feedback, I could consider the possibility of writing a new article devoted to combination of fuzzy logic and a neural network.

Below are the source codes of the experts and a test script for the membership functions. For the expert to compile and work, it is necessary to download the MT4Orders library and the updated Fuzzy library.