Nachschlagewerk MQL5StandardbibliothekMathematikStatistikNegative Binomial-Verteilung

Negative Binomial-Verteilung

In diesem Abschnitt sind Funktionen für die negative Binomialverteilung beschrieben. Mit diesen Funktionen können Dichte, Wahrscheinlichkeit und Quantile berechnet und Pseudozufallszahlen auf Basis der negativen Binomialverteilung erzeugt werden. Die negative Binomialverteilung wird mit der folgenden Formel berechnet:

wobei:

x — der Wert der Zufallsvariablen

r — Anzahl erfolgreicher Tests

p — Erfolgswahrscheinlichkeit

DemoNegativeBinomial

Man kann sowohl einzelne Zufallsvariablen berechnen, als auch mit Arrays von Zufallsvariablen arbeiten.

Funktion	Beschreibung
MathProbabilityDensityNegativeBinomial	Berechnet den Wert der Wahrscheinlichkeitsdichtefunktion der negativen Binomialverteilung
MathCumulativeDistributionNegativeBinomial	Berechnet den Wert der Wahrscheinlichkeitsverteilung der negativen Binomialverteilung
MathQuantileNegativeBinomial	Berechnet den Wert der Umkehrfunktion der negativen Binomialverteilung für eine angegebene Wahrscheinlichkeit
MathRandomNegativeBinomial	Erzeugt eine Pseudozufallszahl/ein Array für Pseudozufallszahlen auf Basis der negativen Binomialverteilung
MathMomentsNegativeBinomial	Berechnet die theoretischen, numerischen Werte der ersten 4 Momente der negativen Binomialverteilung

Beispiel:

#include <Graphics\Graphic.mqh>
#include <Math\Stat\NegativeBinomial.mqh>
#include <Math\Stat\Math.mqh>
#property script_show_inputs
//--- input parameters
input double n_par=40;        // Anzahl der Tests
input double p_par=0.75;      // Erfolgswahrscheinlichkeit für jeden Test
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Anzeige des Preischarts deaktivieren
   ChartSetInteger(0,CHART_SHOW,false);
//---
   MathSrand(GetTickCount());
//--- Stichprobe einer zufälligen Größe erzeugen
   long chart=0;
   string name="GraphicNormal";
   int n=1000000;       // Anzahl der Werte in der Stichprobe
   int ncells=19;       // Anzahl der Intervalle im Histogramm
   double x[];          // Zentren der Intervalle des Histogramms
   double y[];          // Anzahl der Werte aus der Stichprobe, die innerhalb des Intervalls liegen
   double data[];       // Stichprobe
   double max,min;      // der höchste und der niedrigste Werte in der Stichprobe
//--- Stichprobe aus der negativen Binomialverteilung erhalten
   MathRandomNegativeBinomial(n_par,p_par,n,data);
//--- Daten für das Zeichnen des Histogramms berechnen
   CalculateHistogramArray(data,x,y,max,min,ncells);
//--- theoretisch berechnete Daten im Intervall [min,max] erhalten
   double x2[];
   double y2[];
   MathSequence(0,n_par,1,x2);
   MathProbabilityDensityNegativeBinomial(x2,n_par,p_par,false,y2);
//--- skalieren
   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;
//--- Charts ausgeben
   CGraphic graphic;
   if(ObjectFind(chart,name)<0)
      graphic.Create(chart,name,0,0,0,780,380);
   else
      graphic.Attach(chart,name);
   graphic.BackgroundMain(StringFormat("Negative Binomial distributionn n=%G p=%G",n_par,p_par));
   graphic.BackgroundMainSize(16);
//--- plot all curves
   graphic.CurveAdd(x,y,CURVE_HISTOGRAM,"Sample").HistogramWidth(6);
//--- und nun die theoretische Kurve der Verteilungsdichte zeichnen
   graphic.CurveAdd(x2,y2,CURVE_LINES,"Theory").LinesSmooth(true);
   graphic.CurvePlotAll();
//--- plot all curves
   graphic.Update();
  }
//+------------------------------------------------------------------+
//|  Calculate frequencies for data set                              |
//+------------------------------------------------------------------+
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);
//--- Zentren der Intervalle setzen
   for(int i=0; i<cells; i++)
     {
      intervals[i]=minv+(i+0.5)*width;
      frequency[i]=0;
     }
//--- Frequenzen des Auftretens innerhalb des Intervalls füllen
   for(int i=0; i<size; i++)
     {
      int ind=int((data[i]-minv)/width);
      if(ind>=cells) ind=cells-1;
      frequency[ind]++;
     }
   return (true);
  }

MathMomentsBinomial

MathProbabilityDensityNegativeBinomial