Cauchy-Verteilung

In diesem Abschnitt sind Funktionen der Cauchy-Verteilung beschrieben. Mit diesen Funktionen können Dichte, Wahrscheinlichkeit und Quantile berechnet und Pseudozufallszahlen auf Basis der Cauchy-Verteilung erzeugt werden. Die Cauchy-Verteilung wird mit der folgenden Formal beschrieben:

pdf_cauchy_distribution

wobei:

  • x — der Wert der Zufallsvariablen
  • a —  mean Parameter der Verteilung
  • b — scale Parameter der Verteilung

 

DemoCauchyDistribution

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

Funktion

Beschreibung

MathProbabilityDensityCauchy

Berechnet den Wert der Wahrscheinlichkeitsdichtefunktion der Cauchy-Verteilung

MathCumulativeDistributionCauchy

Berechnet den Wert der Wahrscheinlichkeitsverteilung der Cauchy-Verteilung

MathQuantileCauchy

Berechnet den Wert der Umkehrfunktion der Cauchy-Verteilung für eine angegebene Wahrscheinlichkeit

MathRandomCauchy

Erzeugt eine Pseudozufallszahl/ein Array für Pseudozufallszahlen auf Basis der Cauchy-Verteilung

MathMomentsCauchy

Berechnet die theoretischen, numerischen Werte der ersten 4 Momente der Cauchy-Verteilung

Beispiel:

#include <Graphics\Graphic.mqh>
#include <Math\Stat\Cauchy.mqh>
#include <Math\Stat\Math.mqh>
#property script_show_inputs
//--- input parameters
input double a_par=-2;      // Parameter der Verteilung mean
input double b_par=1;       // Parameter der Verteilung scale
//+------------------------------------------------------------------+
//| 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=51;       // 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 Cauchy-Verteilung erhalten
   MathRandomCauchy(a_par,b_par,n,data);
//--- Daten für das Zeichnen des Histogramms berechnen
   CalculateHistogramArray(data,x,y,max,min,ncells);
//--- Grenzen der Sequenz und Schritt für das Zeichnen einer theoretischen Kurve erhalten
   double step;
   GetMaxMinStepValues(max,min,step);
   step=MathMin(step,(max-min)/ncells);
//--- theoretisch berechnete Daten im Intervall [min,max] erhalten
   double x2[];
   double y2[];
   MathSequence(min,max,step,x2);
   MathProbabilityDensityCauchy(x2,a_par,b_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("Cauchy distribution a=%G b=%G",a_par,b_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");
   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)];
   Print("min=",minv," max=",maxv);
   minv=-20;
   maxv=20;
   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*width;
      frequency[i]=0;
     }
//--- Frequenzen des Auftretens innerhalb des Intervalls füllen
   for(int i=0; i<size; i++)
     {
      int ind=(int)MathRound((data[i]-minv)/width);
      if(ind>=0 && ind<cells)
         frequency[ind]++;
     }
   return(true);
  }
//+------------------------------------------------------------------+
//|  Calculates values for sequence generation                       |
//+------------------------------------------------------------------+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
  {
//--- die absolute Spannweite der Sequenz berechnen, um die Genauigkeit der Normalisierung zu erhalten
   double range=MathAbs(maxv-minv);
   int degree=(int)MathRound(MathLog10(range));
//--- den höchsten und den niedrigsten Wert mit der angegebenen Genauigkeit normalisieren
   maxv=NormalizeDouble(maxv,degree);
   minv=NormalizeDouble(minv,degree);
//--- den Schritt der Erzeugung einer Sequenz auch basierend auf der angegebenen Genauigkeit setzen
   stepv=NormalizeDouble(MathPow(10,-degree),degree);
   if((maxv-minv)/stepv<10)
      stepv/=10.;
  }