Distribuzione log-normale

#include <Graphics\Graphic.mqh>
#include <Math\Stat\Lognormal.mqh>
#include <Math\Stat\Math.mqh>
#property script_show_inputs
//--- parametri di input
input double mean_value=1.0;  // logaritmo di un valore atteso (log mean)
input double std_dev=0.25;    // logaritmo della deviazione della radice-quadatica-media (log standard deviation)
//+------------------------------------------------------------------+
//| Funzione start del programma Script                              |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- nascondere il grafico(chart) dei prezzi
   ChartSetInteger(0,CHART_SHOW,false);
//--- inizializza il generatore di numeri casuali  
   MathSrand(GetTickCount());
//--- genera un esempio della variabile casuale
   long chart=0;
   string name="GraphicNormal";
   int n=1000000;       // il numero di valori nell'esempio
   int ncells=51;       // il numero di intervalli nell'istogramma
   double x[];          // centro degli intervalli dell'istogramma
   double y[];          // il numero di valori dall'esempio che cade all'interno dell'intervallo
   double data[];       // esempio di valori casuali
   double max,min;      // i valori massimo e minimo nell'esempio
//--- ottiene un campione dalla distribuzione log-normale
   MathRandomLognormal(mean_value,std_dev,n,data);
//--- calcolare i dati per tracciare l'istogramma
   CalculateHistogramArray(data,x,y,max,min,ncells);
// --- ottenere i confini sequenza e la fase di determinazione del disegnamento della curva teorica
   double step;
   GetMaxMinStepValues(max,min,step);
   step=MathMin(step,(max-min)/ncells);   
/ --- ottiene i dati teoricamente calcolati in base all'intervallo di [min, max]
   double x2[];
   double y2[];
   MathSequence(min,max,step,x2);
   MathProbabilityDensityLognormal(x2,mean_value,std_dev,false,y2);
//--- imposta la scala
   double theor_max=y2[ArrayMaximum(y2)];
   double sample_max=y[ArrayMaximum(y)];
   double k=sample_max/theor_max;
   for(int i=0; i<ncells; i++)
      y[i]/=k;
//--- output charts
   CGraphic graphic;
   if(ObjectFind(chart,name)<0)
      graphic.Create(chart,name,0,0,0,780,380);
   else
      graphic.Attach(chart,name);
   graphic.BackgroundMain(StringFormat("Lognormal distribution mu=%G sigma=%G",mean_value,std_dev));
   graphic.BackgroundMainSize(16);
//--- disabilita la scalatura automatica dell'asse Y
   graphic.YAxis().AutoScale(false);
   graphic.YAxis().Max(theor_max);
   graphic.YAxis().Min(0);   
//--- disegna tutte le curve
   graphic.CurveAdd(x,y,CURVE_HISTOGRAM,"Sample").HistogramWidth(6);
//--- e ora tracciare la curva teorica della densità di distribuzione
   graphic.CurveAdd(x2,y2,CURVE_LINES,"Theory");
   graphic.CurvePlotAll();
//--- disegna tutte le curve
   graphic.Update();
  }
//+------------------------------------------------------------------+
//| Calcolare le frequenze per set di dati                           |
//+------------------------------------------------------------------+
bool CalculateHistogramArray(const double &data[],double &intervals[],double &frequency[],
                             double &maxv,double &minv,const int cells=10)
  {
   if(cells<=1) return (false);
   int size=ArraySize(data);
   if(size<cells*10) return (false);
   minv=data[ArrayMinimum(data)];
   maxv=data[ArrayMaximum(data)];
   double range=maxv-minv;
   double width=range/cells;
   if(width==0) return false;
   ArrayResize(intervals,cells);
   ArrayResize(frequency,cells);
//--- definire il centro dell'intervallo
   for(int i=0; i<cells; i++)
     {
      intervals[i]=minv+(i+0.5)*width;
      frequency[i]=0;
     }
//--- riempie le frequenze di caduta all'interno dell'intervallo
   for(int i=0; i<size; i++)
     {
      int ind=int((data[i]-minv)/width);
      if(ind>=cells) ind=cells-1;
      frequency[ind]++;
     }
   return (true);
  }
//+------------------------------------------------------------------+
//| Calcola i valori per la generazione di sequenze                  |
//+------------------------------------------------------------------+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
  {
//--- calcola il range assoluto della sequenza per ottenere la precisione di normalizzazione
   double range=MathAbs(maxv-minv);
   int degree=(int)MathRound(MathLog10(range));
//--- normalizza i valori massimi e minimi alla precisione specificata
   maxv=NormalizeDouble(maxv,degree);
   minv=NormalizeDouble(minv,degree);
//--- la fase di generazione di sequenza viene inoltre impostata in base alla precisione specificata
   stepv=NormalizeDouble(MathPow(10,-degree),degree);
   if((maxv-minv)/stepv<10)
      stepv/=10.;
  }