SuperCharlie_Oxford/Homologacao_v4_4/S5_Direcao_v4_4.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//|                                              S5_Direcao_v4_4.mq5 |
//|                                                           OXFORD |
//|                                             HEDGING HORN CAPITAL |
//|                                     https://www.hhcapital.com.br |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, HEDGING HORN CAPITAL"
#property link      "https://www.hhcapital.com.br"
#property version   "HOMOLOG_v4_4"
#property description "HFT MARKET MAKING BASED ON OXFORD'S STUDIES. MINI INDICE."

//+===================================================================================================================================================================================+
//| 0 - SESSAO DE CABECALHO / ADMISSAO                                                                                                                                                
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 0.1 - IMPORTACOES                                                |
//+------------------------------------------------------------------+
#include "MarketBook.mqh"
#include "S0_Admissao_v4_4.mqh"

//+===================================================================================================================================================================================+
//| 5 - SESSAO DE PRECOS / DIRECAO                                                                                                                                                    
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 5.1 - FUNCAO QUE DA GET NOS SPREADS E SET NOS PRECOS DA ORDEM    |
//+------------------------------------------------------------------+
void CalculaPrecoOrdem(operacao &Operacao, fluido &Fluidos, slot &Slots[], MqlTick &ArrayTick[], MqlBookInfo &ArrayBook[])
{
   //Calcula os spreads
   if(Slots[0].ponta == 0) 
   {
      CalculaSpreadOrdemC(Operacao, Fluidos, Slots, ArrayTick, ArrayBook);
      SetPrecosOrdemCompra(Operacao, Fluidos, Slots);
   }
   else
   {
      CalculaSpreadOrdemV(Operacao, Fluidos, Slots, ArrayTick, ArrayBook);
      SetPrecosOrdemVenda(Operacao, Fluidos, Slots);
   }
   
   return;
}

//+------------------------------------------------------------------+
//| 5.2 - FUNCAO QUE DA GET NOS SPREADS E SET NOS ALVOS DA POSICAO   |
//+------------------------------------------------------------------+
void CalculaPrecoPosicao(operacao &Operacao, fluido &Fluidos)
{
   if(Operacao.tipoPosicao == POSITION_TYPE_BUY) 
   {
      Operacao.precoAlvo = Fluidos.midPrice + CalculaSpreadPosicaoAlvoC(Fluidos);
      Operacao.precoAlvo = Operacao.precoAlvo - MathMod(Operacao.precoAlvo, Fluidos.tickMin);
   }
   else
   {
      Operacao.precoAlvo = Fluidos.midPrice - CalculaSpreadPosicaoAlvoV(Fluidos);
      Operacao.precoAlvo = Operacao.precoAlvo + (Fluidos.tickMin - MathMod(Operacao.precoAlvo, Fluidos.tickMin));
   }
   
   return;
}

//+------------------------------------------------------------------+
//| 5.2 - FUNCAO QUE DA GET NOS SPREADS E SET NOS STOPS DA POSICAO   |
//+------------------------------------------------------------------+
void CalculaPrecoTrailing(operacao &Operacao, fluido &Fluidos)
{
   if(Operacao.tipoPosicao == POSITION_TYPE_BUY) 
   {
      if(Operacao.chaveTrailing == true)
      {
         if(Fluidos.midPrice > (Operacao.precoEnvio + Operacao.offsetStartTrailingC)) Operacao.precoStop = Fluidos.midPrice - (Fluidos.tickMin/2 + Operacao.offsetStopTrailingC);
         
         if(MathMod(Operacao.precoStop, Fluidos.tickMin) != 0)
         {
            Operacao.precoStop = Operacao.precoStop - MathMod(Operacao.precoStop, Fluidos.tickMin);
         }
      }
   }
   else
   { 
      if(Operacao.chaveTrailing == true)
      {
         if(Fluidos.midPrice < (Operacao.precoEnvio - Operacao.offsetStartTrailingV)) Operacao.precoStop = Fluidos.midPrice + (Fluidos.tickMin/2 + Operacao.offsetStopTrailingV);
      
         if(MathMod(Operacao.precoStop, Fluidos.tickMin) != 0)
         {
            Operacao.precoStop = Operacao.precoStop + (Fluidos.tickMin - MathMod(Operacao.precoStop, Fluidos.tickMin));
         }
      }
   }
   return;
}

//+------------------------------------------------------------------+
//| 5.3 - FUNCAO QUE CALCULA OS SPREADS DA ORDEM DE COMPRA           |
//+------------------------------------------------------------------+
void CalculaSpreadOrdemC(operacao &Operacao, fluido &Fluidos, slot &SlotsC[], MqlTick &ArrayTick[], MqlBookInfo &ArrayBook[])
{

   double spreadCompra = Fluidos.tickMin/2 + Fluidos.spreadCusto;
   double spreadVenda = Fluidos.tickMin*2 + Fluidos.spreadCusto;
   double desvio = MathRound(Fluidos.sigmaLFT * Fluidos.fatorVol/ Fluidos.tickMin) * Fluidos.tickMin;
   double nivel = MathRound(log(Fluidos.iSlot+1) * 100 / Fluidos.tickMin) / 100 * Fluidos.tickMin;
   double incrementoAntC = 0.0;
   double incrementoC = 0.0;
   double incrementoAntV = 0.0;
   double incrementoV = 0.0;
    
   if(Operacao.chaveDeltaH == true)
   {
      double HC_q = CalculaHC(Fluidos, Fluidos.q, Fluidos.n);
      double HV_q = CalculaHV(Fluidos, Fluidos.q, Fluidos.n);
      double HC_qmais1 = CalculaHCmais1(Fluidos, Fluidos.q+1, Fluidos.n);
      double HV_qmenos1 = CalculaHVmenos1(Fluidos, Fluidos.q-1, Fluidos.n);
      double difC = HC_q - HC_qmais1;
      double difV = HV_q - HV_qmenos1;
      
      if(difC < 0)
      {
         Fluidos.LC = false;
         return;
      } 
      if(difV < 0) difV = 0.0;
      
      incrementoAntC = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaV/Fluidos.KC) + difC) / Fluidos.tickMin) * Fluidos.tickMin;
      incrementoAntV = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaC/Fluidos.KV) + difV) / Fluidos.tickMin) * Fluidos.tickMin;
      spreadCompra += incrementoAntC;
      spreadVenda += incrementoAntV;
      
   }
   
   if(Operacao.chaveDesvio == true)
   {
      if(Operacao.chaveCurtose == true) 
      {
         incrementoC = MathRound((desvio * nivel * (1 - Fluidos.curtose))/Fluidos.tickMin) * Fluidos.tickMin;
         
         if(incrementoC > -1*incrementoAntC)
         { 
            spreadCompra += incrementoC;
            incrementoAntC += incrementoC;
         }
      }
      else
      {
         incrementoC = MathRound((desvio * nivel)/Fluidos.tickMin)*Fluidos.tickMin;
         spreadCompra += incrementoC;
         incrementoAntC += incrementoC;
      }
   }
   
   if(Fluidos.q > 0)
   {
      if(Operacao.chaveGama == true) 
      {
         incrementoC = MathRound((desvio * Fluidos.gama * (Fluidos.q/Fluidos.rajada))/Fluidos.tickMin) * Fluidos.tickMin;
         spreadCompra += incrementoC;
         incrementoAntC += incrementoC;
      }
      if(Operacao.chaveFi == true)
      {
         incrementoV = -1*MathRound((desvio * nivel * Fluidos.fi * (Fluidos.q/Fluidos.rajada)) /Fluidos.tickMin) * Fluidos.tickMin;
         
         if(incrementoV > -1*incrementoAntV)
         {
            spreadVenda += incrementoV;
            incrementoAntV += incrementoV;
         }
      }
   }
   
   if(Operacao.chaveDrift == true) 
   {
      incrementoC = -1*MathRound(Fluidos.drift/Fluidos.tickMin)*Fluidos.tickMin;
      incrementoV = MathRound(Fluidos.drift/Fluidos.tickMin)*Fluidos.tickMin;
      
      if(incrementoC > -1*incrementoAntC) spreadCompra += incrementoC;
      if(incrementoV > -1*incrementoAntV) spreadVenda += incrementoV;
   }
   SlotsC[Fluidos.iSlot].spreadEnvio = spreadCompra;
   SlotsC[Fluidos.iSlot].spreadAlvo =  spreadVenda;
   SlotsC[Fluidos.iSlot].spreadStop = MathRound(Fluidos.sigmaLFT / Fluidos.tickMin) * Fluidos.tickMin * Fluidos.fatorStop;

   return;   
}

//+------------------------------------------------------------------+
//| 5.4 - FUNCAO QUE CALCULA OS SPREADS DA ORDEM DE VENDA            |
//+------------------------------------------------------------------+
void CalculaSpreadOrdemV(operacao &Operacao, fluido &Fluidos, slot &SlotsV[], MqlTick &ArrayTick[], MqlBookInfo &ArrayBook[])
{
   double spreadCompra = Fluidos.tickMin/2 + Fluidos.spreadCusto;
   double spreadVenda = Fluidos.tickMin*2 + Fluidos.spreadCusto;
   double desvio = MathRound(Fluidos.sigmaLFT * Fluidos.fatorVol/ Fluidos.tickMin) * Fluidos.tickMin;
   double nivel = MathRound(log(Fluidos.iSlot+1) * 100 / Fluidos.tickMin) / 100 * Fluidos.tickMin;
   double incrementoAntC = 0.0;
   double incrementoC = 0.0;
   double incrementoAntV = 0.0;
   double incrementoV = 0.0;
    
   if(Operacao.chaveDeltaH == true)
   {
      double HC_q = CalculaHC(Fluidos, Fluidos.q, Fluidos.n);
      double HV_q = CalculaHV(Fluidos, Fluidos.q, Fluidos.n);
      double HC_qmais1 = CalculaHCmais1(Fluidos, Fluidos.q+1, Fluidos.n);
      double HV_qmenos1 = CalculaHVmenos1(Fluidos, Fluidos.q-1, Fluidos.n);
      double difC = HC_q - HC_qmais1;
      double difV = HV_q - HV_qmenos1;
      
      if(difV < 0)
      {
         Fluidos.LV = false;
         return;
      } 
      if(difC < 0) difC = 0.0;
      
      incrementoAntC = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaV/Fluidos.KC) + difC) / Fluidos.tickMin) * Fluidos.tickMin;
      incrementoAntV = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaC/Fluidos.KV) + difV) / Fluidos.tickMin) * Fluidos.tickMin;
      spreadCompra += incrementoAntC;
      spreadVenda += incrementoAntV;
      
   }
   
   if(Operacao.chaveDesvio == true)
   {
      if(Operacao.chaveCurtose == true) 
      {
         incrementoV = MathRound((desvio * nivel * (1 - Fluidos.curtose))/Fluidos.tickMin) * Fluidos.tickMin;
         
         if(incrementoV > -1*incrementoAntV)
         { 
            spreadVenda += incrementoV;
            incrementoAntV += incrementoV;
         }
      }
      else
      {
         incrementoV = MathRound((desvio * nivel)/Fluidos.tickMin)*Fluidos.tickMin;
         spreadVenda += incrementoV;
         incrementoAntV += incrementoV;
      }
   }
   
   if(Fluidos.q < 0)
   {
      if(Operacao.chaveGama == true) 
      {
         incrementoV = -1*MathRound((desvio * Fluidos.gama * (Fluidos.q/Fluidos.rajada))/Fluidos.tickMin) * Fluidos.tickMin;
         spreadVenda += incrementoV;
         incrementoAntV += incrementoV;
      }
      if(Operacao.chaveFi == true)
      {
         incrementoC = MathRound((desvio * nivel * Fluidos.fi * (Fluidos.q/Fluidos.rajada)) /Fluidos.tickMin) * Fluidos.tickMin;
         
         if(incrementoC > -1*incrementoAntC)
         {
            spreadCompra += incrementoC;
            incrementoAntC += incrementoC;
         }
      }
   }
   
   if(Operacao.chaveDrift == true) 
   {
      incrementoC = -1*MathRound(Fluidos.drift/Fluidos.tickMin)*Fluidos.tickMin;
      incrementoV = MathRound(Fluidos.drift/Fluidos.tickMin)*Fluidos.tickMin;
      
      if(incrementoC > -1*incrementoAntC) spreadCompra += incrementoC;
      if(incrementoV > -1*incrementoAntV) spreadVenda += incrementoV;
   }
   SlotsV[Fluidos.iSlot].spreadEnvio = spreadVenda;
   SlotsV[Fluidos.iSlot].spreadAlvo =  spreadCompra;
   SlotsV[Fluidos.iSlot].spreadStop = MathRound(Fluidos.sigmaLFT / Fluidos.tickMin) * Fluidos.tickMin * Fluidos.fatorStop;

   return;
}

//+------------------------------------------------------------------+
//| 5.5 - FUNCAO QUE CALCULA O SPREAD DE ALVO DA POSICAO DE COMPRA   |
//+------------------------------------------------------------------+
double CalculaSpreadPosicaoAlvoC(fluido &Fluidos)
{
   double spreadVenda = Fluidos.tickMin*2 + Fluidos.spreadCusto;
   double desvio = MathRound(Fluidos.sigmaLFT * Fluidos.fatorVol/ Fluidos.tickMin) * Fluidos.tickMin;
   double nivel = MathRound(log(Fluidos.iSlot+1) * 100 / Fluidos.tickMin) / 100 * Fluidos.tickMin;
   double incrementoAntV = 0.0;
   double incrementoV = 0.0;
    
   if(Operacao.chaveDeltaH == true)
   {
      double HV_q = CalculaHV(Fluidos, Fluidos.q, Fluidos.n);
      double HV_qmenos1 = CalculaHVmenos1(Fluidos, Fluidos.q-1, Fluidos.n);
      double difV = HV_q - HV_qmenos1;
      
      if(difV < 0) difV = 0.0;
      
      incrementoAntV = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaC/Fluidos.KV) + difV) / Fluidos.tickMin) * Fluidos.tickMin;
      spreadVenda += incrementoAntV;   
   }
   
   if(Fluidos.q > 0)
   {
      if(Operacao.chaveFi == true)
      {
         incrementoV = -1*MathRound((desvio * nivel * Fluidos.fi * (Fluidos.q/Fluidos.rajada)) /Fluidos.tickMin) * Fluidos.tickMin;
         
         if(incrementoV > -1*incrementoAntV)
         {
            spreadVenda += incrementoV;
            incrementoAntV += incrementoV;
         }
      }
   }
   
   if(Operacao.chaveDrift == true) 
   {
      incrementoV = MathRound(Fluidos.drift/Fluidos.tickMin)*Fluidos.tickMin;
      
      if(incrementoV > -1*incrementoAntV) spreadVenda += incrementoV;
   }
   
   double spreadAlvo = spreadVenda;  
   return spreadAlvo;
}

//+------------------------------------------------------------------+
//| 5.6 - FUNCAO QUE CALCULA O SPREAD DE ALVO DA POSICAO DE VENDA    |
//+------------------------------------------------------------------+
double CalculaSpreadPosicaoAlvoV(fluido &Fluidos)
{
   double spreadCompra = Fluidos.tickMin/2 + Fluidos.spreadCusto;
   double desvio = MathRound(Fluidos.sigmaLFT * Fluidos.fatorVol/ Fluidos.tickMin) * Fluidos.tickMin;
   double nivel = MathRound(log(Fluidos.iSlot+1) * 100 / Fluidos.tickMin) / 100 * Fluidos.tickMin;
   double incrementoAntC = 0.0;
   double incrementoC = 0.0;
    
   if(Operacao.chaveDeltaH == true)
   {
      double HC_q = CalculaHC(Fluidos, Fluidos.q, Fluidos.n);
      double HC_qmais1 = CalculaHCmais1(Fluidos, Fluidos.q+1, Fluidos.n);
      double difC = HC_q - HC_qmais1;
       
      if(difC < 0) difC = 0.0;
      
      incrementoAntC = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaV/Fluidos.KC) + difC) / Fluidos.tickMin) * Fluidos.tickMin;
      spreadCompra += incrementoAntC;
   }
   
   if(Fluidos.q < 0)
   {
      if(Operacao.chaveFi == true)
      {
         incrementoC = MathRound((desvio * nivel * Fluidos.fi * (Fluidos.q/Fluidos.rajada)) /Fluidos.tickMin) * Fluidos.tickMin;
         
         if(incrementoC > -1*incrementoAntC)
         {
            spreadCompra += incrementoC;
            incrementoAntC += incrementoC;
         }
      }
   }
   
   if(Operacao.chaveDrift == true) 
   {
      incrementoC = -1*MathRound(Fluidos.drift/Fluidos.tickMin)*Fluidos.tickMin;
      
      if(incrementoC > -1*incrementoAntC) spreadCompra += incrementoC;
   }
   
   double spreadAlvo = spreadCompra;
   return spreadAlvo;
}

//+------------------------------------------------------------------+
//| 5.7 - FUNCAO QUE DA SET NOS PRECOS DA ORDEM DE COMPRA            |
//+------------------------------------------------------------------+
void SetPrecosOrdemCompra(operacao &Operacao, fluido &Fluidos, slot &SlotsC[])
{
   //SET PRECO ENVIO
   SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - SlotsC[Fluidos.iSlot].spreadEnvio;
   
   if(MathMod(SlotsC[Fluidos.iSlot].precoEnvio, Fluidos.tickMin) != 0)
   {
      SlotsC[Fluidos.iSlot].precoEnvio = SlotsC[Fluidos.iSlot].precoEnvio - MathMod(SlotsC[Fluidos.iSlot].precoEnvio, Fluidos.tickMin);
   }
   
   //SET PRECO ALVO
   SlotsC[Fluidos.iSlot].precoAlvo = SlotsC[Fluidos.iSlot].precoEnvio + SlotsC[Fluidos.iSlot].spreadAlvo;
   if(MathMod(SlotsC[Fluidos.iSlot].precoAlvo, Fluidos.tickMin) != 0)
   {
      SlotsC[Fluidos.iSlot].precoAlvo = SlotsC[Fluidos.iSlot].precoAlvo - MathMod(SlotsC[Fluidos.iSlot].precoAlvo, Fluidos.tickMin);
   }
   
   //SET PRECO STOP
   SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - SlotsC[Fluidos.iSlot].spreadStop;
   
   if(MathMod(SlotsC[Fluidos.iSlot].precoStop, Fluidos.tickMin) != 0)
   {
      SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoStop - MathMod(SlotsC[Fluidos.iSlot].precoStop, Fluidos.tickMin);
   }
}

//+------------------------------------------------------------------+
//| 5.8 - FUNCAO QUE DA SET NOS PRECOS DA ORDEM DE VENDA             |
//+------------------------------------------------------------------+
void SetPrecosOrdemVenda(operacao &Operacao, fluido &Fluidos, slot &SlotsV[])
{
   //SET PRECO ENVIO  
   SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + SlotsV[Fluidos.iSlot].spreadEnvio;
   
   if(MathMod(SlotsV[Fluidos.iSlot].precoEnvio, Fluidos.tickMin) != 0)
   {
      SlotsV[Fluidos.iSlot].precoEnvio = SlotsV[Fluidos.iSlot].precoEnvio + (Fluidos.tickMin - MathMod(SlotsV[Fluidos.iSlot].precoEnvio, Fluidos.tickMin));
   }
   
   //SET PRECO ALVO
   SlotsV[Fluidos.iSlot].precoAlvo = SlotsV[Fluidos.iSlot].precoEnvio - SlotsV[Fluidos.iSlot].spreadAlvo;
   if(MathMod(SlotsV[Fluidos.iSlot].precoAlvo, Fluidos.tickMin) != 0)
   {
      SlotsV[Fluidos.iSlot].precoAlvo = SlotsV[Fluidos.iSlot].precoAlvo + (Fluidos.tickMin - MathMod(SlotsV[Fluidos.iSlot].precoAlvo, Fluidos.tickMin));
   }
   
   //SET PRECO STOP
   SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + SlotsV[Fluidos.iSlot].spreadStop; 
   
   if(MathMod(SlotsV[Fluidos.iSlot].precoStop, Fluidos.tickMin) != 0)
   {
      SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoStop + (Fluidos.tickMin - MathMod(SlotsV[Fluidos.iSlot].precoStop, Fluidos.tickMin));
   }
}

//+------------------------------------------------------------------+
//| 5.9 - FUNCAO QUE VERIFICA QUAL E A TENDENCIA PELO IMBALANCE      |
//+------------------------------------------------------------------+
string GetTendencia(fluido &Fluidos, MqlTick &ArrayTick[], MqlBookInfo &ArrayBook[])
{
   if(Operacao.chaveLambda == true)
   {
      Fluidos.lambdaC = CalculaLambdaCompra(ArrayTick, Fluidos.TOe);
      Fluidos.lambdaV = CalculaLambdaVenda(ArrayTick, Fluidos.TOe);
   }
   else
   {
      if(Operacao.chaveLambdaBacktest == true)
      {
         Fluidos.lambdaC = CalculaLambdaCompraBacktest(Fluidos);
         Fluidos.lambdaV = CalculaLambdaVendaBacktest(Fluidos);
      }
   }
      
   if(Operacao.chaveBook == true)
   {
      Fluidos.KC = CalculaKC(Fluidos, ArrayBook);
      Fluidos.KV = CalculaKV(Fluidos, ArrayBook);
   }
   else
   {
      if(Operacao.chaveBookBacktest == true)
      {
         Fluidos.KC = CalculaKCBacktest(Fluidos);
         Fluidos.KV = CalculaKVBacktest(Fluidos);
      }
   }
   
   if((Fluidos.KC != 0) && (Fluidos.KV != 0)) Fluidos.imbalance = (Fluidos.lambdaC / Fluidos.KV) - (Fluidos.lambdaV / Fluidos.KC);
   else Fluidos.imbalance = 0.0;
   
   if(Fluidos.imbalance > 2*Fluidos.corteImbalance) return "ALTA FORTE";
   else if((Fluidos.imbalance > 1*Fluidos.corteImbalance) && (Fluidos.imbalance < 2*Fluidos.corteImbalance)) return "ALTA LEVE";
   else if((Fluidos.imbalance < -1*Fluidos.corteImbalance) && (Fluidos.imbalance > -2*Fluidos.corteImbalance)) return "BAIXA LEVE";
   else if(Fluidos.imbalance < -2*Fluidos.corteImbalance) return "BAIXA FORTE";
   else return "LADO";
}

//+------------------------------------------------------------------+
//| 5.10 - FUNCAO QUE CALCULA O LAMBDA COMPRA                        |
//+------------------------------------------------------------------+
int CalculaLambdaCompra(MqlTick &ArrayTick[], int T)
{
   int lambda = 0;
   double t = 0;
   int segundosIntInicial = 0;
   int segundosIntAtual = 0;
   MqlDateTime horaMqlTickInicial;
   MqlDateTime horaMqlTickAtual;
   
   for(int i=0;i<ArraySize(ArrayTick);i++)
   {
      if(t<T)
      {
         TimeToStruct(ArrayTick[0].time, horaMqlTickInicial);
         TimeToStruct(ArrayTick[i].time, horaMqlTickAtual);
         
         segundosIntInicial = horaMqlTickInicial.hour*60*60 + horaMqlTickInicial.min*60 + horaMqlTickInicial.sec;
         segundosIntAtual = horaMqlTickAtual.hour*60*60 + horaMqlTickAtual.min*60 + horaMqlTickAtual.sec;
         t = segundosIntInicial - segundosIntAtual;
         
         if(ArrayTick[i].flags == 56)
            lambda += ArrayTick[i].volume;
      }
      
   }
   T = 5*T;
   lambda = lambda / T;
   
   return lambda;
}

//+------------------------------------------------------------------+
//| 5.11 - FUNCAO QUE CALCULA O LAMBDA VENDA                         |
//+------------------------------------------------------------------+
int CalculaLambdaVenda(MqlTick &ArrayTick[], int T)
{
   int lambda = 0;
   double t = 0;
   int segundosIntInicial = 0;
   int segundosIntAtual = 0;
   MqlDateTime horaMqlTickInicial;
   MqlDateTime horaMqlTickAtual;
   
   for(int i=0;i<ArraySize(ArrayTick);i++)
   {
      if(t<T)
      {
         TimeToStruct(ArrayTick[0].time, horaMqlTickInicial);
         TimeToStruct(ArrayTick[i].time, horaMqlTickAtual);
         
         segundosIntInicial = horaMqlTickInicial.hour*60*60 + horaMqlTickInicial.min*60 + horaMqlTickInicial.sec;
         segundosIntAtual = horaMqlTickAtual.hour*60*60 + horaMqlTickAtual.min*60 + horaMqlTickAtual.sec;
         t = segundosIntInicial - segundosIntAtual;
         
         if(ArrayTick[i].flags == 88)
            lambda += ArrayTick[i].volume;
      }
      
   }
   T = 5*T;
   lambda = lambda / T;
   
   return lambda;
}

//+------------------------------------------------------------------+
//| 5.12 - FUNCAO QUE CALCULA O LOB COMPRA                           |
//+------------------------------------------------------------------+
int CalculaLobCompra(fluido &Fluidos, MqlBookInfo &ArrayBook[])
{
   int lobC = 0;
   for(int i=0; i<Fluidos.nBook;i++)
   {
      lobC = ArrayBook[Fluidos.iBid0 + i].volume;
   }
   return lobC;
}

//+------------------------------------------------------------------+
//| 5.13 - FUNCAO QUE CALCULA O LOB VENDA                            |
//+------------------------------------------------------------------+
int CalculaLobVenda(fluido &Fluidos, MqlBookInfo &ArrayBook[])
{
   int lobV = 0;
   for(int i=0; i<Fluidos.nBook;i++)
   {
      lobV = ArrayBook[Fluidos.iAsk0 - i].volume;
   }
   return lobV;
}

//+------------------------------------------------------------------+
//| 5.14 - FUNCAO QUE CALCULA O KC                                   |
//+------------------------------------------------------------------+
int CalculaKC(fluido &Fluidos, MqlBookInfo &ArrayBook[])
{
   int KC = 0;
   
   KC = CalculaLobCompra(Fluidos, ArrayBook) / Fluidos.nBook;
   
   return KC;
}

//+------------------------------------------------------------------+
//| 5.15 - FUNCAO QUE CALCULA O KV                                   |
//+------------------------------------------------------------------+
int CalculaKV(fluido &Fluidos, MqlBookInfo &ArrayBook[])
{
   int KV = 0;
   
   KV = CalculaLobVenda(Fluidos, ArrayBook) / Fluidos.nBook;
   
   return KV;
}

//+------------------------------------------------------------------+
//| 5.13 - FUNCAO QUE CALCULA O h(t,q) do SpreadBuy                  |
//+------------------------------------------------------------------+
double CalculaHC(fluido &Fluidos, int q, int n)
{
   double h = 0.0;
   double exp1 = 0.0;
   double exp2 = 0.0;
   Fluidos.eC = Fluidos.tickMin/2;
   Fluidos.eV = Fluidos.tickMin/2;
   
   exp1 = (pow(((q*Fluidos.KC*(Fluidos.eC*Fluidos.lambdaC - Fluidos.eV*Fluidos.lambdaV)) - (Fluidos.fi*Fluidos.KC*pow(q,2))),n)/Fatorial(n))  *  (pow(Fluidos.TOe,n)/Fatorial(n));
   exp2 = exp( -Fluidos.c*Fluidos.KC*pow(q,2) ); 
   
   h = (1/Fluidos.KC) * log(1 + (exp1 * exp2));
   
 //  Print("Fluidos.eC*Fluidos.lambdaC - Fluidos.eV*Fluidos.lambdaV: ", Fluidos.eC*Fluidos.lambdaC - Fluidos.eV*Fluidos.lambdaV, " / Fluidos.fi*Fluidos.KC*pow(q,2): ", Fluidos.fi*Fluidos.KC*pow(q,2), " / HC = exp1: ", exp1, " / exp2: ", exp2, " / h:", h);
   
   return h;
}
 
//+------------------------------------------------------------------+
//| 5.14 - FUNCAO QUE CALCULA O h(t,q) do SpreadSell                 |
//+------------------------------------------------------------------+
double CalculaHV(fluido &Fluidos, int q, int n)
{
   double h = 0.0;
   double exp1 = 0.0;
   double exp2 = 0.0;
   Fluidos.eC = Fluidos.tickMin/2;
   Fluidos.eV = Fluidos.tickMin/2;

   exp1 = (pow(((q*Fluidos.KV*(Fluidos.eC*Fluidos.lambdaC - Fluidos.eV*Fluidos.lambdaV)) - (Fluidos.fi*Fluidos.KV*pow(q,2))),n)/Fatorial(n))  *  (pow(Fluidos.TOe,n)/Fatorial(n));
   exp2 = exp( -Fluidos.c*Fluidos.KV*pow(q,2) ); 
   
   h = (1/Fluidos.KV) * log(1 + (exp1 * exp2));
   
   return h;
}

//+------------------------------------------------------------------+
//| 5.18 - FUNCAO QUE CALCULA O LAMBDA COMPRA BACKTEST               |
//+------------------------------------------------------------------+
int CalculaLambdaCompraBacktest(fluido &Fluidos)
{
   int lambda = 0;
   int lambdaC = 0;
   double rate = 0.0;
   
   if(Fluidos.volumeNegocios != 0) lambda = Fluidos.fatorLambdaBacktest * Fluidos.volumeReal / Fluidos.volumeNegocios;
   else lambda = 1;
   
   rate = (Fluidos.precoClose - Fluidos.precoOpen)/Fluidos.sigmaLFT;
   if(rate < -1) lambdaC = 1;
   else lambdaC = lambda * (1+rate);
   
   return lambdaC;
}

//+------------------------------------------------------------------+
//| 5.19 - FUNCAO QUE CALCULA O LAMBDA VENDA BACKTEST                |
//+------------------------------------------------------------------+
int CalculaLambdaVendaBacktest(fluido &Fluidos)
{
   int lambda = 0;
   int lambdaV = 0;
   double rate = 0.0;
   
   if(Fluidos.volumeNegocios != 0) lambda = Fluidos.fatorLambdaBacktest * Fluidos.volumeReal / Fluidos.volumeNegocios;
   else lambda = 1;
   
   rate = (Fluidos.precoClose - Fluidos.precoOpen)/Fluidos.sigmaLFT;
   if(rate > 1) lambdaV = 1;
   else lambdaV = lambda * (1-rate);
   
   return lambdaV;
}

//+------------------------------------------------------------------+
//| 5.20 - FUNCAO QUE CALCULA O BOOK COMPRA BACKTEST                 |
//+------------------------------------------------------------------+
int CalculaKCBacktest(fluido &Fluidos)
{
   int book = 0;
   
   return book;
}

//+------------------------------------------------------------------+
//| 5.21 - FUNCAO QUE CALCULA O BOOK VENDA BACKTEST                  |
//+------------------------------------------------------------------+
int CalculaKVBacktest(fluido &Fluidos)
{
   int book = 0;
   
   return book;
}

//+------------------------------------------------------------------+
//| 5.22 - FUNCAO QUE CALCULA A MEDIA DE PRECOS                       |
//+------------------------------------------------------------------+
void GetPrecosPassados(MqlTick &ArrayTick[], double &precos[], int T)
{
   if(CopyTicks(Symbol(),ArrayTick,COPY_TICKS_TRADE,0,T) != -1)
   {
      ArraySetAsSeries(ArrayTick,true);
      for(int i=0;i<ArraySize(ArrayTick);i++)
      {
         precos[i] = ArrayTick[i].last;
      }
   }
   else
   {
      Print("Falha ao obter o ArrayTick, falha para GetPrecosPassados");
   }
   
   return;
}


//+------------------------------------------------------------------+
//| 5.15 - FUNCAO QUE CALCULA O h(t,q) do SpreadBuy                  |
//+------------------------------------------------------------------+
double CalculaHCmais1(fluido &Fluidos, int q, int n)
{
   double h = 0.0;
   double exp1 = 0.0;
   double exp2 = 0.0;
   Fluidos.eC = Fluidos.tickMin/2;
   Fluidos.eV = Fluidos.tickMin/2;
   
   exp1 = (pow((Fluidos.lambdaV*exp(-1-(Fluidos.KC*Fluidos.eC))),n)/Fatorial(n))  *  (pow(Fluidos.TOe,n)/Fatorial(n));
   exp2 = exp( -Fluidos.c*Fluidos.KC*pow(q,2) ); 
   
   h = (1/Fluidos.KC) * log(1 + (exp1 * exp2));
   return h;
}
 
//+------------------------------------------------------------------+
//| 5.16 - FUNCAO QUE CALCULA O h(t,q) do SpreadSell                 |
//+------------------------------------------------------------------+
double CalculaHVmenos1(fluido &Fluidos, int q, int n)
{
   double h = 0.0;
   double exp1 = 0.0;
   double exp2 = 0.0;
   Fluidos.eC = Fluidos.tickMin/2;
   Fluidos.eV = Fluidos.tickMin/2;
   
   exp1 = (pow((Fluidos.lambdaC*exp(-1-(Fluidos.KV*Fluidos.eV))),n)/Fatorial(n))  *  (pow(Fluidos.TOe,n)/Fatorial(n));
   exp2 = exp( -Fluidos.c*Fluidos.KV*pow(q,2) ); 
   
   h = (1/Fluidos.KV) * log(1 + (exp1 * exp2));
   return h;
}

//+------------------------------------------------------------------+
//| 5.18 - FUNCAO QUE CALCULA FATORIAL                               |
//+------------------------------------------------------------------+
int Fatorial(int n)
{
   int fatorial = 0;
   for(int i = n; i>0 ; i--)
   {
      if(i == n)
      {
         fatorial = i;
      }
      else
      {
         fatorial = fatorial * i;
      }
   }
   return fatorial;
}

//+===================================================================================================================================================================================+
//| FIM DO PROGRAMA                                                                                                   
//+===================================================================================================================================================================================+


////+------------------------------------------------------------------+
////| 5.16 - FUNCAO QUE CALCULA O h(t,q) do SpreadBuy                  |
////+------------------------------------------------------------------+
//double CalculaHC(fluido &Fluidos, int q)
//{
//   double h = 0.0;
//    
//   h = (Fluidos.lambdaV / Fluidos.KC) * log10(exp( -Fluidos.fi*Fluidos.KC*pow(q,2) * pow(((Fluidos.Td-Fluidos.td)/(Fluidos.Td-Fluidos.t0d)),0.125) ) * exp( -Fluidos.alpha*Fluidos.KC*pow(q,2) ) );
//   //pow(((Fluidos.Td-Fluidos.td)/(Fluidos.Td-Fluidos.t0d)),0.125)
//   return h;
//}
// 
////+------------------------------------------------------------------+
////| 5.17 - FUNCAO QUE CALCULA O h(t,q) do SpreadSell                 |
////+------------------------------------------------------------------+
//double CalculaHV(fluido &Fluidos, int q)
//{
//   double h = 0.0;
//   
//   h = (Fluidos.lambdaC / Fluidos.KV) * log10(exp( -Fluidos.fi*Fluidos.KV*pow(q,2) * pow(((Fluidos.Td-Fluidos.td)/(Fluidos.Td-Fluidos.t0d)),0.125) ) * exp( -Fluidos.alpha*Fluidos.KV*pow(q,2) ) ) ;
//   //pow(((Fluidos.Td-Fluidos.td)/(Fluidos.Td-Fluidos.t0d)),0.125)
//   return h;
//}
//
////+------------------------------------------------------------------+
////| 5.17 - FUNCAO QUE CALCULA O ALPHA                                |
////+------------------------------------------------------------------+
//double CalculaAlpha(fluido &Fluidos, operacao &Operacao)
//{
//   double alpha = 0.0;
//   
//   alpha = (Fluidos.dzeta*Fluidos.driftHFTTend) - (Fluidos.eta*Fluidos.aceleracao) + (Fluidos.eC*Fluidos.lambdaC) - (Fluidos.eV*Fluidos.lambdaV);
//   //Print(" 1: ", Fluidos.driftHFTTend, " 2: ", Fluidos.aceleracao, " 3: ", Fluidos.lambdaC*Fluidos.eC, " 4: ",Fluidos.eV*Fluidos.lambdaV);
//   alpha = alpha*100 / Operacao.simbolo.Last();
//   return alpha;
//}