1590 lines
55 KiB
MQL5
1590 lines
55 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| 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");
| |||
}
| |||
//+------------------------------------------------------------------+
|