mobinzkr/MobinMQL
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
MobinMQL/Scripts/UnitTests/Stat/TestStatBenchmark.mq5

1591 lines
55 KiB
MQL5
Raw Permalink Normal View History

Init
2025-07-22 14:48:34 +03:00
//+------------------------------------------------------------------+
//| TestStatBenchmark.mq5 |
//| Copyright 2000-2025, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2000-2025, MetaQuotes Ltd."
#property link "https://www.mql5.com"
#property version "1.00"
#include <Math\Stat\Math.mqh>
#include <Math\Stat\Binomial.mqh>
#include <Math\Stat\Beta.mqh>
#include <Math\Stat\Gamma.mqh>
#include <Math\Stat\Cauchy.mqh>
#include <Math\Stat\Exponential.mqh>
#include <Math\Stat\Uniform.mqh>
#include <Math\Stat\Geometric.mqh>
#include <Math\Stat\Hypergeometric.mqh>
#include <Math\Stat\Logistic.mqh>
#include <Math\Stat\Weibull.mqh>
#include <Math\Stat\Poisson.mqh>
#include <Math\Stat\F.mqh>
#include <Math\Stat\ChiSquare.mqh>
#include <Math\Stat\NoncentralChiSquare.mqh>
#include <Math\Stat\NoncentralF.mqh>
#include <Math\Stat\NoncentralBeta.mqh>
#include <Math\Stat\NegativeBinomial.mqh>
#include <Math\Stat\T.mqh>
#include <Math\Stat\NoncentralT.mqh>
#include <Math\Stat\Normal.mqh>
#include <Math\Stat\Lognormal.mqh>
//+------------------------------------------------------------------+
//| Structure for benchmark information |
//+------------------------------------------------------------------+
struct benchmark_info
{
//--- propability density calculation times
double pdf_time_min;
double pdf_time_max;
double pdf_time_mean;
double pdf_time_median;
double pdf_time_stddev;
double pdf_time_avgdev;
//--- cumulative distribution calculation times
double cdf_time_min;
double cdf_time_max;
double cdf_time_mean;
double cdf_time_median;
double cdf_time_stddev;
double cdf_time_avgdev;
//--- quantile calculation times
double quantile_time_min;
double quantile_time_max;
double quantile_time_mean;
double quantile_time_median;
double quantile_time_stddev;
double quantile_time_avgdev;
//--- random variable calculation times
double random_time_min;
double random_time_max;
double random_time_mean;
double random_time_median;
double random_time_stddev;
double random_time_avgdev;
};
#define AverageCount 1000
//+------------------------------------------------------------------+
//| ShowBenchmarkInfo |
//+------------------------------------------------------------------+
void ShowBenchmarkInfo(const string test_info,benchmark_info &benchmark)
{
PrintFormat("%s time (microseconds): pdf_mean=%4.2f, pdf_median=%4.2f, pdf_min=%4.2f, pdf_max=%4.2f, pdf_stddev=%4.2f, pdf_avgdev=%4.2f",
test_info,benchmark.pdf_time_mean,benchmark.pdf_time_median,benchmark.pdf_time_min,benchmark.pdf_time_max,benchmark.pdf_time_stddev,benchmark.pdf_time_avgdev);
PrintFormat("%s time (microseconds): cdf_mean=%4.2f, cdf_median=%4.2f, cdf_min=%4.2f, cdf_max=%4.2f, cdf_stddev=%4.2f, cdf_avgdev=%4.2f",
test_info,benchmark.cdf_time_mean,benchmark.cdf_time_median,benchmark.cdf_time_min,benchmark.cdf_time_max,benchmark.cdf_time_stddev,benchmark.cdf_time_avgdev);
PrintFormat("%s time (microseconds): quantile_mean=%4.2f, quantile_median=%4.2f, quantile_min=%4.2f, quantile_max=%4.2f, quantile_stddev=%4.2f, quantile_avgdev=%4.2f",
test_info,benchmark.quantile_time_mean,benchmark.quantile_time_median,benchmark.quantile_time_min,benchmark.quantile_time_max,benchmark.quantile_time_stddev,benchmark.quantile_time_avgdev);
PrintFormat("%s time (microseconds): random_mean=%4.2f, random_median=%4.2f, random_min=%4.2f, random_max=%4.2f, random_stddev=%4.2f, random_avgdev=%4.2f",
test_info,benchmark.random_time_mean,benchmark.random_time_median,benchmark.random_time_min,benchmark.random_time_max,benchmark.random_time_stddev,benchmark.random_time_avgdev);
}
//+------------------------------------------------------------------+
//| CalculateStatisticalProperties |
//+------------------------------------------------------------------+
void CalculateStatisticalProperties(benchmark_info &benchmark,double &pdf_times[],double &cdf_times[],double &quantile_times[],double &random_times[])
{
//--- calculate statistical properties for calculation time: min,max,mean,median,standard and average deviations
//--- probability density
benchmark.pdf_time_min=MathMin(pdf_times);
benchmark.pdf_time_max=MathMax(pdf_times);
benchmark.pdf_time_mean=MathMean(pdf_times);
benchmark.pdf_time_median=MathMedian(pdf_times);
benchmark.pdf_time_stddev=MathStandardDeviation(pdf_times);
benchmark.pdf_time_avgdev=MathAverageDeviation(pdf_times);
//--- cumulative distribution
benchmark.cdf_time_min=MathMin(cdf_times);
benchmark.cdf_time_max=MathMax(cdf_times);
benchmark.cdf_time_mean=MathMean(cdf_times);
benchmark.cdf_time_median=MathMedian(cdf_times);
benchmark.cdf_time_stddev=MathStandardDeviation(cdf_times);
benchmark.cdf_time_avgdev=MathAverageDeviation(cdf_times);
//--- quantile
benchmark.quantile_time_min=MathMin(quantile_times);
benchmark.quantile_time_max=MathMax(quantile_times);
benchmark.quantile_time_mean=MathMean(quantile_times);
benchmark.quantile_time_median=MathMedian(quantile_times);
benchmark.quantile_time_stddev=MathStandardDeviation(quantile_times);
benchmark.quantile_time_avgdev=MathAverageDeviation(quantile_times);
//--- random values
benchmark.random_time_min=MathMin(random_times);
benchmark.random_time_max=MathMax(random_times);
benchmark.random_time_mean=MathMean(random_times);
benchmark.random_time_median=MathMedian(random_times);
benchmark.random_time_stddev=MathStandardDeviation(random_times);
benchmark.random_time_avgdev=MathAverageDeviation(random_times);
return;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkBinomial |
//+------------------------------------------------------------------+
bool CalculateBenchmarkBinomial(benchmark_info &benchmark_binomial,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Binomial distribution parameters
const int N=50;
const double probability=0.1;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0;
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityBinomial(x_values,N,probability,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionBinomial(x_values,N,probability,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileBinomial(cdf_values,N,probability,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomBinomial(N,probability,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_binomial,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkBeta |
//+------------------------------------------------------------------+
bool CalculateBenchmarkBeta(benchmark_info &benchmark_beta,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Beta distribution parameters
const double a=2.0;
const double b=4.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityBeta(x_values,a,b,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionBeta(x_values,a,b,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileBeta(cdf_values,a,b,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomBeta(a,b,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_beta,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkGamma |
//+------------------------------------------------------------------+
bool CalculateBenchmarkGamma(benchmark_info &benchmark_gamma,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Gamma distribution parameters
const double a=1.0;
const double b=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityGamma(x_values,a,b,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionGamma(x_values,a,b,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileGamma(cdf_values,a,b,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomGamma(a,b,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_gamma,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkCauchy |
//+------------------------------------------------------------------+
bool CalculateBenchmarkCauchy(benchmark_info &benchmark_cauchy,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Cauchy distribution parameters
const double a=2.0;
const double b=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityCauchy(x_values,a,b,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionCauchy(x_values,a,b,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileCauchy(cdf_values,a,b,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomCauchy(a,b,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_cauchy,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkExponential |
//+------------------------------------------------------------------+
bool CalculateBenchmarkExponential(benchmark_info &benchmark_exponential,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Exponential distribution parameters
const double mu=2.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityExponential(x_values,mu,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionExponential(x_values,mu,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileExponential(cdf_values,mu,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomExponential(mu,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_exponential,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkUniform |
//+------------------------------------------------------------------+
bool CalculateBenchmarkUniform(benchmark_info &benchmark_uniform,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Uniform distribution parameters
const double a=0.0;
const double b=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityUniform(x_values,a,b,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionUniform(x_values,a,b,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileUniform(cdf_values,a,b,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomUniform(a,b,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_uniform,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkGeometric |
//+------------------------------------------------------------------+
bool CalculateBenchmarkGeometric(benchmark_info &benchmark_geometric,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Geometric distribution parameters
const double prob=0.3;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0;
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityGeometric(x_values,prob,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionGeometric(x_values,prob,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileGeometric(cdf_values,prob,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomGeometric(prob,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_geometric,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkHypergeometric |
//+------------------------------------------------------------------+
bool CalculateBenchmarkHypergeometric(benchmark_info &benchmark_hypergeometric,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Hypergeometric distribution parameters
const double m=50;
const double k=11;
const double n=12;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0;
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityHypergeometric(x_values,m,k,n,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionHypergeometric(x_values,m,k,n,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileHypergeometric(cdf_values,m,k,n,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomHypergeometric(m,k,n,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_hypergeometric,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkLogistic |
//+------------------------------------------------------------------+
bool CalculateBenchmarkLogistic(benchmark_info &benchmark_logistic,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Logistic distribution parameters
const double mu=1.0;
const double sigma=2.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityLogistic(x_values,mu,sigma,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionLogistic(x_values,mu,sigma,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileLogistic(cdf_values,mu,sigma,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomLogistic(mu,sigma,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_logistic,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkWeibull |
//+------------------------------------------------------------------+
bool CalculateBenchmarkWeibull(benchmark_info &benchmark_weibull,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Weibull distribution parameters
const double a=5.0;
const double b=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityWeibull(x_values,a,b,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionWeibull(x_values,a,b,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileWeibull(cdf_values,a,b,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomWeibull(a,b,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_weibull,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkPoisson |
//+------------------------------------------------------------------+
bool CalculateBenchmarkPoisson(benchmark_info &benchmark_poisson,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Poisson distribution parameters
const double lambda=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0;
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityPoisson(x_values,lambda,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionPoisson(x_values,lambda,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantilePoisson(cdf_values,lambda,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomPoisson(lambda,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_poisson,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkF |
//+------------------------------------------------------------------+
bool CalculateBenchmarkF(benchmark_info &benchmark_f,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- F distribution parameters
const double nu1=10.0;
const double nu2=20.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityF(x_values,nu1,nu2,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionF(x_values,nu1,nu2,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileF(cdf_values,nu1,nu2,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomF(nu1,nu2,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_f,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkChiSquare |
//+------------------------------------------------------------------+
bool CalculateBenchmarkChiSquare(benchmark_info &benchmark_chisquare,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- ChiSquare distribution parameters
const double nu=2.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityChiSquare(x_values,nu,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionChiSquare(x_values,nu,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileChiSquare(cdf_values,nu,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomChiSquare(nu,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_chisquare,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkNoncentralChiSquare |
//+------------------------------------------------------------------+
bool CalculateBenchmarkNoncentralChiSquare(benchmark_info &benchmark_noncentral_chisquare,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Noncentral ChiSquare distribution parameters
const double nu=2.0;
const double sigma=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityNoncentralChiSquare(x_values,nu,sigma,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionNoncentralChiSquare(x_values,nu,sigma,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileNoncentralChiSquare(cdf_values,nu,sigma,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomNoncentralChiSquare(nu,sigma,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_noncentral_chisquare,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkNoncentralF |
//+------------------------------------------------------------------+
bool CalculateBenchmarkNoncentralF(benchmark_info &benchmark_noncentral_f,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Noncentral F distribution parameters
const double nu1=10.0;
const double nu2=20.0;
const double sigma=2.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityNoncentralF(x_values,nu1,nu2,sigma,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionNoncentralF(x_values,nu1,nu2,sigma,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileNoncentralF(cdf_values,nu1,nu2,sigma,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomNoncentralF(nu1,nu2,sigma,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_noncentral_f,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkNoncentralBeta |
//+------------------------------------------------------------------+
bool CalculateBenchmarkNoncentralBeta(benchmark_info &benchmark_noncentral_beta,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Noncentral Beta distribution parameters
const double a=2.0;
const double b=4.0;
const double lambda=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityNoncentralBeta(x_values,a,b,lambda,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionNoncentralBeta(x_values,a,b,lambda,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileNoncentralBeta(cdf_values,a,b,lambda,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomNoncentralBeta(a,b,lambda,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_noncentral_beta,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkNegativeBinomial |
//+------------------------------------------------------------------+
bool CalculateBenchmarkNegativeBinomial(benchmark_info &benchmark_negative_binomial,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Negatibe Binomial distribution parameters
const double r=2.0;
const double p=0.5;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0;
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityNegativeBinomial(x_values,r,p,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionNegativeBinomial(x_values,r,p,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileNegativeBinomial(cdf_values,r,p,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomNegativeBinomial(r,p,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_negative_binomial,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkT |
//+------------------------------------------------------------------+
bool CalculateBenchmarkT(benchmark_info &benchmark_t,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- T distribution parameters
const double nu=8.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityT(x_values,nu,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionT(x_values,nu,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileT(cdf_values,nu,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomT(nu,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_t,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkNoncentralT |
//+------------------------------------------------------------------+
bool CalculateBenchmarkNoncentralT(benchmark_info &benchmark_noncentral_t,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Noncentral T distribution parameters
const double nu=10.0;
const double delta=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityNoncentralT(x_values,nu,delta,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionNoncentralT(x_values,nu,delta,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileNoncentralT(cdf_values,nu,delta,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomNoncentralT(nu,delta,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_noncentral_t,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkNormal |
//+------------------------------------------------------------------+
bool CalculateBenchmarkNormal(benchmark_info &benchmark_normal,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Normal distribution parameters
const double mu=1.0;
const double sigma=1.0;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityNormal(x_values,mu,sigma,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionNormal(x_values,mu,sigma,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileNormal(cdf_values,mu,sigma,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomNormal(mu,sigma,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_normal,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarkLognormal |
//+------------------------------------------------------------------+
bool CalculateBenchmarkLognormal(benchmark_info &benchmark_lognormal,int &tests_performed,int &tests_passed)
{
tests_performed++;
//--- Lognormal distribution parameters
const double mu=0.5;
const double sigma=0.6;
const int N=50;
//--- prepare x values
double x_values[];
ArrayResize(x_values,N);
for(int i=0; i<N; i++)
x_values[i]=i*1.0/(N-1);
//--- arrays for calculated values
double pdf_values[];
double cdf_values[];
double quantile_values[];
double random_values[];
//--- arrays for time
double pdf_times[];
double cdf_times[];
double quantile_times[];
double random_times[];
int random_data_count=10000;
ulong msc=0;
int average_count=AverageCount;
//---
ArrayResize(pdf_times,average_count);
ArrayResize(cdf_times,average_count);
ArrayResize(quantile_times,average_count);
ArrayResize(random_times,average_count);
//--- calculate benchmark
for(int i=0; i<average_count; i++)
{
msc=GetMicrosecondCount();
if(!MathProbabilityDensityLognormal(x_values,mu,sigma,pdf_values))
return false;
pdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathCumulativeDistributionLognormal(x_values,mu,sigma,cdf_values))
return false;
cdf_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathQuantileLognormal(cdf_values,mu,sigma,quantile_values))
return false;
quantile_times[i]=(double)GetMicrosecondCount()-msc;
msc=GetMicrosecondCount();
if(!MathRandomLognormal(mu,sigma,random_data_count,random_values))
return false;
random_times[i]=(double)GetMicrosecondCount()-msc;
}
//--- calculate statistical properties min,max,mean,median,standard and average deviations
CalculateStatisticalProperties(benchmark_lognormal,pdf_times,cdf_times,quantile_times,random_times);
//--- successful
tests_passed++;
return true;
}
//+------------------------------------------------------------------+
//| CalculateBenchmarks |
//+------------------------------------------------------------------+
void CalculateBenchmarks(string package_name)
{
PrintFormat("Unit tests for Package %s\n",package_name);
//--- initial values
int tests_performed=0;
int tests_passed=0;
//--- benchmark data for distirbutions
benchmark_info benchmark_binomial;
benchmark_info benchmark_beta;
benchmark_info benchmark_gamma;
benchmark_info benchmark_cauchy;
benchmark_info benchmark_exponential;
benchmark_info benchmark_uniform;
benchmark_info benchmark_geometric;
benchmark_info benchmark_hypergeometric;
benchmark_info benchmark_logistic;
benchmark_info benchmark_weibull;
benchmark_info benchmark_poisson;
benchmark_info benchmark_f;
benchmark_info benchmark_chisquare;
benchmark_info benchmark_noncentral_chisquare;
benchmark_info benchmark_noncentral_f;
benchmark_info benchmark_noncentral_beta;
benchmark_info benchmark_negative_binomial;
benchmark_info benchmark_t;
benchmark_info benchmark_noncentral_t;
benchmark_info benchmark_normal;
benchmark_info benchmark_lognormal;
//---
if(CalculateBenchmarkBinomial(benchmark_binomial,tests_performed,tests_passed))
ShowBenchmarkInfo("Binomial",benchmark_binomial);
if(CalculateBenchmarkBeta(benchmark_beta,tests_performed,tests_passed))
ShowBenchmarkInfo("Beta",benchmark_beta);
if(CalculateBenchmarkGamma(benchmark_gamma,tests_performed,tests_passed))
ShowBenchmarkInfo("Gamma",benchmark_gamma);
if(CalculateBenchmarkCauchy(benchmark_cauchy,tests_performed,tests_passed))
ShowBenchmarkInfo("Cauchy",benchmark_cauchy);
if(CalculateBenchmarkExponential(benchmark_exponential,tests_performed,tests_passed))
ShowBenchmarkInfo("Exponential",benchmark_exponential);
if(CalculateBenchmarkUniform(benchmark_uniform,tests_performed,tests_passed))
ShowBenchmarkInfo("Uniform",benchmark_uniform);
if(CalculateBenchmarkGeometric(benchmark_geometric,tests_performed,tests_passed))
ShowBenchmarkInfo("Geometric",benchmark_geometric);
if(CalculateBenchmarkHypergeometric(benchmark_hypergeometric,tests_performed,tests_passed))
ShowBenchmarkInfo("Hypergeometric",benchmark_hypergeometric);
if(CalculateBenchmarkLogistic(benchmark_logistic,tests_performed,tests_passed))
ShowBenchmarkInfo("Logistic",benchmark_logistic);
if(CalculateBenchmarkWeibull(benchmark_weibull,tests_performed,tests_passed))
ShowBenchmarkInfo("Weibull",benchmark_weibull);
if(CalculateBenchmarkPoisson(benchmark_poisson,tests_performed,tests_passed))
ShowBenchmarkInfo("Poisson",benchmark_poisson);
if(CalculateBenchmarkF(benchmark_f,tests_performed,tests_passed))
ShowBenchmarkInfo("F",benchmark_f);
if(CalculateBenchmarkChiSquare(benchmark_chisquare,tests_performed,tests_passed))
ShowBenchmarkInfo("ChiSquare",benchmark_chisquare);
if(CalculateBenchmarkNoncentralChiSquare(benchmark_noncentral_chisquare,tests_performed,tests_passed))
ShowBenchmarkInfo("Noncentral ChiSquare",benchmark_noncentral_chisquare);
if(CalculateBenchmarkNoncentralF(benchmark_noncentral_f,tests_performed,tests_passed))
ShowBenchmarkInfo("Noncentral F",benchmark_noncentral_f);
if(CalculateBenchmarkNoncentralBeta(benchmark_noncentral_beta,tests_performed,tests_passed))
ShowBenchmarkInfo("Noncentral Beta",benchmark_noncentral_beta);
if(CalculateBenchmarkNegativeBinomial(benchmark_negative_binomial,tests_performed,tests_passed))
ShowBenchmarkInfo("Negative Binomial",benchmark_negative_binomial);
if(CalculateBenchmarkNormal(benchmark_normal,tests_performed,tests_passed))
ShowBenchmarkInfo("Normal",benchmark_normal);
if(CalculateBenchmarkLognormal(benchmark_lognormal,tests_performed,tests_passed))
ShowBenchmarkInfo("Lognormal",benchmark_lognormal);
if(CalculateBenchmarkT(benchmark_t,tests_performed,tests_passed))
ShowBenchmarkInfo("T",benchmark_t);
if(CalculateBenchmarkNoncentralT(benchmark_noncentral_t,tests_performed,tests_passed))
ShowBenchmarkInfo("Noncentral T",benchmark_noncentral_t);
//--- print statistics
PrintFormat("\n%d of %d passed",tests_passed,tests_performed);
}
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
CalculateBenchmarks("Statistic Benchmark");
}
//+------------------------------------------------------------------+
Reference in a new issue Copy permalink