563 lines
26 KiB
MQL5
563 lines
26 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| F.mqh |
|
|
//| Copyright 2000-2025, MetaQuotes Ltd. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#include "Math.mqh"
|
|
#include "Beta.mqh"
|
|
#include "ChiSquare.mqh"
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| F-density function (PDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function returns the probability density function of the |
|
|
//| F-distribution with parameters nu1 and nu2. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| x : Random variable |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| log_mode : Logarithm mode flag, if true it returns Log values |
|
|
//| error_code : Variable for error code |
|
|
//| |
|
|
//| Return value: |
|
|
//| The probability density evaluated at x. |
|
|
//+------------------------------------------------------------------+
|
|
double MathProbabilityDensityF(const double x,const double nu1,const double nu2,const bool log_mode,int &error_code)
|
|
{
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(x) || !MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
{
|
|
error_code=ERR_ARGUMENTS_NAN;
|
|
return QNaN;
|
|
}
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu1!=MathRound(nu1) || nu1<1 || nu2<1)
|
|
{
|
|
error_code=ERR_ARGUMENTS_INVALID;
|
|
return QNaN;
|
|
}
|
|
|
|
error_code=ERR_OK;
|
|
//--- check x
|
|
if(x<=0)
|
|
return TailLog0(true,log_mode);
|
|
//--- calculate F density
|
|
double value=MathPow((nu1/nu2),nu1*0.5)*MathPow(x,(nu1-2)*0.5)/MathBeta(nu1*0.5,nu2*0.5);
|
|
value=value*MathPow(1.0+(nu1/nu2)*x,-(nu1+nu2)*0.5);
|
|
if(log_mode==true)
|
|
return MathLog(value);
|
|
//--- return F density
|
|
return value;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F-density function (PDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function returns the probability density function of the |
|
|
//| F-distribution with parameters nu1 and nu2. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| x : Random variable |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| error_code : Variable for error code |
|
|
//| |
|
|
//| Return value: |
|
|
//| The probability density evaluated at x. |
|
|
//+------------------------------------------------------------------+
|
|
double MathProbabilityDensityF(const double x,const double nu1,const double nu2,int &error_code)
|
|
{
|
|
return MathProbabilityDensityF(x,nu1,nu2,false,error_code);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F-density function (PDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function calculates the probability density function of the |
|
|
//| F distribution with parameters nu1 and nu2 for values in x[]. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| x : Array with random variables |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| log_mode : Logarithm mode flag, if true it returns Log values |
|
|
//| result : Array with calculated values |
|
|
//| |
|
|
//| Return value: |
|
|
//| true if successful, otherwise false. |
|
|
//+------------------------------------------------------------------+
|
|
bool MathProbabilityDensityF(const double &x[],const double nu1,const double nu2,const bool log_mode,double &result[])
|
|
{
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
return false;
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu1!=MathRound(nu1) || nu1<1 || nu2<1)
|
|
return false;
|
|
|
|
int data_count=ArraySize(x);
|
|
if(data_count==0)
|
|
return false;
|
|
|
|
int error_code=0;
|
|
ArrayResize(result,data_count);
|
|
for(int i=0; i<data_count; i++)
|
|
{
|
|
double x_arg=x[i];
|
|
|
|
if(x_arg<=0)
|
|
result[i]=TailLog0(true,log_mode);
|
|
else
|
|
{
|
|
//--- calculate F density
|
|
double value=MathPow((nu1/nu2),nu1*0.5)*MathPow(x_arg,(nu1-2)*0.5)/MathBeta(nu1*0.5,nu2*0.5);
|
|
value=value*MathPow(1.0+(nu1/nu2)*x_arg,-(nu1+nu2)*0.5);
|
|
if(log_mode==true)
|
|
result[i]=MathLog(value);
|
|
else
|
|
result[i]=value;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F-density function (PDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function calculates the probability density function of the |
|
|
//| F distribution with parameters nu1 and nu2 for values in x[]. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| x : Array with random variables |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| result : Array with calculated values |
|
|
//| |
|
|
//| Return value: |
|
|
//| true if successful, otherwise false. |
|
|
//+------------------------------------------------------------------+
|
|
bool MathProbabilityDensityF(const double &x[],const double nu1,const double nu2,double &result[])
|
|
{
|
|
return MathProbabilityDensityF(x,nu1,nu2,false,result);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F cumulative distribution function (CDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function returns the cumulative distribution function of the |
|
|
//| F-distribution with given nu1 and nu2. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| x : The desired quantile |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| tail : Flag to calculate lower tail |
|
|
//| log_mode : Logarithm mode, if true it calculates Log values |
|
|
//| error_code : Variable for error code |
|
|
//| |
|
|
//| Return value: |
|
|
//| The value of the F cumulative distribution function with |
|
|
//| parameters nu1 and nu2, evaluated at x. |
|
|
//+------------------------------------------------------------------+
|
|
double MathCumulativeDistributionF(const double x,const double nu1,const double nu2,const bool tail,const bool log_mode,int &error_code)
|
|
{
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(x) || !MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
{
|
|
error_code=ERR_ARGUMENTS_NAN;
|
|
return QNaN;
|
|
}
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu2!=MathRound(nu2) || nu1<=0 || nu2<=0)
|
|
{
|
|
error_code=ERR_ARGUMENTS_INVALID;
|
|
return QNaN;
|
|
}
|
|
|
|
error_code=ERR_OK;
|
|
//--- check x
|
|
if(x<=0)
|
|
return TailLog0(tail,log_mode);
|
|
//--- calculate cdf using incomplete Beta and take into account round-off errors for probability
|
|
double cdf=MathMin(1.0-MathBetaIncomplete(nu2/(nu2+nu1*x),nu2*0.5,nu1*0.5),1.0);
|
|
return TailLogValue(cdf,tail,log_mode);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F cumulative distribution function (CDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function returns the cumulative distribution function of the |
|
|
//| F-distribution with given nu1 and nu2. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| x : The desired quantile |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| error_code : Variable for error code |
|
|
//| |
|
|
//| Return value: |
|
|
//| The value of the F cumulative distribution function with |
|
|
//| parameters nu1 and nu2, evaluated at x. |
|
|
//+------------------------------------------------------------------+
|
|
double MathCumulativeDistributionF(const double x,const double nu1,const double nu2,int &error_code)
|
|
{
|
|
return MathCumulativeDistributionF(x,nu1,nu2,true,false,error_code);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F cumulative distribution function (CDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function calculates the cumulative distribution function of |
|
|
//| the F distribution with parameters nu1 and nu2 for values in x[].|
|
|
//| |
|
|
//| Arguments: |
|
|
//| x : Array with random variables |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| tail : Flag to calculate lower tail |
|
|
//| log_mode : Logarithm mode, if true it calculates Log values |
|
|
//| result : Array with calculated values |
|
|
//| |
|
|
//| Return value: |
|
|
//| true if successful, otherwise false. |
|
|
//+------------------------------------------------------------------+
|
|
bool MathCumulativeDistributionF(const double &x[],const double nu1,const double nu2,const bool tail,const bool log_mode,double &result[])
|
|
{
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
return false;
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu2!=MathRound(nu2) || nu1<=0 || nu2<=0)
|
|
return false;
|
|
|
|
int data_count=ArraySize(x);
|
|
if(data_count==0)
|
|
return false;
|
|
|
|
int error_code=0;
|
|
ArrayResize(result,data_count);
|
|
for(int i=0; i<data_count; i++)
|
|
{
|
|
double x_arg=x[i];
|
|
|
|
//--- check x
|
|
if(x_arg<=0)
|
|
result[i]=TailLog0(tail,log_mode);
|
|
else
|
|
{
|
|
//--- calculate cdf using incomplete Beta and take into account round-off errors for probability
|
|
double cdf=MathMin(1.0-MathBetaIncomplete(nu2/(nu2+nu1*x_arg),nu2*0.5,nu1*0.5),1.0);
|
|
result[i]=TailLogValue(cdf,tail,log_mode);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F cumulative distribution function (CDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function calculates the cumulative distribution function of |
|
|
//| the F distribution with parameters nu1 and nu2 for values in x[].|
|
|
//| |
|
|
//| Arguments: |
|
|
//| x : Array with random variables |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| result : Array with calculated values |
|
|
//| |
|
|
//| Return value: |
|
|
//| true if successful, otherwise false. |
|
|
//+------------------------------------------------------------------+
|
|
bool MathCumulativeDistributionF(const double &x[],const double nu1,const double nu2,double &result[])
|
|
{
|
|
return MathCumulativeDistributionF(x,nu1,nu2,true,false,result);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F-distribution quantile function (inverse CDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function returns the inverse cumulative distribution |
|
|
//| function of F-distribution with parameters nu1 and nu2 |
|
|
//| for the desired probability. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| probability : The desired probability |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| tail : Flag to calculate lower tail |
|
|
//| log_mode : Logarithm mode, if true it calculates Log values |
|
|
//| error_code : Variable for error code |
|
|
//| |
|
|
//| Return value: |
|
|
//| The value of the inverse cumulative distribution function |
|
|
//| of F-distribution with parameters nu1 and nu2. |
|
|
//+------------------------------------------------------------------+
|
|
double MathQuantileF(const double probability,const double nu1,const double nu2,const bool tail,const bool log_mode,int &error_code)
|
|
{
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
{
|
|
error_code=ERR_ARGUMENTS_NAN;
|
|
return QNaN;
|
|
}
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu2!=MathRound(nu2) || nu1<=0 || nu2<=0)
|
|
{
|
|
error_code=ERR_ARGUMENTS_INVALID;
|
|
return QNaN;
|
|
}
|
|
|
|
//--- calculate real probability
|
|
double prob=TailLogProbability(probability,tail,log_mode);
|
|
//--- check probability range
|
|
if(prob<0.0 || prob>1.0)
|
|
{
|
|
error_code=ERR_ARGUMENTS_INVALID;
|
|
return QNaN;
|
|
}
|
|
//--- check case probability==1
|
|
if(prob==1.0)
|
|
{
|
|
error_code=ERR_RESULT_INFINITE;
|
|
return QPOSINF;
|
|
}
|
|
|
|
error_code=ERR_OK;
|
|
if(prob==0.0)
|
|
return 0.0;
|
|
//--- calculate quantile using Beta distribution
|
|
double qBeta=MathQuantileBeta(1.0-prob,nu2*0.5,nu1*0.5,error_code);
|
|
//--- return quantile;
|
|
return (nu2/qBeta-nu2)/nu1;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F-distribution quantile function (inverse CDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function returns the inverse cumulative distribution |
|
|
//| function of F-distribution with parameters nu1 and nu2 |
|
|
//| for the desired probability. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| probability : The desired probability |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| error_code : Variable for error code |
|
|
//| |
|
|
//| Return value: |
|
|
//| The value of the inverse cumulative distribution function |
|
|
//| of F-distribution with parameters nu1 and nu2. |
|
|
//+------------------------------------------------------------------+
|
|
double MathQuantileF(const double probability,const double nu1,const double nu2,int &error_code)
|
|
{
|
|
return MathQuantileF(probability,nu1,nu2,true,false,error_code);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F-distribution quantile function (inverse CDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function calculates the inverse cumulative distribution |
|
|
//| function of the F distribution with parameters nu1 and nu2 |
|
|
//| for values from the probability[] array. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| probability : Array with probabilities |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| tail : Flag to calculate lower tail |
|
|
//| log_mode : Logarithm mode, if true it calculates Log values |
|
|
//| result : Array with calculated values |
|
|
//| |
|
|
//| Return value: |
|
|
//| true if successful, otherwise false. |
|
|
//+------------------------------------------------------------------+
|
|
bool MathQuantileF(const double &probability[],const double nu1,const double nu2,const bool tail,const bool log_mode,double &result[])
|
|
{
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
return false;
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu2!=MathRound(nu2) || nu1<=0 || nu2<=0)
|
|
return false;
|
|
|
|
int data_count=ArraySize(probability);
|
|
if(data_count==0)
|
|
return false;
|
|
|
|
int error_code=0;
|
|
ArrayResize(result,data_count);
|
|
for(int i=0; i<data_count; i++)
|
|
{
|
|
//--- calculate real probability
|
|
double prob=TailLogProbability(probability[i],tail,log_mode);
|
|
//--- check probability range
|
|
if(prob<0.0 || prob>1.0)
|
|
return false;
|
|
|
|
//--- check case probability==1,0
|
|
if(prob==0.0)
|
|
result[i]=0.0;
|
|
else
|
|
if(prob==1.0)
|
|
result[i]=QPOSINF;
|
|
else
|
|
{
|
|
//--- calculate quantile using Beta distribution
|
|
double qBeta=MathQuantileBeta(1.0-prob,nu2*0.5,nu1*0.5,error_code);
|
|
result[i]=(nu2/qBeta-nu2)/nu1;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F-distribution quantile function (inverse CDF) |
|
|
//+------------------------------------------------------------------+
|
|
//| The function calculates the inverse cumulative distribution |
|
|
//| function of the F distribution with parameters nu1 and nu2 |
|
|
//| for values from probability[] array. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| probability : Array with probabilities |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| result : Array with calculated values |
|
|
//| |
|
|
//| Return value: |
|
|
//| true if successful, otherwise false. |
|
|
//+------------------------------------------------------------------+
|
|
bool MathQuantileF(const double &probability[],const double nu1,const double nu2,double &result[])
|
|
{
|
|
return MathQuantileF(probability,nu1,nu2,true,false,result);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Random variate from the F-distribution |
|
|
//+------------------------------------------------------------------+
|
|
//| Compute the random variable from F-distribution |
|
|
//| with parameters nu1 and nu2. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| error_code : Variable for error code |
|
|
//| |
|
|
//| Return value: |
|
|
//| The random value with F-distribution. |
|
|
//+------------------------------------------------------------------+
|
|
double MathRandomF(const double nu1,const double nu2,int &error_code)
|
|
{
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
{
|
|
error_code=ERR_ARGUMENTS_NAN;
|
|
return QNaN;
|
|
}
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu2!=MathRound(nu2) || nu1<=0 || nu2<=0)
|
|
{
|
|
error_code=ERR_ARGUMENTS_INVALID;
|
|
return QNaN;
|
|
}
|
|
|
|
error_code=ERR_OK;
|
|
//--- random F=ChiSquare(nu1)*nu2/ChiSquare(nu2)*nu1;
|
|
double xnum = MathRandomGamma(nu1*0.5,1.0,error_code)*nu2;
|
|
double xden = MathRandomGamma(nu2*0.5,1.0,error_code)*nu1;
|
|
//---
|
|
double value=0.0;
|
|
if(xden!=0)
|
|
value= xnum/xden;
|
|
else
|
|
{
|
|
error_code=ERR_NON_CONVERGENCE;
|
|
value=QNaN;
|
|
}
|
|
//--- return random F
|
|
return value;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Random variate from the F distribution |
|
|
//+------------------------------------------------------------------+
|
|
//| Generates random variables from the F distribution with |
|
|
//| parameters nu1 and nu2. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| data_count : Number of values needed |
|
|
//| result : Output array with random values |
|
|
//| |
|
|
//| Return value: |
|
|
//| true if successful, otherwise false. |
|
|
//+------------------------------------------------------------------+
|
|
bool MathRandomF(const double nu1,const double nu2,const int data_count,double &result[])
|
|
{
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
return false;
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu2!=MathRound(nu2) || nu1<=0 || nu2<=0)
|
|
return false;
|
|
|
|
//--- prepare output array and calculate random values
|
|
ArrayResize(result,data_count);
|
|
for(int i=0; i<data_count; i++)
|
|
{
|
|
int error_code=0;
|
|
//--- random F=ChiSquare(nu1)*nu2/ChiSquare(nu2)*nu1;
|
|
double xnum = MathRandomGamma(nu1*0.5,1.0,error_code)*nu2;
|
|
double xden = MathRandomGamma(nu2*0.5,1.0,error_code)*nu1;
|
|
//---
|
|
double value=0.0;
|
|
if(xden!=0)
|
|
value= xnum/xden;
|
|
else
|
|
{
|
|
error_code=ERR_NON_CONVERGENCE;
|
|
value=QNaN;
|
|
}
|
|
//--- random F
|
|
result[i]=value;
|
|
}
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| F-distribution moments |
|
|
//+------------------------------------------------------------------+
|
|
//| The function calculates 4 first moments of F-distribution |
|
|
//| with parameters nu1 and nu2. |
|
|
//| |
|
|
//| Arguments: |
|
|
//| nu1 : Numerator degrees of freedom |
|
|
//| nu2 : Denominator degrees of freedom |
|
|
//| mean : Variable for mean value (1st moment) |
|
|
//| variance : Variable for variance value (2nd moment) |
|
|
//| skewness : Variable for skewness value (3rd moment) |
|
|
//| kurtosis : Variable for kurtosis value (4th moment) |
|
|
//| error_code : Variable for error code |
|
|
//| |
|
|
//| Return value: |
|
|
//| true if moments calculated successfully, otherwise false. |
|
|
//+------------------------------------------------------------------+
|
|
bool MathMomentsF(const double nu1,const double nu2,double &mean,double &variance,double &skewness,double &kurtosis,int &error_code)
|
|
{
|
|
//--- default values
|
|
mean =QNaN;
|
|
variance=QNaN;
|
|
skewness=QNaN;
|
|
kurtosis=QNaN;
|
|
//--- check NaN
|
|
if(!MathIsValidNumber(nu1) || !MathIsValidNumber(nu2))
|
|
{
|
|
error_code=ERR_ARGUMENTS_NAN;
|
|
return false;
|
|
}
|
|
//--- check arguments
|
|
if(nu1!=MathRound(nu1) || nu1!=MathRound(nu1) || nu1<1 || nu2<1)
|
|
{
|
|
error_code=ERR_ARGUMENTS_INVALID;
|
|
return false;
|
|
}
|
|
|
|
error_code=ERR_OK;
|
|
//--- calculate moments
|
|
if(nu2>2)
|
|
mean=nu2/(nu2-2);
|
|
if(nu2>4)
|
|
variance=2*nu2*nu2*(nu1+nu2-2)/(nu1*(nu2-2)*(nu2-2)*(nu2-4));
|
|
if(nu2>6)
|
|
skewness=2*MathSqrt(2)*MathSqrt(nu2-4)*(2*nu1+nu2-2)/(MathSqrt(nu1*(nu1+nu2-2))*(nu2-6));
|
|
if(nu2>8)
|
|
kurtosis=12*(nu1*(5*nu2-22)*(nu1+nu2-2)+(nu2-4)*(nu2-2)*(nu2-2))/(nu1*(nu2-8)*(nu2-6)*(nu1+nu2-2));
|
|
//--- successful
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|