統計

#include <GraphicsGraphic.mqh>
#include <MathStatNormal.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double mean_value=0; // 期待値（平均）
input double std_dev=1;     // 二乗平均平方根偏差（標準偏差）
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 正規分布からサンプルを取得する
MathRandomNormal(mean_value,std_dev,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityNormal(x2,mean_value,std_dev,false,y2);
//— 規模を設定する
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;
//— チャートを出力する    
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Normal distribution mu=%G sigma=%G”,mean_value,std_dev));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
//— カーブをプロットする
graphic.CurvePlotAll();
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatLognormal.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double mean_value=1.0; // 期待値の対数（対数平均）
input double std_dev=0.25;   // 二乗平均平方根偏差の対数（対数標準偏差）
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 対数正規分布からサンプルを取得する
MathRandomLognormal(mean_value,std_dev,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityLognormal(x2,mean_value,std_dev,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
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);
//— Y軸の自動スケーリングを無効にする
graphic.YAxis().AutoScale(false);
graphic.YAxis().Max(theor_max);
graphic.YAxis().Min(0);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatBeta.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double alpha=2;   // ベータ分布の1番目のパラメータ（形状1）
input double beta=5;   // ベータ分布の2番目のパラメータ （形状2）
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— ベータ分布からサンプルを取得す
MathRandomBeta(alpha,beta,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityBeta(x2,alpha,beta,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Beta distribution alpha=%G beta=%G”,alpha,beta));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatNoncentralBeta.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double a_par=2;   // ベータ分布の1番目のパラメータ（形状1）
input double b_par=5;   // ベータ分布の2番目のパラメータ （形状2）
input double l_par=1;   // 非心パラメータ (lambda)
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=53;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 非心ベータ分布からサンプルを取得す
MathRandomNoncentralBeta(a_par,b_par,l_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityNoncentralBeta(x2,a_par,b_par,l_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
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);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatGamma.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double alpha=9;   // 分布の1番目のパラメータ（形状）
input double beta=0.5; // 分布の2番目のパラメータ（スケール）
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— ガンマ分布からサンプルを取得する
MathRandomGamma(alpha,beta,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityGamma(x2,alpha,beta,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Gamma distribution alpha=%G beta=%G”,alpha,beta));
graphic.BackgroundMainSize(16);
//— Y軸の自動スケーリングを無効にする
graphic.YAxis().AutoScale(false);
graphic.YAxis().Max(NormalizeDouble(theor_max,1));
graphic.YAxis().Min(0);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatChiSquare.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double nu_par=5;   // 自由度の数
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— カイ2乗分布からサンプルを取得する
MathRandomChiSquare(nu_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityChiSquare(x2,nu_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“ChiSquare distribution nu=%G “,nu_par));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatNoncentralChiSquare.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double nu_par=8;   // 自由度の数
input double si_par=1;   // 非心パラメータ
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 非新カイ2乗分布からサンプルを取得する
MathRandomNoncentralChiSquare(nu_par,si_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityNoncentralChiSquare(x2,nu_par,si_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
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 ChiSquare distribution nu=%G sigma=%G”,nu_par,si_par));
graphic.BackgroundMainSize(16);
//— Y軸の自動スケーリングを無効にする
graphic.XAxis().AutoScale(false);
graphic.XAxis().Max(NormalizeDouble(max,0));
graphic.XAxis().Min(min);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatExponential.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double mu_par=1.5;   // 自由度の数
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 指数分布からサンプルを取得する
MathRandomExponential(mu_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityExponential(x2,mu_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Exponential distribution mu=%G “,mu_par));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+i*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatF.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double nu_1=100;   // 1番目の自由度の数
input double nu_2=100;   // 2番目の自由度の数
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— フィッシャーのF分布からサンプルを取得する
MathRandomF(nu_1,nu_2,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityF(x2,nu_1,nu_2,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“F-distribution nu1=%G nu2=%G”,nu_1,nu_2));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(4);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatNoncentralF.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double nu_1=20;   // 1番目の自由度の数
input double nu_2=20;   // 2番目の自由度の数
input double sig=10;     // 非心パラメータ
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— フィッシャーのF分布からサンプルを取得する
MathRandomNoncentralF(nu_1,nu_2,sig,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityNoncentralF(x2,nu_1,nu_2,sig,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
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 F-distribution nu1=%G nu2=%G sigma=%G”,nu_1,nu_2,sig));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatT.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double nu_par=10;   // 自由度の数
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— スチューデントのt分布からサンプルを取得する
MathRandomT(nu_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityT(x2,nu_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“t-distribution nu=%G”,nu_par));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatNoncentralT.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double nu_par=30;     // 自由度の数
input double delta_par=5;   // 非心パラメータ
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 非心t分布からサンプルを取得する
MathRandomNoncentralT(nu_par,delta_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityNoncentralT(x2,nu_par,delta_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
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 t-distribution nu=%G delta=%G”,nu_par,delta_par));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatLogistic.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double mu_par=6;       // 分布の平均パラメータ
input double sigma_par=2;     // 分布のスケールパラメータ
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— ロジスティク分布からサンプルを取得する
MathRandomLogistic(mu_par,sigma_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityLogistic(x2,mu_par,sigma_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Logistic distribution mu=%G sigma=%G”,mu_par,sigma_par));
graphic.BackgroundMainSize(16);
//— Y軸の自動スケーリングを無効にする
graphic.YAxis().AutoScale(false);
graphic.YAxis().Max(theor_max);
graphic.YAxis().Min(0);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatCauchy.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double a_par=-2;     // 分布の平均パラメータ
input double b_par=1;       // 分布のスケールパラメータ
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— コーシー分布からサンプルを取得する
MathRandomCauchy(a_par,b_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityCauchy(x2,a_par,b_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
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);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+i*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=(int)MathRound((data[i]-minv)/width);
if(ind>=0 && ind<cells)
frequency[ind]++;
}
return(true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatUniform.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double a_par=0;     // 分布のパラメータa（下限）
input double b_par=10;     // 分布のパラメータb（上限）
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 一様分布からサンプルを取得する
MathRandomUniform(a_par,b_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityUniform(x2,a_par,b_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Uniform distribution a=%G b=%G”,a_par,b_par));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatWeibull.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double a_par=1;     // 分布のパラメータ（形状）
input double b_par=5;     // 分布のパラメータ（スケール）
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=51;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— ワイブル分布からサンプルを取得する
MathRandomWeibull(a_par,b_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
step=MathMin(step,(max-min)/ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(min,max,step,x2);
MathProbabilityDensityWeibull(x2,a_par,b_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Weibull distribution a=%G b=%G”,a_par,b_par));
graphic.BackgroundMainSize(16);
//— Y軸の自動スケーリングを無効にする
graphic.XAxis().AutoScale(false);
graphic.XAxis().Max(max);
graphic.XAxis().Min(min);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+i*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatBinomial.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double n_par=40;       // テスト数
input double p_par=0.75;     // 各テストの成功率
//+——————————————————————+
//| スクリプトプログラムを開始する関数                        |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=20;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 二項分布からサンプルを取得する
MathRandomBinomial(n_par,p_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(0,n_par,1,x2);
MathProbabilityDensityBinomial(x2,n_par,p_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Binomial distributionn n=%G p=%G”,n_par,p_par));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”).LinesSmooth(true);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}

#include <GraphicsGraphic.mqh>
#include <MathStatNegativeBinomial.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double n_par=40;       // テスト数
input double p_par=0.75;     // 各テストの成功率
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=19;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 負の二項分布からサンプルを取得する
MathRandomNegativeBinomial(n_par,p_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(0,n_par,1,x2);
MathProbabilityDensityNegativeBinomial(x2,n_par,p_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
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);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”).LinesSmooth(true);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}

#include <GraphicsGraphic.mqh>
#include <MathStatGeometric.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double p_par=0.2;     // 1回のテストでのイベント発生率
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=47;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 幾何分布からサンプルを取得する
MathRandomGeometric(p_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
PrintFormat(“max=%G min=%G”,max,min);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(0,ncells,1,x2);
MathProbabilityDensityGeometric(x2,p_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Geometric distribution p=%G”,p_par));
graphic.BackgroundMainSize(16);
//— Y軸の自動スケーリングを無効にする
graphic.XAxis().AutoScale(false);
graphic.XAxis().Max(max);
graphic.XAxis().Min(min);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+i*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatHypergeometric.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double m_par=60;     // オブジェクトの総数
input double k_par=30;     // 所望の特性を有するオブジェクトの数
input double n_par=30;     // オブジェクト描画の数
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=1000000;       // サンプルの値の数
int ncells=15;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— 超幾何分布からサンプルを取得する
MathRandomHypergeometric(m_par,k_par,n_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
PrintFormat(“max=%G min=%G”,max,min);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(0,n_par,1,x2);
MathProbabilityDensityHypergeometric(x2,m_par,k_par,n_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Hypergeometric distribution m=%G k=%G n=%G”,m_par,k_par,n_par));
graphic.BackgroundMainSize(16);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”).LinesSmooth(true);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}

#include <GraphicsGraphic.mqh>
#include <MathStatPoisson.mqh>
#include <MathStatMath.mqh>
#property script_show_inputs
//— 入力パラメータ
input double lambda_par=10;     // 分布のパラメータ（平均）
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
void OnStart()
{
//— 価格チャートを非表示にする
ChartSetInteger(0,CHART_SHOW,false);
//— 擬似乱数生成器を初期化する  
MathSrand(GetTickCount());
//— 確率変数のサンプルを生成する
long chart=0;
string name=“GraphicNormal”;
int n=100000;       // サンプルの値の数
int ncells=13;       // ヒストグラムの間隔の数
double x[];         // ヒストグラム間隔の中心
double y[];         // 間隔内のサンプルからの値の数
double data[];       // 確率変数値のサンプル
double max,min;     // サンプルの最大値と最小値
//— ポアソン分布からサンプルを取得する
MathRandomPoisson(lambda_par,n,data);
//— ヒストグラムをプロットするためのデータを計算する
CalculateHistogramArray(data,x,y,max,min,ncells);
//— 理論曲線をプロットするシーケンス境界とステップを取得する
double step;
GetMaxMinStepValues(max,min,step);
PrintFormat(“max=%G min=%G”,max,min);
//— [min、max]の間隔で理論的に計算されたデータを取得する
double x2[];
double y2[];
MathSequence(0,int(MathCeil(max)),1,x2);
MathProbabilityDensityPoisson(x2,lambda_par,false,y2);
//— 規模を設定する
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;
//— チャートを出力する
CGraphic graphic;
if(ObjectFind(chart,name)<0)
graphic.Create(chart,name,0,0,0,780,380);
else
graphic.Attach(chart,name);
graphic.BackgroundMain(StringFormat(“Poisson distribution lambda=%G”,lambda_par));
graphic.BackgroundMainSize(16);
//— Y軸の自動スケーリングを無効にする
graphic.YAxis().AutoScale(false);
graphic.YAxis().Max(NormalizeDouble(theor_max,2));
graphic.YAxis().Min(0);
//— カーブをプロットする
graphic.CurveAdd(x,y,CURVE_HISTOGRAM,“Sample”).HistogramWidth(6);
//— 今度は分布密度の理論曲線をプロットする
graphic.CurveAdd(x2,y2,CURVE_LINES,“Theory”).LinesSmooth(true);
graphic.CurvePlotAll();
//— カーブをプロットする
graphic.Update();
}
//+——————————————————————+
//|  データセットの頻度を計算する                                            |
//+——————————————————————+
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);
//— 間隔の中心を定義する
for(int i=0; i<cells; i++)
{
intervals[i]=minv+(i+0.5)*width;
frequency[i]=0;
}
//— 間隔内に入る頻度を記入する
for(int i=0; i<size; i++)
{
int ind=int((data[i]-minv)/width);
if(ind>=cells) ind=cells-1;
frequency[ind]++;
}
return (true);
}
//+——————————————————————+
//|  シーケンス生成の値を計算する                                           |
//+——————————————————————+
void GetMaxMinStepValues(double &maxv,double &minv,double &stepv)
{
//— 正規化の精度を得るためにシーケンスの絶対範囲を計算する
double range=MathAbs(maxv-minv);
int degree=(int)MathRound(MathLog10(range));
//— 最大値と最小値を指定された精度に正規化する
maxv=NormalizeDouble(maxv,degree);
minv=NormalizeDouble(minv,degree);
//— 指定された精度に基づいてシーケンス生成ステップも設定される
stepv=NormalizeDouble(MathPow(10,-degree),degree);
if((maxv-minv)/stepv<10)
stepv/=10.;
}