Optimal F Service

Optimal F Service

• Application Type: Service
• Application Functions: Calculation of the optimal fraction and trade volume to achieve maximum growth of the equity curve, based on the results of previous trades.

About this app

Capital management is the most crucial and often underestimated component of any trading system. Proper capital management can enhance—and sometimes significantly improve—the performance of your trading algorithm.
This application automatically calculates the optimal fraction and trade volume using the algorithm proposed by Ralph Vince in his book "The Mathematics of Money Management" to achieve maximum geometric growth of the account balance. This point exists and is unique for any trading system, which is why it is essential to know it. In your trading systems, you must never use a trade size exceeding the optimal value!

How to use

Before the first launch, each trading system must be tested in the strategy tester for the period up to the present moment. It is recommended to select a timeframe that includes at least 100 trades. Then, using the Test Trade Saver Script and following the instructions, extract the result files from the testing files (*.tst) in the required format.

Next, to ensure that the data files are regularly updated and remain current, you need to run the Trade Saver Service following the provided instructions.
Thus, after the initial data export from tests using the Trade Saver Script, the Trade Saver Service continuously updates the files with new data as it becomes available, while the Optimal F Service regularly calculates and writes new values to the results file

Algorithm

1. Extract the list of systems requiring calculation from the MAGIC_LIST parameter.
2. Use text files named <MAGIC>.csv in the format <MAGIC>,<POSITION_CLOSE_TIME>,<LOTS>,<RESULT_$> containing the results of previous trades from the directory specified by TRADE_FILES_PATH. Construct a matrix for the balance curve function, where each value a[i][j] represents the result of trading system i for period j.
3. Check each system for at least one negative period in its results. If a system has no negative periods, exclude it from further calculations (such systems must be removed).
4. Evaluate the mathematical expectation of each system. If a system has no positive expected value, exclude it from further calculations (such systems must be removed).
5. Determine the error margin required to compute the trading volume with a precision of 0.01.
6. For each remaining system, calculate its optimal fraction.
7. Divide the current balance into equal parts for the remaining systems. For each system and its allocated balance, calculate the trade volume in lots corresponding to the optimal fraction.
8. Write the results to the text file specified by OUTPUT_FILE_PATH in the format <MAGIC>,<BIGGEST_LOSS>,<OPTIMAL_F>,<OPTIMAL_LOTS>.

Links and references

• Ralph Vince - The Mathematics of Money Management: Risk Analysis Techniques for Traders (ISBN-13  978-0471547389)

For developers

#include "OptimalFResultsLoader.mqh"

   // create loader
   COptimalFResultsLoader* optimalFResultsLoader = new COptimalFResultsLoader("/SRProject/results.csv");
   // print all fields for magic = '1111'
   Print(optimalFResultsLoader.getOptimalFFor(1111), " ",
         optimalFResultsLoader.getBiggestLossFor(1111), " ", 
         optimalFResultsLoader.getOptimalLotsFor(1111));
   // delete loader from memory
   delete(optimalFResultsLoader);

//+------------------------------------------------------------------+
//|                                        OptimalFResultsLoader.mqh |
//|                                                   Semyon Racheev |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Semyon Racheev"
#property link      ""
#property version   "1.00"

#include <Files\FileTxt.mqh>

class COptimalFResultsLoader
  {
private:
   const string name_;
   const uchar delimiter_;
   const ushort separator_;
   const string srcFilePath_; 
                     bool checkStringForOptimalFResultsDeserializing(string &inputStr[]) const;
                     ushort calculateCharCode(const uchar separator) const;
public:
                     COptimalFResultsLoader(const string srcFilePath, uchar separator);
                    ~COptimalFResultsLoader();
                     double getOptimalLotsFor(const ulong magicNumber) const;
                     double getOptimalFFor(const ulong magicNumber) const;
                     double getBiggestLossFor(const ulong magicNumber) const;
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
COptimalFResultsLoader::COptimalFResultsLoader(const string srcFilePath = "/SRProject/results.csv", uchar separator = ','):name_("OptimalFResultsLoader"),
srcFilePath_(srcFilePath), delimiter_(separator), separator_(calculateCharCode(separator))
  {  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
COptimalFResultsLoader::~COptimalFResultsLoader()
  {
  }
//+------------------public------------------------------------------+
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double COptimalFResultsLoader::getOptimalLotsFor(const ulong inputMagicNumber) const
  {
   double rsl = 0.0;
   CFileTxt* file = new CFileTxt();
   int fileHandle = file.Open(srcFilePath_,FILE_READ|FILE_UNICODE|FILE_CSV);
   while (!FileIsEnding(fileHandle))
    {
     string readString = file.ReadString(); 
     
     string str[];
     StringSplit(readString, separator_, str);
     if (checkStringForOptimalFResultsDeserializing(str))
      {
       if (inputMagicNumber == (ulong)StringToInteger(str[0]))
        {
         rsl = StringToDouble(str[3]);
        }
      }
    }   
   file.Close();
   delete(file);
   return(rsl);  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double COptimalFResultsLoader::getOptimalFFor(const ulong inputMagicNumber) const
  {
   double rsl = 0.0;
   CFileTxt* file = new CFileTxt();
   int fileHandle = file.Open(srcFilePath_,FILE_READ|FILE_UNICODE|FILE_CSV);
   while (!FileIsEnding(fileHandle))
    {
     string readString = file.ReadString(); 
     
     string str[];
     StringSplit(readString, separator_, str);
     if (checkStringForOptimalFResultsDeserializing(str))
      {
       if (inputMagicNumber == (ulong)StringToInteger(str[0]))
        {
         rsl = StringToDouble(str[2]);
        }
      }
    }   
   file.Close();
   delete(file);
   return(rsl);  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double COptimalFResultsLoader::getBiggestLossFor(const ulong inputMagicNumber) const
  {
   double rsl = 0.0;
   CFileTxt* file = new CFileTxt();
   int fileHandle = file.Open(srcFilePath_,FILE_READ|FILE_UNICODE|FILE_CSV);
   while (!FileIsEnding(fileHandle))
    {
     string readString = file.ReadString(); 
     
     string str[];
     StringSplit(readString, separator_, str);
     if (checkStringForOptimalFResultsDeserializing(str))
      {
       if (inputMagicNumber == (ulong)StringToInteger(str[0]))
        {
         rsl = StringToDouble(str[1]);
        }
      }
    }   
   file.Close();
   delete(file);
   return(rsl);  
  }
//+---------------------private--------------------------------------+
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool COptimalFResultsLoader::checkStringForOptimalFResultsDeserializing(string &inputStr[]) const
  {
   if (ArraySize(inputStr) < 4)
    {
     return(false);
    }
   return(true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
ushort COptimalFResultsLoader::calculateCharCode(const uchar separator) const
  {
   string str = CharToString(separator);
   return(StringGetCharacter(str,0));
  }
//+------------------------------------------------------------------+