Distribuzione beta non centrale

Questa sezione contiene le funzioni per lavorare con distribuzione beta non centrale. Esse consentono di calcolare densità, probabilità, quantili e di generare numeri pseudo casuali distribuiti secondo la legge corrispondente. La distribuzione beta non centrale è definita dalla seguente formula:

pdf_noncentral_beta_distribution

dove:

  • x — valore della variabile casuale
  • a — il primo parametro della distribuzione beta
  • b — il secondo parametro della distribuzione beta
  • λ — parametro di non centralità

DemoNoncentralBeta

Oltre al calcolo delle singole variabili casuali, la libreria implementa anche la capacità di lavorare con array di variabili casuali.  

Funzione

Descrizione

MathProbabilityDensityNoncentralBeta

Calcola la funzione di densità di probabilità della distribuzione beta non centrale

MathCumulativeDistributionNoncentralBeta

Calcola il valore della funzione di distribuzione di probabilità non centrale beta

MathQuantileNoncentralBeta

Calcola il valore della funzione di distribuzione beta non centrale inversa per la probabilità specificata

MathRandomNoncentralBeta

Genera una variabile/array di variabili pseudocasuali distribuite secondo la legge di distribuzione beta non centrale

MathMomentsNoncentralBeta

Calcola i valori numerici teoriche dei primi 4 momenti della distribuzione beta non centrale

Esempio:

#include <Graphics\Graphic.mqh>
#include <Math\Stat\NoncentralBeta.mqh>
#include <Math\Stat\Math.mqh>
#property script_show_inputs
//--- parametri di input
input double a_par=2;    // il primo parametro della distribuzione beta (shape1)
input double b_par=5;    // il secondo parametro della distribuzione beta (shape2)
input double l_par=1;    // parametro di non centralità (lambda)
//+------------------------------------------------------------------+
//| 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=53;       // 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 beta non centrale
   MathRandomNoncentralBeta(a_par,b_par,l_par,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);
   MathProbabilityDensityNoncentralBeta(x2,a_par,b_par,l_par,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("Noncentral Beta distribution alpha=%G beta=%G lambda=%G",
                          a_par,b_par,l_par));
   graphic.BackgroundMainSize(16);
//--- 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.;
  }