Hiroaki86
5518 lines
425 KiB
Plaintext
5518 lines
425 KiB
Plaintext
//+------------------------------------------------------------------+
|
||
//| Math.mqh |
|
||
//| Copyright 2000-2026, MetaQuotes Ltd. |
|
||
//| www.mql5.com |
|
||
//+------------------------------------------------------------------+
|
||
#define ERR_OK 0
|
||
#define ERR_ARGUMENTS_NAN 1
|
||
#define ERR_ARGUMENTS_INVALID 2
|
||
#define ERR_RESULT_INFINITE 3
|
||
#define ERR_NON_CONVERGENCE 4
|
||
|
||
//+------------------------------------------------------------------+
|
||
//| Nans |
|
||
//+------------------------------------------------------------------+
|
||
double QNaN =(double)"nan"; // QNaN
|
||
double QPOSINF=(double)"inf"; // +infinity 1.#INF
|
||
double QNEGINF=(double)"-inf"; // -infinity -1.#INF
|
||
//+------------------------------------------------------------------+
|
||
//| MathRandom |
|
||
//+------------------------------------------------------------------+
|
||
double MathRandomNonZero(void)
|
||
{
|
||
double rnd=0;
|
||
//--- except 0 and 1
|
||
while(rnd==0.0 || rnd==1.0)
|
||
rnd=MathRand()/32767.0;
|
||
//---
|
||
return(rnd);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes 4 first moments of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
bool MathMoments(const double &array[],double &mean,double &variance,double &skewness,double &kurtosis,const int start=0,const int count=WHOLE_ARRAY)
|
||
{
|
||
//--- initial values
|
||
mean=0.0;
|
||
variance=0.0;
|
||
skewness=0.0;
|
||
kurtosis=0.0;
|
||
//--- get data size
|
||
int size=ArraySize(array);
|
||
int data_count=0;
|
||
//--- set data count
|
||
if(count==WHOLE_ARRAY)
|
||
data_count=size;
|
||
else
|
||
data_count=count;
|
||
//--- check data range
|
||
if(data_count==0)
|
||
return(false);
|
||
if(start+data_count>size)
|
||
return(false);
|
||
//--- set indexes
|
||
int ind1=start;
|
||
int ind2=ind1+data_count-1;
|
||
//--- calculate mean
|
||
for(int i=ind1; i<=ind2; i++)
|
||
mean+=array[i];
|
||
mean=mean/data_count;
|
||
double S=0.0;
|
||
//---
|
||
if(data_count>1)
|
||
{
|
||
//--- calculate variance
|
||
for(int i=ind1; i<=ind2; i++)
|
||
variance+=MathPow(array[i]-mean,2);
|
||
variance=variance/(data_count-1);
|
||
S=MathSqrt(variance);
|
||
}
|
||
else
|
||
variance=QNaN;
|
||
//---
|
||
if(data_count>2 && S>0.0)
|
||
{
|
||
//--- calculate skewness
|
||
for(int i=ind1; i<=ind2; i++)
|
||
skewness+=MathPow(array[i]-mean,3);
|
||
skewness=skewness/(data_count*MathPow(S,3));
|
||
}
|
||
else
|
||
skewness=QNaN;
|
||
//---
|
||
if(data_count>3 && S>0.0)
|
||
{
|
||
//--- calculate kurtosis
|
||
for(int i=ind1; i<=ind2; i++)
|
||
kurtosis+=MathPow(array[i]-mean,4);
|
||
kurtosis=kurtosis/(data_count*MathPow(S,4));
|
||
kurtosis-=3;
|
||
}
|
||
else
|
||
kurtosis=QNaN;
|
||
//--- check values and return calculation result
|
||
if((!MathIsValidNumber(variance)) || (!MathIsValidNumber(skewness)) || (!MathIsValidNumber(kurtosis)))
|
||
return(false);
|
||
else
|
||
return(true);
|
||
}
|
||
|
||
#define M_1_SQRT_2PI 1/MathSqrt(2*M_PI)
|
||
|
||
double FactorialsTable[21]=
|
||
{
|
||
1,1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,
|
||
6227020800,87178291200,1307674368000,20922789888000,355687428096000,
|
||
6402373705728000,121645100408832000,2432902008176640000
|
||
};
|
||
//+------------------------------------------------------------------+
|
||
//| MathPowInt |
|
||
//+------------------------------------------------------------------+
|
||
double MathPowInt(const double x,const int power)
|
||
{
|
||
//--- check power
|
||
if(power==0)
|
||
return(1.0);
|
||
if(power<0)
|
||
return(0);
|
||
//--- calculate product
|
||
double val=x;
|
||
for(int i=2; i<=power; i++)
|
||
val*=x;
|
||
//--- return result
|
||
return(val);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathFactorial |
|
||
//+------------------------------------------------------------------+
|
||
double MathFactorial(const int n)
|
||
{
|
||
if(n<0)
|
||
return(0);
|
||
if(n<=20)
|
||
//--- use values from the factorials table
|
||
return(FactorialsTable[n]);
|
||
else
|
||
{
|
||
//--- calculate product starting from 20th element of factorials table
|
||
double val=FactorialsTable[20];
|
||
for(int i=21; i<=n; i++)
|
||
val*=i;
|
||
//--- return result
|
||
return(val);
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTrunc |
|
||
//+------------------------------------------------------------------+
|
||
double MathTrunc(const double x)
|
||
{
|
||
if(x>=0)
|
||
return(MathFloor(x));
|
||
else
|
||
return(MathCeil(x));
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathRound |
|
||
//+------------------------------------------------------------------+
|
||
//| Round a double number to a given precision |
|
||
//+------------------------------------------------------------------+
|
||
double MathRound(const double x,const int digits)
|
||
{
|
||
if(!MathIsValidNumber(x))
|
||
return(QNaN);
|
||
|
||
if(x==0.0)
|
||
return(x);
|
||
|
||
if(digits>0)
|
||
{
|
||
double sign=1.0;
|
||
double xx=x;
|
||
if(xx<0.0)
|
||
{
|
||
xx=-xx;
|
||
sign=-1.0;
|
||
}
|
||
double pwr_factor=MathPow(10,digits);
|
||
double int_value=MathFloor(xx);
|
||
double res=(xx-int_value)*pwr_factor;
|
||
res=MathFloor(MathAbs(res)+0.5);
|
||
return(sign*(int_value+res/pwr_factor));
|
||
}
|
||
else
|
||
if(digits==0)
|
||
return MathRound(x);
|
||
//---
|
||
return(0);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Comments from original FORTRAN code: |
|
||
//| https://www.netlib.org/specfun/gamma |
|
||
//| |
|
||
//| This routine calculates the GAMMA function for a real argument X.|
|
||
//| Computation is based on an algorithm outlined in reference 1. |
|
||
//| The program uses rational functions that approximate the GAMMA |
|
||
//| function to at least 20 significant decimal digits. Coefficients |
|
||
//| for the approximation over the interval (1,2) are unpublished. |
|
||
//| Those for the approximation for X .GE. 12 are from reference 2. |
|
||
//| |
|
||
//| References: |
|
||
//| 1. "An Overview of Software Development for Special Functions" |
|
||
//| W. J. Cody, Lecture Notes in Mathematics, 506, |
|
||
//| Numerical Analysis Dundee, 1975, G. A. Watson (ed.) |
|
||
//| Springer Verlag, Berlin, 1976. |
|
||
//| 2. Computer Approximations, Hart, Et. Al., Wiley and sons, |
|
||
//| New York, 1968. |
|
||
//| |
|
||
//| Authors: |
|
||
//| W. J. Cody and L. Stoltz, Applied Mathematics Division |
|
||
//| Argonne National Laboratory, Argonne, IL 60439 |
|
||
//+------------------------------------------------------------------+
|
||
double MathGamma(const double x)
|
||
{
|
||
//--- mathematical constants
|
||
const double logsqrt2pi=MathLog(MathSqrt(2*M_PI));
|
||
//--- machine dependent parameters
|
||
const double xminin=2.23e-308;
|
||
const double xbig=171.624;
|
||
double eps=2.22e-16;
|
||
//--- numerator and denominator coefficients for rational minimax
|
||
//--- approximation over (1,2)
|
||
const double p[8]=
|
||
{
|
||
-1.71618513886549492533811e+0, 2.47656508055759199108314e+1,
|
||
-3.79804256470945635097577e+2, 6.29331155312818442661052e+2,
|
||
8.66966202790413211295064e+2,-3.14512729688483675254357e+4,
|
||
-3.61444134186911729807069e+4, 6.64561438202405440627855e+4
|
||
};
|
||
const double q[8]=
|
||
{
|
||
-3.08402300119738975254353e+1, 3.15350626979604161529144e+2,
|
||
-1.01515636749021914166146e+3,-3.10777167157231109440444e+3,
|
||
2.25381184209801510330112e+4, 4.75584627752788110767815e+3,
|
||
-1.34659959864969306392456e+5,-1.15132259675553483497211e+5
|
||
};
|
||
//--- coefficients for minimax approximation over (12, inf)
|
||
const double c[7]=
|
||
{
|
||
-1.910444077728e-03, 8.4171387781295e-04,
|
||
-5.952379913043012e-04, 7.93650793500350248e-04,
|
||
-2.777777777777681622553e-03,8.333333333333333331554247e-02,
|
||
5.7083835261e-03
|
||
};
|
||
|
||
int parity=0;
|
||
double fact=1.0;
|
||
int n=0;
|
||
double y=x,y1,res,z,xnum=0,xden=0,ysq=0,sum=0;
|
||
|
||
if(y<=0.0)
|
||
{
|
||
//--- argument is negative
|
||
y=-x;
|
||
y1=MathTrunc(y);
|
||
res=y-y1;
|
||
if(res!=0.0)
|
||
{
|
||
if(y1!=MathTrunc(y1*0.5)*2.0)
|
||
parity=1;
|
||
fact=-M_PI/MathSin(M_PI*res);
|
||
y=y+1.0;
|
||
}
|
||
else
|
||
{
|
||
return(QPOSINF);
|
||
}
|
||
}
|
||
//--- argument is positive
|
||
if(y<eps)
|
||
{
|
||
//--- argument < eps
|
||
if(y>=xminin)
|
||
{
|
||
res=1.0/y;
|
||
}
|
||
else
|
||
{
|
||
return(QPOSINF);
|
||
}
|
||
}
|
||
else
|
||
if(y<12.0)
|
||
{
|
||
y1=y;
|
||
if(y<1.0)
|
||
{
|
||
//--- 0.0 < argument < 1.0
|
||
z = y;
|
||
y = y + 1.0;
|
||
}
|
||
else
|
||
{
|
||
//--- 1.0 < argument < 12.0, reduce argument if necessary
|
||
n = int(y) - 1;
|
||
y = y - double(n);
|
||
z = y - 1.0;
|
||
}
|
||
//--- evaluate approximation for 1.0 < argument < 2.0
|
||
xnum=0.0;
|
||
xden=1.0;
|
||
for(int i=0; i<8; i++)
|
||
{
|
||
xnum = (xnum + p[i]) * z;
|
||
xden = xden * z + q[i];
|
||
}
|
||
res=xnum/xden+1.0;
|
||
if(y1<y)
|
||
{
|
||
//--- adjust result for case 0.0 < argument < 1.0
|
||
res=res/y1;
|
||
}
|
||
else
|
||
if(y1>y)
|
||
{
|
||
//--- adjust result for case 2.0 < argument < 12.0
|
||
for(int i=0; i<n; i++)
|
||
{
|
||
res=res*y;
|
||
y=y+1.0;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//--- evaluate for argument <=12.0,
|
||
if(y<=xbig)
|
||
{
|
||
ysq=y*y;
|
||
sum=c[6];
|
||
for(int i=0; i<6; i++)
|
||
{
|
||
sum=sum/ysq+c[i];
|
||
}
|
||
sum = sum/y - y + logsqrt2pi;
|
||
sum = sum + (y-0.5)*MathLog(y);
|
||
res = MathExp(sum);
|
||
}
|
||
else
|
||
{
|
||
return(QPOSINF);
|
||
}
|
||
}
|
||
//--- final adjustments and return
|
||
if(parity==1)
|
||
res=-res;
|
||
if(fact!=1.0)
|
||
res=fact/res;
|
||
//--- return result
|
||
return(res);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathGammaLog |
|
||
//+------------------------------------------------------------------+
|
||
//| Comments from original FORTRAN code: |
|
||
//| https://www.netlib.org/specfun/algama |
|
||
//| |
|
||
//| This routine calculates the LOG(GAMMA) function for a positive |
|
||
//| real argument X. Computation is based on an algorithm outlined |
|
||
//| in references 1 and 2. The program uses rational functions that |
|
||
//| theoretically approximate LOG(GAMMA) to at least 18 significant |
|
||
//| decimal digits. The approximation for X > 12 is from reference |
|
||
//| 3, while approximations for X < 12.0 are similar to those in |
|
||
//| reference 1, but are unpublished. The accuracy achieved depends |
|
||
//| on the arithmetic system, the compiler, the intrinsic functions, |
|
||
//| and proper selection of the machine-dependent constants. |
|
||
//| |
|
||
//| References: |
|
||
//| 1) W. J. Cody and K. E. Hillstrom, 'Chebyshev Approximations for |
|
||
//| the Natural Logarithm of the Gamma Function,' Math. Comp. 21, |
|
||
//| 1967, pp. 198-203. |
|
||
//| 2) K. E. Hillstrom, ANL/AMD Program ANLC366S, DGAMMA/DLGAMA, May,|
|
||
//| 1969. |
|
||
//| 3) Hart, Et. Al., Computer Approximations, Wiley and sons, New |
|
||
//| York, 1968. |
|
||
//| Authors: W. J. Cody and L. Stoltz |
|
||
//| Argonne National Laboratory |
|
||
//| |
|
||
//| https://gcc.gnu.org/ml/fortran/2007-11/msg00061/gamma.diff |
|
||
//| For negative arguments (where netlib would return +Inf) |
|
||
//| we use the following identity: |
|
||
//| lgamma(y) = log(pi/(|y*sin(pi*y)|)) - lgamma(-y) |
|
||
//+------------------------------------------------------------------+
|
||
double MathGammaLog(const double x)
|
||
{
|
||
//--- mathematical constants
|
||
const double pnt68=0.6796875e0;
|
||
const double sqrtpi=0.9189385332046727417803297e0;
|
||
//--- machine dependent parameters
|
||
const double xbig=2.55E305;
|
||
const double xinf=1.79E308;
|
||
const double eps=2.22E-16;
|
||
const double frtbig=2.25E76;
|
||
//--- numerator and denominator coefficients for rational minimax
|
||
//--- approximation over (0.5,1.5)
|
||
const double d1=-5.772156649015328605195174e-1;
|
||
const double p1[8]=
|
||
{
|
||
4.945235359296727046734888e0,2.018112620856775083915565e2,
|
||
2.290838373831346393026739e3,1.131967205903380828685045e4,
|
||
2.855724635671635335736389e4,3.848496228443793359990269e4,
|
||
2.637748787624195437963534e4,7.225813979700288197698961e3
|
||
};
|
||
const double q1[8]=
|
||
{
|
||
6.748212550303777196073036e1,1.113332393857199323513008e3,
|
||
7.738757056935398733233834e3,2.763987074403340708898585e4,
|
||
5.499310206226157329794414e4,6.161122180066002127833352e4,
|
||
3.635127591501940507276287e4,8.785536302431013170870835e3
|
||
};
|
||
//--- numerator and denominator coefficients for rational minimax
|
||
//--- approximation over (1.5,4.0)
|
||
const double d2=4.227843350984671393993777e-1;
|
||
const double p2[8]=
|
||
{
|
||
4.974607845568932035012064e0,5.424138599891070494101986e2,
|
||
1.550693864978364947665077e4,1.847932904445632425417223e5,
|
||
1.088204769468828767498470e6,3.338152967987029735917223e6,
|
||
5.106661678927352456275255e6,3.074109054850539556250927e6
|
||
};
|
||
const double q2[8]=
|
||
{
|
||
1.830328399370592604055942e2,7.765049321445005871323047e3,
|
||
1.331903827966074194402448e5,1.136705821321969608938755e6,
|
||
5.267964117437946917577538e6,1.346701454311101692290052e7,
|
||
1.782736530353274213975932e7,9.533095591844353613395747e6
|
||
};
|
||
//--- numerator and denominator coefficients for rational minimax
|
||
//--- approximation over (4.0,12.0)
|
||
const double d4=1.791759469228055000094023e0;
|
||
const double p4[8]=
|
||
{
|
||
1.474502166059939948905062e4, 2.426813369486704502836312e6,
|
||
1.214755574045093227939592e8, 2.663432449630976949898078e9,
|
||
2.940378956634553899906876e10,1.702665737765398868392998e11,
|
||
4.926125793377430887588120e11,5.606251856223951465078242e11
|
||
};
|
||
const double q4[8]=
|
||
{
|
||
2.690530175870899333379843e3, 6.393885654300092398984238e5,
|
||
4.135599930241388052042842e7, 1.120872109616147941376570e9,
|
||
1.488613728678813811542398e10,1.016803586272438228077304e11,
|
||
3.417476345507377132798597e11,4.463158187419713286462081e11
|
||
};
|
||
//--- coefficients for minimax approximation over (12, inf)
|
||
const double c[7]=
|
||
{
|
||
-1.910444077728e-03, 8.4171387781295e-04,
|
||
-5.952379913043012e-04, 7.93650793500350248e-04,
|
||
-2.777777777777681622553e-03,8.333333333333333331554247e-02,
|
||
5.7083835261e-03
|
||
};
|
||
|
||
double y=x;
|
||
double res=0.0;
|
||
double corr=0;
|
||
double xm1,xm2,xm4,xden,xnum;
|
||
double ysq=0;
|
||
|
||
if((y>0 && y<=xbig))
|
||
{
|
||
if(y<=eps)
|
||
{
|
||
res=-MathLog(y);
|
||
}
|
||
else
|
||
{
|
||
if(y<=1.5)
|
||
{
|
||
//--- eps < x <= 1.5
|
||
if(y<pnt68)
|
||
{
|
||
corr= -MathLog(y);
|
||
xm1 = y;
|
||
}
|
||
else
|
||
{
|
||
corr=0.0;
|
||
xm1 =(y-0.5)-0.5;
|
||
}
|
||
if((y<=0.5 || y>=pnt68))
|
||
{
|
||
xden = 1.0;
|
||
xnum = 0;
|
||
for(int i=0; i<8; i++)
|
||
{
|
||
xnum = xnum*xm1 + p1[i];
|
||
xden = xden*xm1 + q1[i];
|
||
}
|
||
res=corr+(xm1 *(d1+xm1*(xnum/xden)));
|
||
}
|
||
else
|
||
{
|
||
xm2=(y-0.5)-0.5;
|
||
xden = 1.0;
|
||
xnum = 0.0;
|
||
for(int i=0; i<8; i++)
|
||
{
|
||
xnum=xnum*xm2+p2[i];
|
||
xden=xden*xm2+q2[i];
|
||
}
|
||
res=corr+xm2 *(d2+xm2*(xnum/xden));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(y<=4.0)
|
||
{
|
||
//--- 1.5 < x .<= 4.0
|
||
xm2=y-2.0;
|
||
xden = 1.0;
|
||
xnum = 0.0;
|
||
for(int i=0; i<8; i++)
|
||
{
|
||
xnum = xnum*xm2 + p2[i];
|
||
xden = xden*xm2 + q2[i];
|
||
}
|
||
res=xm2 *(d2+xm2*(xnum/xden));
|
||
}
|
||
else
|
||
{
|
||
if(y<=12.0)
|
||
{
|
||
//--- 4.0 < x <= 12.0
|
||
xm4=y-4.0;
|
||
xden = -1.0;
|
||
xnum = 0.0;
|
||
for(int i=0; i<8; i++)
|
||
{
|
||
xnum = xnum*xm4 + p4[i];
|
||
xden = xden*xm4 + q4[i];
|
||
}
|
||
res=d4+xm4*(xnum/xden);
|
||
}
|
||
else
|
||
{
|
||
//--- evaluate for argument>=12.0,
|
||
res=0.0;
|
||
if(y<=frtbig)
|
||
{
|
||
res=c[6];
|
||
ysq=y*y;
|
||
for(int i=0; i<6; i++)
|
||
{
|
||
res=res/ysq+c[i];
|
||
}
|
||
}
|
||
res=res/y;
|
||
corr= MathLog(y);
|
||
res = res + sqrtpi - 0.5*corr;
|
||
res = res + y*(corr-1.0);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//--- return for bad arguments
|
||
//--- res=QPOSINF;
|
||
//--- for negative arguments (where netlib would return +Inf)
|
||
//--- we use the following identity:
|
||
//--- lgamma(y) = log(pi/(|y*sin(pi*y)|)) - lgamma(-y)
|
||
//--- https://gcc.gnu.org/ml/fortran/2007-11/msg00061/gamma.diff
|
||
if(y<0 && MathFloor(y)!=y)
|
||
{
|
||
//--- for abs(y) very close to zero, we use a series expansion to
|
||
//--- the first order in y to avoid overflow.
|
||
if(y>-1.e-100)
|
||
res=-2*MathLog(MathAbs(y))-MathGammaLog(-y);
|
||
else
|
||
res=MathLog(M_PI/MathAbs(y*MathSin(M_PI*y)))-MathGammaLog(-y);
|
||
}
|
||
else
|
||
{
|
||
//--- negative integer values
|
||
res=QPOSINF;
|
||
}
|
||
}
|
||
//--- return result
|
||
return(res);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBeta |
|
||
//+------------------------------------------------------------------+
|
||
double MathBeta(const double a,const double b)
|
||
{
|
||
return MathExp(MathBetaLog(a,b));
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBetaLog |
|
||
//+------------------------------------------------------------------+
|
||
double MathBetaLog(const double a,const double b)
|
||
{
|
||
return(MathGammaLog(a)+MathGammaLog(b)-MathGammaLog(a+b));
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Incomplete beta function |
|
||
//+------------------------------------------------------------------+
|
||
//| The incomplete beta function ratio is the probability that a |
|
||
//| random variable from a beta distribution having parameters p |
|
||
//| and q will be less than or equal to x. |
|
||
//| |
|
||
//| Input: |
|
||
//| x : upper limit of integration. x must be in (0,1) inclusive. |
|
||
//| p : first beta distribution parameter. p must be>0.0. |
|
||
//| q : second beta distribution parameter. q must be>0.0. |
|
||
//| |
|
||
//| Returns the value of the incomplete Beta function ratio. |
|
||
//| |
|
||
//| Original FORTRAN77 version by KL Majumder, GP Bhattacharjee. |
|
||
//| C version by John Burkardt. |
|
||
//| |
|
||
//| Reference: |
|
||
//| |
|
||
//| KL Majumder, GP Bhattacharjee, |
|
||
//| Algorithm AS 63: The incomplete Beta Integral, |
|
||
//| Applied Statistics,.Volume 22, Number 3, 1973, pages 409-411. |
|
||
//+------------------------------------------------------------------+
|
||
double MathBetaIncomplete(const double x,const double p,const double q)
|
||
{
|
||
double acu=0.1E-16;
|
||
double pp,qq,xx;
|
||
int ifault=0;
|
||
double value=x;
|
||
//--- check the input arguments
|
||
if(p<=0.0 || q<=0.0)
|
||
{
|
||
ifault=1;
|
||
return(value);
|
||
}
|
||
//--- check x range
|
||
if(x<0.0 || 1.0<x)
|
||
{
|
||
ifault=2;
|
||
return(value);
|
||
}
|
||
//--- special cases
|
||
if(x==0.0 || x==1.0)
|
||
{
|
||
return(value);
|
||
}
|
||
//--- calc beta log
|
||
double beta_log=MathGammaLog(p)+MathGammaLog(q)-MathGammaLog(p+q);
|
||
//--- change tail if necessary and determine S
|
||
double psq= p+q;
|
||
double cx = 1.0-x;
|
||
|
||
int indx=0;
|
||
if(p<psq*x)
|
||
{
|
||
xx = cx;
|
||
cx = x;
|
||
pp = q;
|
||
qq = p;
|
||
indx=1;
|
||
}
|
||
else
|
||
{
|
||
xx = x;
|
||
pp = p;
|
||
qq = q;
|
||
indx=0;
|
||
}
|
||
|
||
value=1.0;
|
||
double term=1.0;
|
||
double ai=1.0;
|
||
int ns=(int)(qq+cx*psq);
|
||
//--- use the Soper reduction formula
|
||
double rx=xx/cx;
|
||
double temp=qq-ai;
|
||
|
||
if(ns==0.0)
|
||
{
|
||
rx=xx;
|
||
}
|
||
|
||
for(;;)
|
||
{
|
||
term=term*temp*rx/(pp+ai);
|
||
value= value+term;;
|
||
temp = MathAbs(term);
|
||
//---
|
||
if(temp<=acu && temp<=acu*value)
|
||
{
|
||
value=value*MathExp(pp*MathLog(xx)+(qq-1.0)*MathLog(cx)-beta_log)/pp;
|
||
if(indx)
|
||
{
|
||
value=1.0-value;
|
||
}
|
||
break;
|
||
}
|
||
|
||
ai=ai+1.0;
|
||
ns--;
|
||
|
||
if(0<=ns)
|
||
{
|
||
temp=qq-ai;
|
||
if(ns==0)
|
||
{
|
||
rx=xx;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
temp= psq;
|
||
psq = psq+1.0;
|
||
}
|
||
}
|
||
//--- return result
|
||
return(value);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Incomplete Gamma function |
|
||
//+------------------------------------------------------------------+
|
||
//| Inputs: |
|
||
//| x : value at which the c.d.f is to be computed |
|
||
//| alpha : parameter of the gamma function (>0) |
|
||
//+------------------------------------------------------------------+
|
||
//| Comment from original FORTRAN code: |
|
||
//| www.nist.gov/sites/default/files/documents/itl/sed/stspac.f |
|
||
//| ibid .../itl/sed/SED_Note_86-2-2.pdf |
|
||
//| |
|
||
//| CDFGAM Written by Charles p. Reeve, Statistical Engineering |
|
||
//| Division, National Bureau of Standards, Gaithersburg. |
|
||
//| |
|
||
//| Computing the cumulative distribution function of the Gamma |
|
||
//| distribution (also known as the Incomplete Gamma ratio) to a |
|
||
//| specified accuracy (truncation error in the infinite series). |
|
||
//| the algorithm, described in Ref. 2, is a modification of |
|
||
//| the algorithm of Ref. 1. Three features have been added: |
|
||
//| |
|
||
//| 1) A precise method of meeting the truncation accuracy, |
|
||
//| 2) Computation of the upper tail area by decrementing alpha |
|
||
//| when that method is more efficient, and |
|
||
//| 3) A constant uflo >= the underflow limit on the computer. |
|
||
//| |
|
||
//| References: |
|
||
//| |
|
||
//| 1) Lau, Chi-Leung, 'A Simple Series for the Incomplete Gamma |
|
||
//| Integral', Algorithm AS 147, Applied Statistics, vol. 29, |
|
||
//| No. 1, 1980, pp. 113-114. |
|
||
//| |
|
||
//| 2) Reeve, Charles p., 'An Algorithm for Computing the Gamma |
|
||
//| C.D.F. to a Specified Accuracy', Statistical Engineering |
|
||
//| Division,Note 86-2, October 1986. |
|
||
//+------------------------------------------------------------------+
|
||
double MathGammaIncomplete(double x,double alpha)
|
||
{
|
||
double eps=10e-20;
|
||
int iflag=0;
|
||
bool ll;
|
||
int imax=5000;
|
||
double uflo=1.0e-100;
|
||
double cdfx=0.0;
|
||
int k=0;
|
||
//--- check for validity of arguments alpha and eps
|
||
if(alpha<=uflo || eps<=uflo)
|
||
{
|
||
iflag=1;
|
||
return(QNaN);
|
||
}
|
||
|
||
iflag=0;
|
||
//--- check for special case of x
|
||
if(x<=0.0)
|
||
return(QNaN);
|
||
//--- evaluate the gamma p.d.f. and check for underflow
|
||
double dx=double(x);
|
||
|
||
double pdfl=double(alpha-1.0)*MathLog(dx)-dx-MathGammaLog(alpha);
|
||
|
||
if(pdfl<MathLog(uflo))
|
||
{
|
||
if(x>=alpha)
|
||
cdfx=1.0;
|
||
}
|
||
else
|
||
{
|
||
double p=alpha;
|
||
double u=MathExp(pdfl);
|
||
//--- determine whether to increment or decrement alpha (a.k.a. p)
|
||
ll=true;
|
||
if(x>=p)
|
||
{
|
||
k=int(p);
|
||
|
||
if(p<=double(k))
|
||
k=k-1;
|
||
|
||
double eta=p-double(k);
|
||
double bl=double((eta-1.0)*MathLog(dx)-dx-MathGammaLog(eta));
|
||
ll=bl>MathLog(eps);
|
||
}
|
||
//---
|
||
double epsx=eps/x;
|
||
//---
|
||
if(ll==true)
|
||
{
|
||
//--- increment p
|
||
for(int i=0; i<=imax; i++)
|
||
{
|
||
if(u<=epsx*(p-x))
|
||
{
|
||
return(cdfx);
|
||
}
|
||
u=x*u/p;
|
||
cdfx=cdfx+u;
|
||
p=p+1.0;
|
||
}
|
||
iflag=2;
|
||
}
|
||
else
|
||
{
|
||
//--- decrement p
|
||
for(int j=1; j<=k; j++)
|
||
{
|
||
p=p-1.0;
|
||
|
||
if(u<=epsx*(x-p))
|
||
break;
|
||
|
||
cdfx=cdfx+u;
|
||
u=p*u/x;
|
||
}
|
||
cdfx=1.0-cdfx;
|
||
}
|
||
}
|
||
//--- return result
|
||
return(cdfx);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the binomial coefficient C(n,k)=n!/(k!*(n-k)!) |
|
||
//|
|
||
//| The value is calculated in such a way as to avoid overflow and |
|
||
//| roundoff. The calculation is done in integer arithmetic. |
|
||
//| |
|
||
//| Parameters: |
|
||
//| Input, int N, K, are the values of N and K. |
|
||
//| Output: the number of combinations of N things taken K at a time.|
|
||
//| |
|
||
//| Author: John Burkardt |
|
||
//| |
|
||
//| Reference: |
|
||
//| ML Wolfson, HV Wright, |
|
||
//| Algorithm 160: Combinatorial of M Things Taken N at a Time, |
|
||
//| Communications of the ACM, Volume 6, N4, April 1963, page 161. |
|
||
//+------------------------------------------------------------------+
|
||
long MathBinomialCoefficient(const int n,const int k)
|
||
{
|
||
int mn,mx;
|
||
long value=0;
|
||
int n_k=n-k;
|
||
//---
|
||
if(k<n_k)
|
||
{
|
||
mn = k;
|
||
mx = n_k;
|
||
}
|
||
else
|
||
{
|
||
mn = n_k;
|
||
mx = k;
|
||
}
|
||
if(mn>0)
|
||
{
|
||
value=mx+1;
|
||
for(int i=2; i<=mn; i++)
|
||
value=(value*(mx+i))/i;
|
||
}
|
||
else
|
||
{
|
||
if(mn<0)
|
||
return(0);
|
||
if(mn==0)
|
||
return(1);
|
||
}
|
||
//---
|
||
return(value);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBinomialCoefficientLog |
|
||
//+------------------------------------------------------------------+
|
||
double MathBinomialCoefficientLog(const int n,const int k)
|
||
{
|
||
int mn,mx;
|
||
long value=0;
|
||
int n_k=n-k;
|
||
//---
|
||
if(k<n_k)
|
||
{
|
||
mn = k;
|
||
mx = n_k;
|
||
}
|
||
else
|
||
{
|
||
mn = n_k;
|
||
mx = k;
|
||
}
|
||
if(mn>0)
|
||
{
|
||
value=mx+1;
|
||
for(int i=2; i<=mn; i++)
|
||
value=(value*(mx+i))/i;
|
||
}
|
||
else
|
||
{
|
||
if(mn<0)
|
||
return(QNEGINF);
|
||
if(mn==0)
|
||
return(0);
|
||
}
|
||
//---
|
||
return MathLog(value);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the logarithm of the Binomial coefficient. |
|
||
//| |
|
||
//| Log(C(n,k))=Log(n!/(k!*(n-k)!)) |
|
||
//| |
|
||
//| Parameters: |
|
||
//| Input, int n, k, are the values of n and k. |
|
||
//| Return value: the logarithm of C(n,k). |
|
||
//+------------------------------------------------------------------+
|
||
double MathBinomialCoefficientLog(const double n,const double k)
|
||
{
|
||
return(MathGammaLog(n+1)-MathGammaLog(k+1)-MathGammaLog(n-k+1));
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the function Hypergeometric_2F2(a,b,c,d,z) using |
|
||
//| a Taylor method. |
|
||
//| |
|
||
//| Author : John Pearson |
|
||
//| Reference : MSc thesis "Computation of Hypergeometric Functions" |
|
||
//+------------------------------------------------------------------+
|
||
double MathHypergeometric2F2(const double a,const double b,const double c,const double d,const double z)
|
||
{
|
||
double a1=1.0;
|
||
double b1=1.0;
|
||
double tol=10E-10; // set tolerance
|
||
//--- direct summation
|
||
for(int j=1; j<=500; j++)
|
||
{
|
||
//--- update current term in terms of previous one
|
||
a1=(a+j-1)*(b+j-1)/(c+j-1)/(d+j-1)*z/j*a1;
|
||
//--- update sum of terms computed so far
|
||
b1=b1+a1;
|
||
//--- terminate summation if stopping criterion is satisfied
|
||
if(MathAbs(a1)/MathAbs(b1)<tol)
|
||
return(b1);
|
||
}
|
||
//--- unknown
|
||
return(QNaN);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns log(0) depending on tail and log_mode arugments |
|
||
//+------------------------------------------------------------------+
|
||
double TailLog0(const bool tail,const bool log_mode)
|
||
{
|
||
if(tail==true)
|
||
{
|
||
if(log_mode==true)
|
||
return(QNEGINF);
|
||
else
|
||
return(0.0);
|
||
}
|
||
else
|
||
{
|
||
if(log_mode==true)
|
||
return(0.0);
|
||
else
|
||
return(1.0);
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns log(1) depending on tail and log_mode arugments |
|
||
//+------------------------------------------------------------------+
|
||
double TailLog1(const bool tail,const bool log_mode)
|
||
{
|
||
if(tail==true)
|
||
{
|
||
if(log_mode==true)
|
||
return(0.0);
|
||
else
|
||
return(1.0);
|
||
}
|
||
else
|
||
{
|
||
if(log_mode==true)
|
||
return(1.0);
|
||
else
|
||
return(0.0);
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns value depending on tail and log_mode arugments |
|
||
//+------------------------------------------------------------------+
|
||
double TailLogValue(const double value,const bool tail,const bool log_mode)
|
||
{
|
||
if(tail==true)
|
||
{
|
||
if(log_mode)
|
||
return MathLog(MathAbs(value));
|
||
else
|
||
return(value);
|
||
}
|
||
else
|
||
{
|
||
if(log_mode)
|
||
return MathLog(MathAbs(1.0-value));
|
||
else
|
||
return(1.0-value);
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns value depending on tail and log_mode arugments |
|
||
//+------------------------------------------------------------------+
|
||
double TailLogProbability(const double probability,const bool tail,const bool log_mode)
|
||
{
|
||
if(tail==true)
|
||
{
|
||
if(log_mode)
|
||
return MathExp(probability);
|
||
else
|
||
return(probability);
|
||
}
|
||
else
|
||
{
|
||
if(log_mode)
|
||
return(1.0-MathExp(probability));
|
||
else
|
||
return(1.0-probability);
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSequence |
|
||
//+------------------------------------------------------------------+
|
||
//| The function generates a sequence of double numbers |
|
||
//| with given starting and ending values and step. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| from : Starting value of the sequence |
|
||
//| to : Last value of the sequence |
|
||
//| step : Step of the sequence |
|
||
//| result[] : Array for the sequence values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSequence(const double from,const double to,const double step,double &result[])
|
||
{
|
||
//--- check NaN
|
||
if(!MathIsValidNumber(from) || !MathIsValidNumber(to) || !MathIsValidNumber(step))
|
||
return(false);
|
||
|
||
if(to<from)
|
||
return(false);
|
||
//--- calculate number of elements and prepare output array
|
||
int count=1+int((to-from)/step);
|
||
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- prepare sequence
|
||
for(int i=0; i<count; i++)
|
||
result[i]=from+i*step;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSequence |
|
||
//+------------------------------------------------------------------+
|
||
//| The function generates a sequence of integer numbers |
|
||
//| with given starting and ending values and step. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| from : Starting value of the sequence |
|
||
//| to : Last value of the sequence |
|
||
//| step : Step of the sequence |
|
||
//| result[] : Array for the sequence values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSequence(const int from,const int to,const int step,int &result[])
|
||
{
|
||
if(to<from)
|
||
return(false);
|
||
//--- calculate number of elements and prepare output array
|
||
int count=1+int((to-from)/step);
|
||
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- prepare sequence
|
||
for(int i=0; i<count; i++)
|
||
result[i]=from+i*step;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSequenceByCount |
|
||
//+------------------------------------------------------------------+
|
||
//| The function generates a sequence of double numbers |
|
||
//| with given starting and ending values and number of elements |
|
||
//| in the sequence. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| from : Starting value of the sequence |
|
||
//| to : Last value of the sequence |
|
||
//| count : Number of elements in the sequence |
|
||
//| result[] : Array for sequence values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSequenceByCount(const double from,const double to,const int count,double &result[])
|
||
{
|
||
//--- check NaN
|
||
if(!MathIsValidNumber(from) || !MathIsValidNumber(to))
|
||
return(false);
|
||
|
||
if(to<from || count<=0)
|
||
return(false);
|
||
//--- prepare output array
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- prepare sequence
|
||
double step=(count==1) ? 0 : ((to-from)/(count-1));
|
||
|
||
for(int i=0; i<count; i++)
|
||
result[i]=from+i*step;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSequenceByCount |
|
||
//+------------------------------------------------------------------+
|
||
//| The function generates a sequence of double numbers |
|
||
//| with given starting and ending values and number of elements |
|
||
//| in the sequence. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| from : Starting value of the sequence |
|
||
//| to : Last value of the sequence |
|
||
//| count : Number of elements in the sequence |
|
||
//| result[] : Array for sequence values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSequenceByCount(const int from,const int to,const int count,int &result[])
|
||
{
|
||
if(to<from || count<=0)
|
||
return(false);
|
||
//--- prepare output array
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- prepare sequence
|
||
int step=(count==1) ? 0 : ((to-from)/(count-1));
|
||
|
||
for(int i=0; i<count; i++)
|
||
result[i]=from+i*step;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathReplicate |
|
||
//+------------------------------------------------------------------+
|
||
//| The function replicates the sequence of double numbers |
|
||
//| from array[] with given times (count). |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values to replicate |
|
||
//| count : Number of elements in the sequence |
|
||
//| result[] : Array for sequence values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathReplicate(const double &array[],const int count,double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return(false);
|
||
//--- check replicate count
|
||
if(count<=0)
|
||
return(false);
|
||
|
||
//--- prepare output array
|
||
int target_size=size*count;
|
||
if(ArraySize(result)<target_size)
|
||
if(ArrayResize(result,target_size)!=target_size)
|
||
return(false);
|
||
|
||
//--- replicate array elements
|
||
for(int i=0; i<count; i++)
|
||
ArrayCopy(result,array,i*size,0,WHOLE_ARRAY);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathReplicate |
|
||
//+------------------------------------------------------------------+
|
||
//| The function replicates the sequence of integer numbers |
|
||
//| from array[] with given times (count). |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values to replicate |
|
||
//| count : Number of elements in the sequence |
|
||
//| result[] : Array for sequence values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathReplicate(const int &array[],const int count,int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return(false);
|
||
//--- check replicate count
|
||
if(count<=0)
|
||
return(false);
|
||
|
||
//--- prepare output array
|
||
int target_size=size*count;
|
||
if(ArraySize(result)<target_size)
|
||
if(ArrayResize(result,target_size)!=target_size)
|
||
return(false);
|
||
|
||
//--- replicate array elements
|
||
for(int i=0; i<count; i++)
|
||
ArrayCopy(result,array,i*size,0,WHOLE_ARRAY);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathReverse |
|
||
//+------------------------------------------------------------------+
|
||
//| The function reverses order of the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Array for reversed elements |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathReverse(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate elements of the reversed array
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
int idx=size-1-i;
|
||
result[idx]=array[i];
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathReverse |
|
||
//+------------------------------------------------------------------+
|
||
//| The function reverses order of the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Array for reversed elements |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathReverse(const int &array[],int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate elements of the reversed array
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
int idx=size-1-i;
|
||
result[idx]=array[i];
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathReverse |
|
||
//+------------------------------------------------------------------+
|
||
//| The function reverses order of the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathReverse(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return(false);
|
||
int count=size/2;
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
int idx=size-1-i;
|
||
//--- swap array[i] and array[size-1-i];
|
||
double t=array[i];
|
||
array[i]=array[idx];
|
||
array[idx]=t;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathReverse |
|
||
//+------------------------------------------------------------------+
|
||
//| The function reverses order of the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathReverse(int &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return(false);
|
||
int count=size/2;
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
int idx=size-1-i;
|
||
//--- swap array[i] and array[size-1-i];
|
||
int t=array[i];
|
||
array[i]=array[idx];
|
||
array[idx]=t;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathIdentical |
|
||
//+------------------------------------------------------------------+
|
||
//| The function compares two arrays. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array |
|
||
//| array2[] : Second array |
|
||
//| |
|
||
//| Return value: true if the arrays are equal, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathIdentical(const double &array1[],const double &array2[])
|
||
{
|
||
int size1=ArraySize(array1);
|
||
int size2=ArraySize(array1);
|
||
//--- check size of the arrays
|
||
if(size1!=size2)
|
||
return(false);
|
||
//--- check empty array case
|
||
if(size1==0)
|
||
return(false);
|
||
//--- check all array elements
|
||
for(int i=0; i<size1; i++)
|
||
{
|
||
if(array1[i]!=array2[i])
|
||
return(false);
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathIdentical |
|
||
//+------------------------------------------------------------------+
|
||
//| The function compares two arrays. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array |
|
||
//| array2[] : Second array |
|
||
//| |
|
||
//| Return value: true if the arrays are equal, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathIdentical(const int &array1[],const int &array2[])
|
||
{
|
||
int size1=ArraySize(array1);
|
||
int size2=ArraySize(array1);
|
||
//--- check size of the arrays
|
||
if(size1!=size2)
|
||
return(false);
|
||
//--- check empty array case
|
||
if(size1==0)
|
||
return(false);
|
||
//--- check all array elements
|
||
for(int i=0; i<size1; i++)
|
||
{
|
||
if(array1[i]!=array2[i])
|
||
return(false);
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathUnique |
|
||
//+------------------------------------------------------------------+
|
||
//| The function extracts the unique values from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Array for unique values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathUnique(const double &array[],double &result[])
|
||
{
|
||
//--- check array size
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
|
||
//--- prepare additional array
|
||
bool checked[];
|
||
if(ArrayResize(checked,size)!=size)
|
||
return(false);
|
||
ArrayFill(checked,0,size,false);
|
||
|
||
//--- prepare result array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- find unique elements
|
||
int unique_count=0;
|
||
double value=0;
|
||
for(;;)
|
||
{
|
||
bool flag=false;
|
||
for(int i=unique_count; i<size; i++)
|
||
{
|
||
if(!flag && !checked[i])
|
||
{
|
||
value=array[i];
|
||
result[unique_count]=array[i];
|
||
unique_count++;
|
||
checked[i]=true;
|
||
flag=true;
|
||
}
|
||
else
|
||
if(flag && value==array[i])
|
||
checked[i]=true;
|
||
}
|
||
if(!flag)
|
||
break;
|
||
}
|
||
//--- resize target array
|
||
ArrayResize(result,unique_count);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathUnique |
|
||
//+------------------------------------------------------------------+
|
||
//| The function extracts the unique values from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Array for unique values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathUnique(const int &array[],int &result[])
|
||
{
|
||
//--- check array size
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
|
||
//--- prepare additional array
|
||
bool checked[];
|
||
if(ArrayResize(checked,size)!=size)
|
||
return(false);
|
||
ArrayFill(checked,0,size,false);
|
||
|
||
//--- prepare result array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- find unique elements
|
||
int unique_count=0;
|
||
int value=0;
|
||
for(;;)
|
||
{
|
||
bool flag=false;
|
||
for(int i=unique_count; i<size; i++)
|
||
{
|
||
if(!flag && !checked[i])
|
||
{
|
||
value=array[i];
|
||
result[unique_count]=array[i];
|
||
unique_count++;
|
||
checked[i]=true;
|
||
flag=true;
|
||
}
|
||
else
|
||
if(flag && value==array[i])
|
||
checked[i]=true;
|
||
}
|
||
if(!flag)
|
||
break;
|
||
}
|
||
//--- resize target array
|
||
ArrayResize(result,unique_count);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathQuickSortAscending |
|
||
//+------------------------------------------------------------------+
|
||
//| The function sorts array[] and indices[] simultaneously |
|
||
//| using QuickSort algorithm. After sorting the initial ordering |
|
||
//| of the elements is located in the indices[] array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array : Array with values to sort |
|
||
//| indices : Targe array to sort |
|
||
//| first : First element index |
|
||
//| last : Last element index |
|
||
//| |
|
||
//| Return value: None |
|
||
//+------------------------------------------------------------------+
|
||
void MathQuickSortAscending(double &array[],int &indices[],int first,int last)
|
||
{
|
||
int i,j,t_int;
|
||
double p_double,t_double;
|
||
//--- check
|
||
if(first<0 || last<0)
|
||
return;
|
||
//--- sort
|
||
i=first;
|
||
j=last;
|
||
while(i<last)
|
||
{
|
||
//--- ">>1" is quick division by 2
|
||
p_double=array[(first+last)>>1];
|
||
while(i<j)
|
||
{
|
||
while(array[i]<p_double)
|
||
{
|
||
//--- control the output of the array bounds
|
||
if(i==ArraySize(array)-1)
|
||
break;
|
||
i++;
|
||
}
|
||
while(array[j]>p_double)
|
||
{
|
||
//--- control the output of the array bounds
|
||
if(j==0)
|
||
break;
|
||
j--;
|
||
}
|
||
if(i<=j)
|
||
{
|
||
//-- swap elements i and j
|
||
t_double=array[i];
|
||
array[i]=array[j];
|
||
array[j]=t_double;
|
||
//-- swap indices i and j
|
||
t_int=indices[i];
|
||
indices[i]=indices[j];
|
||
indices[j]=t_int;
|
||
i++;
|
||
//--- control the output of the array bounds
|
||
if(j==0)
|
||
break;
|
||
j--;
|
||
}
|
||
}
|
||
if(first<j)
|
||
MathQuickSortAscending(array,indices,first,j);
|
||
first=i;
|
||
j=last;
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathQuickSortDescending |
|
||
//+------------------------------------------------------------------+
|
||
//| The function sorts array[] and indices[] simultaneously |
|
||
//| using QuickSort algorithm. After sorting the initial ordering |
|
||
//| of the elements is located in the indices[] array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array : Array with values to sort |
|
||
//| indices : Targe array to sort |
|
||
//| first : First element index |
|
||
//| last : Last element index |
|
||
//| |
|
||
//| Return value: None |
|
||
//+------------------------------------------------------------------+
|
||
void MathQuickSortDescending(double &array[],int &indices[],int first,int last)
|
||
{
|
||
int i,j,t_int;
|
||
double p_double,t_double;
|
||
//--- check
|
||
if(first<0 || last<0)
|
||
return;
|
||
//--- sort
|
||
i=first;
|
||
j=last;
|
||
while(i<last)
|
||
{
|
||
//--- ">>1" is quick division by 2
|
||
p_double=array[(first+last)>>1];
|
||
while(i<j)
|
||
{
|
||
while(array[i]>p_double)
|
||
{
|
||
//--- control the output of the array bounds
|
||
if(i==ArraySize(array)-1)
|
||
break;
|
||
i++;
|
||
}
|
||
while(array[j]<p_double)
|
||
{
|
||
//--- control the output of the array bounds
|
||
if(j==0)
|
||
break;
|
||
j--;
|
||
}
|
||
if(i<=j)
|
||
{
|
||
//-- swap elements i and j
|
||
t_double=array[i];
|
||
array[i]=array[j];
|
||
array[j]=t_double;
|
||
//-- swap indices i and j
|
||
t_int=indices[i];
|
||
indices[i]=indices[j];
|
||
indices[j]=t_int;
|
||
i++;
|
||
//--- control the output of the array bounds
|
||
if(j==0)
|
||
break;
|
||
j--;
|
||
}
|
||
}
|
||
if(first<j)
|
||
MathQuickSortDescending(array,indices,first,j);
|
||
first=i;
|
||
j=last;
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathQuickSort |
|
||
//+------------------------------------------------------------------+
|
||
//| The function sorts array[] and indices[] simultaneously |
|
||
//| using QuickSort algorithm. After sorting the initial ordering |
|
||
//| of the elements is located in the indices[] array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array : Array with values to sort |
|
||
//| indices : Targe array to sort |
|
||
//| first : First element index |
|
||
//| last : Last element index |
|
||
//| mode : Sort direction (>0 ascending,otherwise descending) |
|
||
//| |
|
||
//| Return value: None |
|
||
//+------------------------------------------------------------------+
|
||
void MathQuickSort(double &array[],int &indices[],int first,int last,int mode)
|
||
{
|
||
if(mode>0)
|
||
MathQuickSortAscending(array,indices,first,last);
|
||
else
|
||
MathQuickSortDescending(array,indices,first,last);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathOrder |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates the order of elements from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Array for sorted indices |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathOrder(const double &array[],int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare temporary array
|
||
double tmp_array[];
|
||
ArrayCopy(tmp_array,array,0,0,WHOLE_ARRAY);
|
||
//--- prepare identical permutation
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
result[i]=i+1;
|
||
//--- calculate order of numbers
|
||
MathQuickSortAscending(tmp_array,result,0,size-1);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathOrder |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates the order of elements from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Array for sorted indices |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathOrder(const int &array[],int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare temporary array
|
||
double tmp_array[];
|
||
if(ArrayResize(tmp_array,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
tmp_array[i]=array[i];
|
||
//--- prepare identical permutation
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
result[i]=i+1;
|
||
//--- calculate order of numbers
|
||
MathQuickSortAscending(tmp_array,result,0,size-1);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseNot |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates NOT logical operation for elements |
|
||
//| of the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseNot(const int &array[],int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
|
||
//--- prepare target array and calculate ~array[i]
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
result[i]=~array[i];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseNot |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates NOT logical operation for elements |
|
||
//| of the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseNot(int &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate ~array[i]
|
||
for(int i=0; i<size; i++)
|
||
array[i]=~array[i];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseAnd |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates AND logical operation for elements |
|
||
//| of the array1[] and array2[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with values |
|
||
//| array2[] : Second array with values |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseAnd(const int &array1[],const int &array2[],int &result[])
|
||
{
|
||
int size1=ArraySize(array1);
|
||
int size2=ArraySize(array2);
|
||
if(size1==0 || size2==0 || size1!=size2)
|
||
return(false);
|
||
//--- prepare target array and calculate array1&array2
|
||
if(ArraySize(result)<size1)
|
||
if(ArrayResize(result,size1)!=size1)
|
||
return(false);
|
||
|
||
for(int i=0; i<size1; i++)
|
||
result[i]=array1[i]&array2[i];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseOr |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates OR logical operation for elements |
|
||
//| of the array1[] and array2[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with values |
|
||
//| array2[] : Second array with values |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseOr(const int &array1[],const int &array2[],int &result[])
|
||
{
|
||
int size1=ArraySize(array1);
|
||
int size2=ArraySize(array2);
|
||
if(size1==0 || size2==0 || size1!=size2)
|
||
return(false);
|
||
//--- prepare target array and calculate array1|array2
|
||
if(ArraySize(result)<size1)
|
||
if(ArrayResize(result,size1)!=size1)
|
||
return(false);
|
||
|
||
for(int i=0; i<size1; i++)
|
||
result[i]=array1[i]|array2[i];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseXor |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates XOR logical operation for elements |
|
||
//| of the array1[] and array2[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with values |
|
||
//| array2[] : Second array with values |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseXor(const int &array1[],const int &array2[],int &result[])
|
||
{
|
||
int size1=ArraySize(array1);
|
||
int size2=ArraySize(array2);
|
||
if(size1==0 || size2==0 || size1!=size2)
|
||
return(false);
|
||
//--- prepare target array and calculate array1^array2
|
||
if(ArraySize(result)<size1)
|
||
if(ArrayResize(result,size1)!=size1)
|
||
return(false);
|
||
|
||
for(int i=0; i<size1; i++)
|
||
result[i]=array1[i]^array2[i];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseShiftL |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates << logical operation for elements |
|
||
//| of the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| n : Number of bits to shift |
|
||
//| result[] : Array for sorted indices |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseShiftL(const int &array[],const int n,int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate array<<n
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
|
||
for(int i=0; i<size; i++)
|
||
result[i]=array[i]<<n;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseShiftL |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates << logical operation for elements |
|
||
//| of the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| n : Number of bits to shift |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseShiftL(int &array[],const int n)
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate array<<n
|
||
for(int i=0; i<size; i++)
|
||
array[i]=array[i]<<n;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseShiftR |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates >> logical operation for elements |
|
||
//| of the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| n : Number of bits to shift |
|
||
//| result[] : Array for sorted indices |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseShiftR(const int &array[],const int n,int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//---
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate array>>n
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
|
||
for(int i=0; i<size; i++)
|
||
result[i]=array[i]>>n;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathBitwiseShiftR |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates >> logical operation for elements |
|
||
//| of the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| n : Number of bits to shift |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathBitwiseShiftR(int &array[],const int n)
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate array>>n
|
||
for(int i=0; i<size; i++)
|
||
array[i]=array[i]>>n;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeSum |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cumulative sum of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with cumulative sum |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeSum(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate cumulative sum
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
|
||
double sum=0.0;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
//--- check value
|
||
if(!MathIsValidNumber(array[i]))
|
||
return(false);
|
||
sum+=array[i];
|
||
result[i]=sum;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeSum |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cumulative sum of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeSum(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate cumulative sum
|
||
double sum=0.0;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]))
|
||
return(false);
|
||
sum+=array[i];
|
||
array[i]=sum;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeProduct |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cumulative product of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with cumulative product |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeProduct(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate cumulative product
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
|
||
double product=1.0;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]))
|
||
return(false);
|
||
product*=array[i];
|
||
result[i]=product;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeProduct |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cumulative product of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeProduct(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate cumulative product
|
||
double product=1.0;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
//--- check value
|
||
if(!MathIsValidNumber(array[i]))
|
||
return(false);
|
||
product*=array[i];
|
||
array[i]=product;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeMin |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cumulative minimum of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with cumulative product |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeMin(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate cumulative min
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
|
||
double min=QPOSINF;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]) || !MathIsValidNumber(min))
|
||
min+=array[i];
|
||
else
|
||
min=MathMin(min,array[i]);
|
||
result[i]=min;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeMin |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cumulative minimum of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeMin(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
|
||
double min=QPOSINF;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]) || !MathIsValidNumber(min))
|
||
min+=array[i];
|
||
else
|
||
min=MathMin(min,array[i]);
|
||
array[i]=min;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeMax |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cumulative maximum of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with cumulative product |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeMax(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate cumulative max
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
|
||
double max=QNEGINF;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]) || !MathIsValidNumber(max))
|
||
max+=array[i];
|
||
else
|
||
max=MathMax(max,array[i]);
|
||
result[i]=max;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeMax |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cumulative maximum of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeMax(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
|
||
double max=QNEGINF;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]) || !MathIsValidNumber(max))
|
||
max+=array[i];
|
||
else
|
||
max=MathMax(max,array[i]);
|
||
array[i]=max;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSin |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates sin(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSin(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathSin(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSin |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates sin(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSin(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathSin(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCos |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cos(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCos(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathCos(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCos |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cos(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCos(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathCos(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTan |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates tan(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTan(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathTan(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTan |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates tan(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTan(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathTan(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArcsin |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Arcsin(x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArcsin(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathArcsin(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArcsin |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Arcsin(x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArcsin(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathArcsin(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArccos |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Arccos(x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArccos(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathArccos(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArccos |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Arccos(x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArccos(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathArccos(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArctan |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Arctan(x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArctan(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathArctan(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArctan |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Arctan(x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArctan(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathArctan(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSinPi |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates sin(pi*x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSinPi(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathSin(M_PI*array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSinPi |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates sin(pi*x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSinPi(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathSin(M_PI*array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCosPi |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cos(pi*x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCosPi(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathCos(M_PI*array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCosPi |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates cos(pi*x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCosPi(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathCos(M_PI*array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTanPi |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates tan(pi*x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTanPi(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathTan(M_PI*array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTanPi |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates tan(pi*x) for the elements |
|
||
//| from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTanPi(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathTan(M_PI*array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathAbs |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates abs(x) for the elements from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathAbs(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathAbs(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathAbs |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates abs(x) for the elements from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathAbs(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathAbs(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCeil |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates integer numberic values closest from |
|
||
//| above for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCeil(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate Ceil(array[i])
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathCeil(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCeil |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates integer numberic values closest from |
|
||
//| above for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCeil(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathCeil(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathFloor |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates integer numberic values closest from |
|
||
//| below for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathFloor(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate Floor(array[i])
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathFloor(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathFloor |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates integer numberic values closest from |
|
||
//| below for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathFloor(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathFloor(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTrunc |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates trunc(x) for the elements from the array.|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTrunc(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array and calculate Trunc(array[i])
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(array[i]>=0)
|
||
result[i]=MathFloor(array[i]);
|
||
else
|
||
result[i]=MathCeil(array[i]);
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTrunc |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates trunc(x) for the elements from the array.|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTrunc(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(array[i]>=0)
|
||
array[i]=MathFloor(array[i]);
|
||
else
|
||
array[i]=MathCeil(array[i]);
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSqrt |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates sqrt(x) for the elements from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSqrt(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathSqrt(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSqrt |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates sqrt(x) for the elements from the array. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSqrt(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathSqrt(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathExp |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates exp(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathExp(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathExp(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathExp |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates exp(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathExp(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathExp(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathPow |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Pow(x,power) for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathPow(const double &array[],const double power,double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- check NAN
|
||
if(!MathIsValidNumber(power))
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathPow(array[i],power);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathPow |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Pow(x,power) for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathPow(double &array[],const double power)
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- check NAN
|
||
if(!MathIsValidNumber(power))
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathPow(array[i],power);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates log(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathLog(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates log(x) for the elements from the array[].|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathLog(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates logarithm with the specified base |
|
||
//| for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog(const double &array[],const double base,double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- check NAN
|
||
if(!MathIsValidNumber(base))
|
||
return(false);
|
||
//--- check base
|
||
if(base==1.0 || base<=0.0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
double factor=1.0/MathLog(base);
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathLog(array[i])*factor;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates logarithm with the specified base |
|
||
//| for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog(double &array[],const double base)
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- check NAN
|
||
if(!MathIsValidNumber(base))
|
||
return(false);
|
||
//--- check base
|
||
if(base==1.0 || base<=0.0)
|
||
return(false);
|
||
//--- calculate values
|
||
double factor=1.0/MathLog(base);
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathLog(array[i])*factor;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog2 |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates logarithms on base 2 for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog2(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
static const double factor=1.0/M_LN2;
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathLog(array[i])*factor;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog2 |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates logarithms on base 2 for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog2(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
static const double factor=1.0/M_LN2;
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathLog(array[i])*factor;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog10 |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates logarithm on base 10 for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog10(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathLog10(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog10 |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates logarithm on base 10 for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog10(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathLog10(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArctan2 |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates polar angles of vector (x[i],y[i]) |
|
||
//| in range [-pi, pi] for the elements from the x[] and y[] arrays. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| x[] : Array with double values |
|
||
//| y[] : Array with double values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArctan2(const double &y[],const double &x[],double &result[])
|
||
{
|
||
int size=ArraySize(x);
|
||
if(size==0 || ArraySize(y)!=size)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathArctan2(y[i],x[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathRound |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates rounded values to a given precision |
|
||
//| for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| digits : Precision |
|
||
//| result[] : Output array with rounded values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathRound(const double &array[],int digits,double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
if(digits<0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathRound(array[i],digits);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathRound |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates rounded values to a given precision |
|
||
//| for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| digits : Precision |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathRound(double &array[],int digits)
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
if(digits<0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathRound(array[i],digits);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathDifference |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates laggged differences of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| lag : Lag value |
|
||
//| result[] : Output array with calculated differences |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathDifference(const double &array[],const int lag,double &result[])
|
||
{
|
||
int size=ArraySize(array)-lag;
|
||
if(lag<1 || size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=array[i+lag]-array[i];
|
||
//--- change array size for call with differences
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathDifference |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates laggged differences of the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with integer values |
|
||
//| lag : Lag value |
|
||
//| result[] : Output array with calculated differences |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathDifference(const int &array[],const int lag,int &result[])
|
||
{
|
||
int size=ArraySize(array)-lag;
|
||
if(lag<1 || size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=array[i+lag]-array[i];
|
||
//--- change array size for call with differences
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathDifference |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates laggged and iterated differences |
|
||
//| of the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| lag : Lag value |
|
||
//| differences : Number of iterations |
|
||
//| result[] : Output array with calculated differences |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathDifference(const double &array[],const int lag,const int differences,double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check parameters
|
||
if(size==0 || differences<0 || lag*differences>=size)
|
||
return(false);
|
||
//--- copy data from initial array
|
||
if(ArrayCopy(result,array,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
//--- calculate iterated differences
|
||
for(int i=0; i<differences; i++)
|
||
{
|
||
if(!MathDifference(result,lag,result))
|
||
return false;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathDifference |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates laggged and iterated differences |
|
||
//| of the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with integer values |
|
||
//| lag : Lag value |
|
||
//| differences : Number of iterations |
|
||
//| result[] : Output array with calculated differences |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathDifference(const int &array[],const int lag,const int differences,int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check parameters
|
||
if(size==0 || differences<0 || lag*differences>=size)
|
||
return(false);
|
||
//--- copy data from initial array
|
||
if(ArrayCopy(result,array,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
//--- calculate iterated differences
|
||
for(int i=0; i<differences; i++)
|
||
{
|
||
if(!MathDifference(result,lag,result))
|
||
return false;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSample |
|
||
//+------------------------------------------------------------------+
|
||
//| The function takes a sample of the specified size from the |
|
||
//| elements of the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| count : Number of elements to choose |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSample(const double &array[],const int count,double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return false;
|
||
//--- prepare target array and calculate values
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
int ind=(int)((ulong)size*MathRand()/32768);
|
||
result[i]=array[ind];
|
||
}
|
||
//---
|
||
return true;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSample |
|
||
//+------------------------------------------------------------------+
|
||
//| The function takes a sample of the specified size from the |
|
||
//| elements of the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with integer values |
|
||
//| count : Number of elements to choose |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSample(const int &array[],const int count,int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0)
|
||
return false;
|
||
//--- prepare target array and calculate values
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
int ind=(int)((ulong)size*MathRand()/32768);
|
||
result[i]=array[ind];
|
||
}
|
||
//---
|
||
return true;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSample |
|
||
//+------------------------------------------------------------------+
|
||
//| The function takes a sample of the specified size from the |
|
||
//| elements of the array[] with replacement. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| count : Number of elements to choose |
|
||
//| replace : If true, Sampling with Replacement will be used |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSample(const double &array[],const int count,const bool replace,double &result[])
|
||
{
|
||
//--- Sampling with Replacement
|
||
if(replace)
|
||
return MathSample(array,count,result);
|
||
|
||
int size=ArraySize(array);
|
||
if(size==0 || count>size)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- unique values needed, prepare indices
|
||
int indices[];
|
||
|
||
if(!MathSequenceByCount(0,size-1,size,indices))
|
||
return(false);
|
||
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
//--- select random index and swap items [j] and [i]
|
||
int j=i+int((ulong)(size-i)*MathRand()/32768);
|
||
|
||
if(j!=i)
|
||
{
|
||
int t=indices[i];
|
||
indices[i]=indices[j];
|
||
indices[j]=t;
|
||
}
|
||
}
|
||
//--- select data according to indices
|
||
for(int i=0; i<count; i++)
|
||
result[i]=array[indices[i]];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSample |
|
||
//+------------------------------------------------------------------+
|
||
//| The function takes a sample of the specified size from the |
|
||
//| elements of the array[] with replacement. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with integer values |
|
||
//| count : Number of elements to choose |
|
||
//| replace : If true, Sampling with Replacement will be used |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSample(const int &array[],const int count,const bool replace,int &result[])
|
||
{
|
||
//--- Sampling with Replacement
|
||
if(replace)
|
||
return MathSample(array,count,result);
|
||
|
||
int size=ArraySize(array);
|
||
if(size==0 || count>size)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- unique values needed, prepare indices
|
||
int indices[];
|
||
|
||
if(!MathSequenceByCount(0,size-1,size,indices))
|
||
return(false);
|
||
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
//--- select random index and swap items [j] and [i]
|
||
int j=i+int((ulong)(size-i)*MathRand()/32768);
|
||
|
||
if(j!=i)
|
||
{
|
||
int t=indices[i];
|
||
indices[i]=indices[j];
|
||
indices[j]=t;
|
||
}
|
||
}
|
||
//--- select data according to indices
|
||
for(int i=0; i<count; i++)
|
||
result[i]=array[indices[i]];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSample |
|
||
//+------------------------------------------------------------------+
|
||
//| The function takes a sample of the specified size from the |
|
||
//| elements of the array[] according to the given probabilities. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| probabilities[] : Array with probabilities |
|
||
//| count : Number of elements to choose |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSample(const double &array[],double &probabilities[],const int count,double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0 || size!=ArraySize(probabilities))
|
||
return(false);
|
||
|
||
if(count<=0)
|
||
return(false);
|
||
|
||
//--- probabilities
|
||
double prob[];
|
||
if(ArrayCopy(prob,probabilities,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
//--- calculate sum and normalize probabilities
|
||
double sum=0;
|
||
for(int i=0; i<size; i++)
|
||
sum+=prob[i];
|
||
|
||
if(sum==0.0)
|
||
return(false);
|
||
|
||
sum=1.0/sum;
|
||
|
||
for(int i=0; i<size; i++)
|
||
prob[i]*=sum;
|
||
//--- prepare indices
|
||
int indices[];
|
||
if(ArrayResize(indices,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
indices[i]=i;
|
||
//--- sort and prepare cumulative probabilities
|
||
MathQuickSortDescending(prob,indices,0,size-1);
|
||
for(int i=1; i<size; i++)
|
||
prob[i]+=prob[i-1];
|
||
//--- prepare target array and calculate values
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- prepare random samples according to given probabilities
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
double prb=MathRand()/32767.0;
|
||
for(int k=0; k<size; k++)
|
||
{
|
||
if(prb<=prob[k])
|
||
{
|
||
result[i]=array[indices[k]];
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//---
|
||
return true;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSample |
|
||
//+------------------------------------------------------------------+
|
||
//| The function takes a sample of the specified size from the |
|
||
//| elements of the array[] according to the given probabilities. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with integer values |
|
||
//| probabilities[] : Array with probabilities |
|
||
//| count : Number of elements to choose |
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSample(const int &array[],double &probabilities[],const int count,int &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0 || size!=ArraySize(probabilities))
|
||
return(false);
|
||
|
||
if(count<=0)
|
||
return(false);
|
||
|
||
//--- probabilities
|
||
double prob[];
|
||
if(ArrayCopy(prob,probabilities,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
//--- calculate sum and normalize probabilities
|
||
double sum=0;
|
||
for(int i=0; i<size; i++)
|
||
sum+=prob[i];
|
||
|
||
if(sum==0.0)
|
||
return(false);
|
||
|
||
sum=1.0/sum;
|
||
|
||
for(int i=0; i<size; i++)
|
||
prob[i]*=sum;
|
||
//--- prepare indices
|
||
int indices[];
|
||
if(ArrayResize(indices,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
indices[i]=i;
|
||
//--- sort and prepare cumulative probabilities
|
||
MathQuickSortDescending(prob,indices,0,size-1);
|
||
for(int i=1; i<size; i++)
|
||
prob[i]+=prob[i-1];
|
||
//--- prepare target array and calculate values
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- prepare random samples according to given probabilities
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
double prb=MathRand()/32767.0;
|
||
for(int k=0; k<size; k++)
|
||
{
|
||
if(prb<=prob[k])
|
||
{
|
||
result[i]=array[indices[k]];
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//---
|
||
return true;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSample |
|
||
//+------------------------------------------------------------------+
|
||
//| The function takes a sample of the specified size from the |
|
||
//| elements of the array[] according to the given probabilities. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| probabilities[] : Array with probabilities |
|
||
//| count : Number of elements to choose |
|
||
//| replace : If true, Sampling with Replacement will be used|
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSample(const double &array[],double &probabilities[],const int count,const bool replace,double &result[])
|
||
{
|
||
//--- Sampling with Replacement
|
||
if(replace)
|
||
return MathSample(array,probabilities,count,result);
|
||
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0 || size!=ArraySize(probabilities))
|
||
return(false);
|
||
//--- return false if count>total samples
|
||
if(count<=0 || count>size)
|
||
return(false);
|
||
|
||
//--- probabilities
|
||
double prob[];
|
||
if(ArrayCopy(prob,probabilities,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
//--- calculate sum and normalize probabilities
|
||
double sum=0;
|
||
for(int i=0; i<size; i++)
|
||
sum+=prob[i];
|
||
|
||
if(sum==0.0)
|
||
return(false);
|
||
|
||
sum=1.0/sum;
|
||
|
||
for(int i=0; i<size; i++)
|
||
prob[i]*=sum;
|
||
//--- prepare indices
|
||
int indices[];
|
||
if(ArrayResize(indices,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
indices[i]=i;
|
||
//--- sort and prepare cumulative probabilities
|
||
MathQuickSortDescending(prob,indices,0,size-1);
|
||
for(int i=1; i<size; i++)
|
||
prob[i]+=prob[i-1];
|
||
//--- prepare array for taken values flag
|
||
bool taken_values[];
|
||
if(ArrayResize(taken_values,size)!=size)
|
||
return(false);
|
||
ArrayFill(taken_values,0,size,false);
|
||
//--- prepare target array and calculate values
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- prepare random samples according to given probabilities
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
double prb=MathRand()/32767.0;
|
||
for(int k=0; k<size; k++)
|
||
{
|
||
int ind=indices[k];
|
||
//--- check also if the value has been already taken
|
||
if(prb<=prob[k] && taken_values[ind]==false)
|
||
{
|
||
result[i]=array[ind];
|
||
taken_values[ind]=true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//---
|
||
return true;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSample |
|
||
//+------------------------------------------------------------------+
|
||
//| The function takes a sample of the specified size from the |
|
||
//| elements of the array[] according to the given probabilities. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with integer values |
|
||
//| probabilities[] : Array with probabilities |
|
||
//| count : Number of elements to choose |
|
||
//| replace : If true, Sampling with Replacement will be used|
|
||
//| result[] : Output array |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSample(const int &array[],double &probabilities[],const int count,const bool replace,int &result[])
|
||
{
|
||
//--- Sampling with Replacement
|
||
if(replace)
|
||
return MathSample(array,probabilities,count,result);
|
||
|
||
int size=ArraySize(array);
|
||
//--- check array size
|
||
if(size==0 || size!=ArraySize(probabilities))
|
||
return(false);
|
||
//--- return false if count>total samples
|
||
if(count<=0 || count>size)
|
||
return(false);
|
||
|
||
//--- probabilities
|
||
double prob[];
|
||
if(ArrayCopy(prob,probabilities,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
//--- calculate sum and normalize probabilities
|
||
double sum=0;
|
||
for(int i=0; i<size; i++)
|
||
sum+=prob[i];
|
||
|
||
if(sum==0.0)
|
||
return(false);
|
||
|
||
sum=1.0/sum;
|
||
|
||
for(int i=0; i<size; i++)
|
||
prob[i]*=sum;
|
||
//--- prepare indices
|
||
int indices[];
|
||
if(ArrayResize(indices,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
indices[i]=i;
|
||
//--- sort and prepare cumulative probabilities
|
||
MathQuickSortDescending(prob,indices,0,size-1);
|
||
for(int i=1; i<size; i++)
|
||
prob[i]+=prob[i-1];
|
||
//--- prepare array for taken values flag
|
||
bool taken_values[];
|
||
if(ArrayResize(taken_values,size)!=size)
|
||
return(false);
|
||
ArrayFill(taken_values,0,size,false);
|
||
//--- prepare target array and calculate values
|
||
if(ArraySize(result)<count)
|
||
if(ArrayResize(result,count)!=count)
|
||
return(false);
|
||
//--- prepare random samples according to given probabilities
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
double prb=MathRand()/32767.0;
|
||
for(int k=0; k<size; k++)
|
||
{
|
||
int ind=indices[k];
|
||
//--- check also if the value has been already taken
|
||
if(prb<=prob[k] && taken_values[ind]==false)
|
||
{
|
||
result[i]=array[ind];
|
||
taken_values[ind]=true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//---
|
||
return true;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTukeySummary |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Tukey's five number summary. |
|
||
//| It consists of the five most important sample percentiles: |
|
||
//| 1) the sample minimum (smallest observation) |
|
||
//| 2) the lower quartile or first quartile (0.25 quantile) |
|
||
//| 3) the median (middle value) |
|
||
//| 4) the upper quartile or third quartile (0.75 quantile) |
|
||
//| 5) the sample maximum (largest observation) |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| removeNAN : Flag, if true, all NaN values will be removed |
|
||
//| minimum : Output variable for minimum value |
|
||
//| lower_hinge : Output variable for 0.25 quantile |
|
||
//| median : Output variable for median value |
|
||
//| upper_hinge : Output variable for 0.75 quantile |
|
||
//| maximum : Output variable for maximum value |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTukeySummary(const double &array[],const bool removeNAN,double &minimum,double &lower_hinge,double &median,double &upper_hinge,double &maximum)
|
||
{
|
||
//--- set default values
|
||
minimum=QNaN;
|
||
lower_hinge=QNaN;
|
||
median=QNaN;
|
||
upper_hinge=QNaN;
|
||
maximum=QNaN;
|
||
//--- check array size
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
|
||
double data[];
|
||
if(ArrayResize(data,size)!=size)
|
||
return(false);
|
||
|
||
int actual_values=0;
|
||
if(removeNAN==true)
|
||
{
|
||
//--- remove NAN values (copy non-NAN elements)
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(MathIsValidNumber(array[i]))
|
||
{
|
||
data[actual_values]=array[i];
|
||
actual_values++;
|
||
}
|
||
}
|
||
//--- set actual size
|
||
ArrayResize(data,actual_values);
|
||
}
|
||
else
|
||
{
|
||
//--- check NAN and return if NAN found
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]))
|
||
return(false);
|
||
}
|
||
//--- otherwise copy data
|
||
if(ArrayCopy(data,array,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
}
|
||
//--- sort array
|
||
ArraySort(data);
|
||
int n=ArraySize(data);
|
||
if(n==0)
|
||
return(false);
|
||
//--- prepare indices
|
||
double n4=MathFloor((n+3)*0.5)*0.5;
|
||
double ind[5];
|
||
ind[0]=0;
|
||
ind[1]=n4-1;
|
||
ind[2]=0.5*(n+1)-1;
|
||
ind[3]=n-n4;
|
||
ind[4]=n-1;
|
||
//--- calculate values
|
||
minimum=0.5*(data[(int)MathFloor(ind[0])]+data[(int)MathCeil(ind[0])]);
|
||
lower_hinge=0.5*(data[(int)MathFloor(ind[1])]+data[(int)MathCeil(ind[1])]);
|
||
median=0.5*(data[(int)MathFloor(ind[2])]+data[(int)MathCeil(ind[2])]);
|
||
upper_hinge=0.5*(data[(int)MathFloor(ind[3])]+data[(int)MathCeil(ind[3])]);
|
||
maximum=0.5*(data[(int)MathFloor(ind[4])]+data[(int)MathCeil(ind[4])]);
|
||
//--- successful
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the minimum and maximum of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
bool MathRange(const double &array[],double &min,double &max)
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- default values, find minimum and maximum values
|
||
min=array[0];
|
||
max=array[0];
|
||
for(int i=1; i<size; i++)
|
||
{
|
||
double value=array[i];
|
||
min=MathMin(min,value);
|
||
max=MathMax(max,value);
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the minimum value in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathMin(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(QNaN);
|
||
double min_value=array[0];
|
||
for(int i=1; i<size; i++)
|
||
min_value=MathMin(min_value,array[i]);
|
||
//--- return minimum value
|
||
return(min_value);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the maximum value in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathMax(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(QNaN);
|
||
double max_value=array[0];
|
||
for(int i=1; i<size; i++)
|
||
max_value=MathMax(max_value,array[i]);
|
||
//--- return maximum value
|
||
return(max_value);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the sum of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathSum(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(QNaN);
|
||
//--- calculate sum
|
||
double sum=0.0;
|
||
for(int i=0; i<size; i++)
|
||
sum+=array[i];
|
||
//--- return sum
|
||
return(sum);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the product of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathProduct(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(QNaN);
|
||
//--- calculate product
|
||
double product=1.0;
|
||
for(int i=0; i<size; i++)
|
||
product*=array[i];
|
||
//--- return product
|
||
return(product);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the standard deviation of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathStandardDeviation(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size<=1)
|
||
return(QNaN);
|
||
//--- calculate mean
|
||
double mean=0.0;
|
||
for(int i=0; i<size; i++)
|
||
mean+=array[i];
|
||
//--- average mean
|
||
mean=mean/size;
|
||
//--- calculate standard deviation
|
||
double sdev=0;
|
||
for(int i=0; i<size; i++)
|
||
sdev+=MathPow(array[i]-mean,2);
|
||
//--- return standard deviation
|
||
return MathSqrt(sdev/(size-1));
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the average absolute deviation of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathAverageDeviation(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size<=1)
|
||
return(QNaN);
|
||
//--- calculate mean
|
||
double mean=0.0;
|
||
for(int i=0; i<size; i++)
|
||
mean+=array[i];
|
||
mean=mean/size;
|
||
//--- calculate average deviation
|
||
double adev=0;
|
||
for(int i=0; i<size; i++)
|
||
adev+=MathAbs(array[i]-mean);
|
||
adev=adev/size;
|
||
//--- return average deviation
|
||
return(adev);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the median value of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathMedian(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check data range
|
||
if(size==0)
|
||
return(QNaN);
|
||
//--- prepare sorted values
|
||
double sorted_values[];
|
||
if(ArrayCopy(sorted_values,array,0,0,WHOLE_ARRAY)!=size)
|
||
return(QNaN);
|
||
ArraySort(sorted_values);
|
||
//--- calculate median for odd and even cases
|
||
//--- data_count=odd
|
||
if(size%2==1)
|
||
return(sorted_values[size/2]);
|
||
//--- data_count=even
|
||
return(0.5*(sorted_values[(size-1)/2]+sorted_values[(size+1)/2]));
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the mean value of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathMean(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check data range
|
||
if(size<1)
|
||
return(QNaN); // need at least 1 observation
|
||
//--- calculate mean
|
||
double mean=0.0;
|
||
for(int i=0; i<size; i++)
|
||
mean+=array[i];
|
||
mean=mean/size;
|
||
//--- return mean
|
||
return(mean);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the variance of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathVariance(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check data range
|
||
if(size<2)
|
||
return(QNaN); // need at least 2 observations
|
||
//--- calculate mean
|
||
double mean=0.0;
|
||
for(int i=0; i<size; i++)
|
||
mean+=array[i];
|
||
mean=mean/size;
|
||
//--- calculate variance
|
||
double variance=0;
|
||
for(int i=0; i<size; i++)
|
||
variance+=MathPow(array[i]-mean,2);
|
||
variance=variance/(size-1);
|
||
//--- return variance
|
||
return(variance);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the skewness of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathSkewness(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check data range
|
||
if(size<3)
|
||
return(QNaN); // need at least 3 observations
|
||
//--- calculate mean
|
||
double mean=0.0;
|
||
for(int i=0; i<size; i++)
|
||
mean+=array[i];
|
||
mean=mean/size;
|
||
//--- calculate variance and skewness
|
||
double variance=0;
|
||
double skewness=0;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
double sqr_dev=MathPow(array[i]-mean,2);
|
||
skewness+=sqr_dev*(array[i]-mean);
|
||
variance+=sqr_dev;
|
||
}
|
||
variance=(variance)/(size-1);
|
||
double v3=MathPow(MathSqrt(variance),3);
|
||
//---
|
||
if(v3!=0)
|
||
{
|
||
skewness=skewness/(size*v3);
|
||
//--- return skewness
|
||
return(skewness);
|
||
}
|
||
else
|
||
return(QNaN);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Computes the kurtosis of the values in array[] |
|
||
//+------------------------------------------------------------------+
|
||
double MathKurtosis(const double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
//--- check data range
|
||
if(size<4)
|
||
return(QNaN); // need at least 4 observations
|
||
//--- calculate mean
|
||
double mean=0.0;
|
||
for(int i=0; i<size; i++)
|
||
mean+=array[i];
|
||
mean=mean/size;
|
||
//--- calculate variance and kurtosis
|
||
double variance=0;
|
||
double kurtosis=0;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
double sqr_dev=MathPow(array[i]-mean,2);
|
||
variance+=sqr_dev;
|
||
kurtosis+=sqr_dev*sqr_dev;
|
||
}
|
||
//--- calculate variance
|
||
variance=(variance)/(size-1);
|
||
double v4=MathPow(MathSqrt(variance),4);
|
||
|
||
if(v4!=0)
|
||
{
|
||
//--- calculate kurtosis
|
||
kurtosis=kurtosis/(size*v4);
|
||
kurtosis-=3;
|
||
//--- return kurtosis
|
||
return(kurtosis);
|
||
}
|
||
else
|
||
return(QNaN);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog1p |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates log(1+x) for the elements from the array.|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog1p(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathLog1p(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathLog1p |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates log(1+x) for the elements from the array.|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathLog1p(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathLog1p(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathExpm1 |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates exp(x)-1 for the elements from the array.|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathExpm1(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathExpm1(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathExpm1 |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates exp(x)-1 for the elements from the array.|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathExpm1(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathExpm1(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSinh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates hyperbolic sine for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSinh(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathSinh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSinh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates hyperbolic sine for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSinh(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathSinh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCosh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates hyperbolic cosine for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCosh(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathCosh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCosh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates hyperbolic cosine for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCosh(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathCosh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTanh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates hyperbolic tangent for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTanh(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathTanh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathTanh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates hyperbolic tangent for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathTanh(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathTanh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArcsinh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates inverse hyperbolic sine for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArcsinh(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathArcsinh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArcsinh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates inverse hyperbolic sine for the elements |
|
||
//| from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArcsinh(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathArcsinh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArccosh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates inverse hyperbolic cosine for |
|
||
//| the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArccosh(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathArccosh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArccosh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates inverse hyperbolic cosine for |
|
||
//| the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArccosh(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathArccosh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArctanh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates inverse hyperbolic tangent for |
|
||
//| the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArctanh(const double &array[],double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathArctanh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathArctanh |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates inverse hyperbolic tangent for |
|
||
//| the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathArctanh(double &array[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathArctanh(array[i]);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Rounds the value to the specified number of significant digits |
|
||
//+------------------------------------------------------------------+
|
||
double MathSignif(const double x,const int digits)
|
||
{
|
||
if(x==0)
|
||
return x;
|
||
|
||
int dig=digits;
|
||
if(dig>30)
|
||
return x;
|
||
if(dig<1)
|
||
dig=1;
|
||
|
||
double sign=1.0;
|
||
double xx=x;
|
||
if(xx<0.0)
|
||
{
|
||
sign=-sign;
|
||
xx=-xx;
|
||
}
|
||
//--- calculate log
|
||
double l10 = MathLog10(xx);
|
||
double e10 = (int)(dig-1-MathFloor(l10));
|
||
double value=0,pwr10;
|
||
if(e10>0)
|
||
{
|
||
pwr10=MathPow(10,e10);
|
||
value=MathFloor((xx*pwr10)+0.5)/pwr10;
|
||
}
|
||
else
|
||
{
|
||
pwr10=MathPow(10,-e10);
|
||
value=MathFloor((xx/pwr10)+0.5)*pwr10;
|
||
}
|
||
return(sign*value);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSignif |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates the rounded values (to the specified |
|
||
//| number of significant digits) for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| digits : Number of significant digits |
|
||
//| result[] : Output array with calculated values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSignif(const double &array[],int digits,double &result[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- prepare target array
|
||
if(ArraySize(result)<size)
|
||
if(ArrayResize(result,size)!=size)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
result[i]=MathSignif(array[i],digits);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathSignif |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates the rounded values (to the specified |
|
||
//| number of significant digits) for the elements from the array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with double values |
|
||
//| digits : Number of significant digits |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathSignif(double &array[],int digits)
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- calculate values
|
||
for(int i=0; i<size; i++)
|
||
array[i]=MathSignif(array[i],digits);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathRank |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates tied ranks for the elements of the array.|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Input array with double values |
|
||
//| rank[] : Output array with ranked values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
//| Code from ALGLIB numerical analysis and data processing library |
|
||
//+------------------------------------------------------------------+
|
||
bool MathRank(const double &array[],double &rank[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size<1)
|
||
return(false);
|
||
if(size==1)
|
||
{
|
||
if(ArrayResize(rank,size)!=size)
|
||
return(false);
|
||
rank[0]=1;
|
||
return(true);
|
||
}
|
||
//--- prepare arrays
|
||
double values[];
|
||
int indices[];
|
||
if(ArrayCopy(values,array,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
if(!MathSequenceByCount(0,size,size,indices))
|
||
return(false);
|
||
if(ArrayResize(rank,size)!=size)
|
||
return(false);
|
||
//---
|
||
int i,j,k,t,tmpi;
|
||
double tmp;
|
||
//--- sort
|
||
if(size!=1)
|
||
{
|
||
i=2;
|
||
do
|
||
{
|
||
t=i;
|
||
while(t!=1)
|
||
{
|
||
k=t/2;
|
||
if(values[k-1]>=values[t-1])
|
||
t=1;
|
||
else
|
||
{
|
||
//--- swap
|
||
tmp=values[k-1];
|
||
values[k-1]=values[t-1];
|
||
values[t-1]=tmp;
|
||
tmpi=indices[k-1];
|
||
indices[k-1]=indices[t-1];
|
||
indices[t-1]=tmpi;
|
||
t=k;
|
||
}
|
||
}
|
||
i=i+1;
|
||
}
|
||
while(i<=size);
|
||
i=size-1;
|
||
do
|
||
{
|
||
//--- swap
|
||
tmp=values[i];
|
||
values[i]=values[0];
|
||
values[0]=tmp;
|
||
tmpi=indices[i];
|
||
indices[i]=indices[0];
|
||
indices[0]=tmpi;
|
||
t=1;
|
||
while(t!=0)
|
||
{
|
||
k=2*t;
|
||
if(k>i)
|
||
t=0;
|
||
else
|
||
{
|
||
if(k<i)
|
||
if(values[k]>values[k-1])
|
||
k++;
|
||
if(values[t-1]>=values[k-1])
|
||
t=0;
|
||
else
|
||
{
|
||
//--- swap
|
||
tmp=values[k-1];
|
||
values[k-1]=values[t-1];
|
||
values[t-1]=tmp;
|
||
tmpi=indices[k-1];
|
||
indices[k-1]=indices[t-1];
|
||
indices[t-1]=tmpi;
|
||
t=k;
|
||
}
|
||
}
|
||
}
|
||
i=i-1;
|
||
}
|
||
while(i>=1);
|
||
}
|
||
//--- compute tied ranks
|
||
i=0;
|
||
while(i<size)
|
||
{
|
||
j=i+1;
|
||
while(j<size)
|
||
{
|
||
//--- check
|
||
if(values[j]!=values[i])
|
||
break;
|
||
j=j+1;
|
||
}
|
||
for(k=i; k<j; k++)
|
||
values[k]=1+(i+j-1)*0.5;
|
||
i=j;
|
||
}
|
||
//--- set output values
|
||
for(i=0; i<size; i++)
|
||
rank[indices[i]]=values[i];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathRank |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates tied ranks for the elements of the array.|
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Input array with integer values |
|
||
//| rank[] : Output array with ranked values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
//| Code from ALGLIB numerical analysis and data processing library |
|
||
//+------------------------------------------------------------------+
|
||
bool MathRank(const int &array[],double &rank[])
|
||
{
|
||
int size=ArraySize(array);
|
||
if(size<1)
|
||
return(false);
|
||
if(size==1)
|
||
{
|
||
if(ArrayResize(rank,size)!=size)
|
||
return(false);
|
||
rank[0]=1;
|
||
return(true);
|
||
}
|
||
//--- prepare arrays
|
||
double values[];
|
||
int indices[];
|
||
|
||
if(ArrayResize(values,size)!=size)
|
||
return(false);
|
||
for(int i=0; i<size; i++)
|
||
values[i]=array[i];
|
||
|
||
if(!MathSequenceByCount(0,size,size,indices))
|
||
return(false);
|
||
if(ArrayResize(rank,size)!=size)
|
||
return(false);
|
||
//---
|
||
int i,j,k,t,tmpi;
|
||
double tmp;
|
||
//--- sort
|
||
if(size!=1)
|
||
{
|
||
i=2;
|
||
do
|
||
{
|
||
t=i;
|
||
while(t!=1)
|
||
{
|
||
k=t/2;
|
||
if(values[k-1]>=values[t-1])
|
||
t=1;
|
||
else
|
||
{
|
||
//--- swap
|
||
tmp=values[k-1];
|
||
values[k-1]=values[t-1];
|
||
values[t-1]=tmp;
|
||
tmpi=indices[k-1];
|
||
indices[k-1]=indices[t-1];
|
||
indices[t-1]=tmpi;
|
||
t=k;
|
||
}
|
||
}
|
||
i=i+1;
|
||
}
|
||
while(i<=size);
|
||
i=size-1;
|
||
do
|
||
{
|
||
//--- swap
|
||
tmp=values[i];
|
||
values[i]=values[0];
|
||
values[0]=tmp;
|
||
tmpi=indices[i];
|
||
indices[i]=indices[0];
|
||
indices[0]=tmpi;
|
||
t=1;
|
||
while(t!=0)
|
||
{
|
||
k=2*t;
|
||
if(k>i)
|
||
t=0;
|
||
else
|
||
{
|
||
if(k<i)
|
||
if(values[k]>values[k-1])
|
||
k++;
|
||
if(values[t-1]>=values[k-1])
|
||
t=0;
|
||
else
|
||
{
|
||
//--- swap
|
||
tmp=values[k-1];
|
||
values[k-1]=values[t-1];
|
||
values[t-1]=tmp;
|
||
tmpi=indices[k-1];
|
||
indices[k-1]=indices[t-1];
|
||
indices[t-1]=tmpi;
|
||
t=k;
|
||
}
|
||
}
|
||
}
|
||
i=i-1;
|
||
}
|
||
while(i>=1);
|
||
}
|
||
//--- compute tied ranks
|
||
i=0;
|
||
while(i<size)
|
||
{
|
||
j=i+1;
|
||
while(j<size)
|
||
{
|
||
//--- check
|
||
if(values[j]!=values[i])
|
||
break;
|
||
j=j+1;
|
||
}
|
||
for(k=i; k<j; k++)
|
||
values[k]=1+(i+j-1)*0.5;
|
||
i=j;
|
||
}
|
||
//--- set output values
|
||
for(i=0; i<size; i++)
|
||
rank[indices[i]]=values[i];
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCorrelationPearson |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Pearson product-moment correlation |
|
||
//| coefficient. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with double values |
|
||
//| array2[] : Second array with double values |
|
||
//| r : Variable for calculated value of the Pearson r |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
//| Code from ALGLIB numerical analysis and data processing library |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCorrelationPearson(const double &array1[],const double &array2[],double &r)
|
||
{
|
||
r=QNaN;
|
||
int size=ArraySize(array1);
|
||
if(size<=1 || ArraySize(array2)!=size)
|
||
return(false);
|
||
//--- create variables
|
||
double xmean=0;
|
||
double ymean=0;
|
||
double v=1.0/(double)size;
|
||
double x0=array1[0];
|
||
double y0=array2[0];
|
||
double s=0;
|
||
double xv=0;
|
||
double yv=0;
|
||
double t1=0;
|
||
double t2=0;
|
||
bool samex=true;
|
||
bool samey=true;
|
||
//--- additonally we calculate SameX and SameY - flag variables which are set to true
|
||
//--- when all X[] (or Y[]) contain exactly same value.
|
||
//--- if at least one of them is true, we return zero
|
||
//--- (othwerwise we risk to get nonzero correlation because of roundoff).
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
s=array1[i];
|
||
samex=samex && s==x0;
|
||
xmean+=s*v;
|
||
s=array2[i];
|
||
samey=samey && s==y0;
|
||
ymean+=s*v;
|
||
}
|
||
//--- check
|
||
if(samex || samey)
|
||
return(false);
|
||
//--- calculation
|
||
s=0;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
t1=array1[i]-xmean;
|
||
t2=array2[i]-ymean;
|
||
xv+=t1*t1;
|
||
yv+=t2*t2;
|
||
s+=t1*t2;
|
||
}
|
||
//--- check
|
||
if(xv==0 || yv==0)
|
||
return(false);
|
||
//---
|
||
r=s/MathSqrt(xv*yv);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCorrelationPearson |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Pearson product-moment correlation |
|
||
//| coefficient. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with integer values |
|
||
//| array2[] : Second array with integer values |
|
||
//| r : Variable for calculated value of the Pearson r |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
//| Code from ALGLIB numerical analysis and data processing library |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCorrelationPearson(const int &array1[],const int &array2[],double &r)
|
||
{
|
||
r=QNaN;
|
||
int size=ArraySize(array1);
|
||
if(size<=1 || ArraySize(array2)!=size)
|
||
return(false);
|
||
//--- create variables
|
||
double xmean=0;
|
||
double ymean=0;
|
||
double v=1.0/(double)size;
|
||
double x0=array1[0];
|
||
double y0=array2[0];
|
||
double s=0;
|
||
double xv=0;
|
||
double yv=0;
|
||
double t1=0;
|
||
double t2=0;
|
||
bool samex=true;
|
||
bool samey=true;
|
||
//--- additonally we calculate SameX and SameY - flag variables which are set to true
|
||
//--- when all X[] (or Y[]) contain exactly same value.
|
||
//--- if at least one of them is true, we return zero
|
||
//--- (othwerwise we risk to get nonzero correlation because of roundoff).
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
s=array1[i];
|
||
samex=samex && s==x0;
|
||
xmean+=s*v;
|
||
s=array2[i];
|
||
samey=samey && s==y0;
|
||
ymean+=s*v;
|
||
}
|
||
//--- check
|
||
if(samex || samey)
|
||
return(false);
|
||
//--- calculation
|
||
s=0;
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
t1=array1[i]-xmean;
|
||
t2=array2[i]-ymean;
|
||
xv+=t1*t1;
|
||
yv+=t2*t2;
|
||
s+=t1*t2;
|
||
}
|
||
//--- check
|
||
if(xv==0 || yv==0)
|
||
return(false);
|
||
//---
|
||
r=s/MathSqrt(xv*yv);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCorrelationSpearman |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Spearman correlation coefficient. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with double values |
|
||
//| array2[] : Second array with double values |
|
||
//| r : Variable for calculated value of the Spearman r |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
//| Code from ALGLIB numerical analysis and data processing library |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCorrelationSpearman(const double &array1[],const double &array2[],double &r)
|
||
{
|
||
r=QNaN;
|
||
int size=ArraySize(array1);
|
||
if(size<1 || ArraySize(array2)!=size)
|
||
return(false);
|
||
//--- calculate ranks
|
||
double rank_x[];
|
||
double rank_y[];
|
||
if(!MathRank(array1,rank_x))
|
||
return(false);
|
||
if(!MathRank(array2,rank_y))
|
||
return(false);
|
||
//---
|
||
return MathCorrelationPearson(rank_x,rank_y,r);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCorrelationSpearman |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Spearman correlation coefficient. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with integer values |
|
||
//| array2[] : Second array with integer values |
|
||
//| r : Variable for calculated value of the Spearman r |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
//| Code from ALGLIB numerical analysis and data processing library |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCorrelationSpearman(const int &array1[],const int &array2[],double &r)
|
||
{
|
||
r=QNaN;
|
||
int size=ArraySize(array1);
|
||
if(size<1 || ArraySize(array2)!=size)
|
||
return(false);
|
||
//--- calculate ranks
|
||
double rank_x[];
|
||
double rank_y[];
|
||
if(!MathRank(array1,rank_x))
|
||
return(false);
|
||
if(!MathRank(array2,rank_y))
|
||
return(false);
|
||
//---
|
||
return MathCorrelationPearson(rank_x,rank_y,r);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCorrelationKendall |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Kendall's tau correlation coefficient. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with double values |
|
||
//| array2[] : Second array with double values |
|
||
//| tau : Variable for calculated value of the Kendall's tau |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCorrelationKendall(const double &array1[],const double &array2[],double &tau)
|
||
{
|
||
tau=QNaN;
|
||
int size=ArraySize(array1);
|
||
if(size==0 || ArraySize(array2)!=size)
|
||
return(false);
|
||
//---
|
||
int cnt1=0,cnt2=0,cnt=0;
|
||
//---
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
for(int j=i+1; j<size; j++)
|
||
{
|
||
double delta1=array1[i]-array1[j];
|
||
double delta2=array2[i]-array2[j];
|
||
double delta=delta1*delta2;
|
||
if(delta==0)
|
||
{
|
||
if(delta1!=0)
|
||
cnt1++;
|
||
if(delta2!=0)
|
||
cnt2++;
|
||
}
|
||
else
|
||
{
|
||
cnt1++;
|
||
cnt2++;
|
||
if(delta>0.0)
|
||
cnt++;
|
||
else
|
||
cnt--;
|
||
}
|
||
}
|
||
}
|
||
//--- calculate Kendall tau
|
||
double den=cnt1*cnt2;
|
||
if(den==0)
|
||
return(false);
|
||
tau=cnt/MathSqrt(den);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCorrelationKendall |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates Kendall's tau correlation coefficient. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array1[] : First array with integer values |
|
||
//| array2[] : Second array with integer values |
|
||
//| tau : Variable for calculated value of the Kendall's tau |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCorrelationKendall(const int &array1[],const int &array2[],double &tau)
|
||
{
|
||
tau=QNaN;
|
||
int size=ArraySize(array1);
|
||
if(size==0 || ArraySize(array2)!=size)
|
||
return(false);
|
||
//---
|
||
int cnt1=0,cnt2=0,cnt=0;
|
||
//---
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
for(int j=i+1; j<size; j++)
|
||
{
|
||
double delta1=array1[i]-array1[j];
|
||
double delta2=array2[i]-array2[j];
|
||
double delta=delta1*delta2;
|
||
if(delta==0)
|
||
{
|
||
if(delta1!=0)
|
||
cnt1++;
|
||
if(delta2!=0)
|
||
cnt2++;
|
||
}
|
||
else
|
||
{
|
||
cnt1++;
|
||
cnt2++;
|
||
if(delta>0.0)
|
||
cnt++;
|
||
else
|
||
cnt--;
|
||
}
|
||
}
|
||
}
|
||
//--- calculate Kendall tau
|
||
double den=cnt1*cnt2;
|
||
if(den==0)
|
||
return(false);
|
||
tau=cnt/MathSqrt(den);
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathQuantile |
|
||
//+------------------------------------------------------------------+
|
||
//| The function produces sample quantiles corresponding to the |
|
||
//| given probabilities. The smallest observation corresponds |
|
||
//| to a probability of 0.0 and the largest to a probability of 1.0. |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates estimates of underlying distribution |
|
||
//| quantiles based on one or two order statistics from the supplied |
|
||
//| elements in x at probabilities in probs. |
|
||
//| |
|
||
//| Reference: |
|
||
//| Hyndman, R. J. and Fan, Y. (1996) |
|
||
//| "Sample quantiles in statistical packages", |
|
||
//| American Statistician, vol.50, pp. 361–365. |
|
||
//+------------------------------------------------------------------+
|
||
//| All sample quantiles are defined as weighted averages |
|
||
//| of consecutive order statistics. |
|
||
//| Sample quantiles of type i are defined by: |
|
||
//| Q[i](p) = (1 - gamma)*x[j] + gamma*x[j+1] |
|
||
//| |
|
||
//| The function MathQuantile calculates quantiles according to |
|
||
//| default type in R (type=7) |
|
||
//| p(k) = (k - 1)/(n - 1). |
|
||
//| In this case, p(k) = mode[F(x[k])]. This is used by S. |
|
||
//+------------------------------------------------------------------+
|
||
bool MathQuantile(const double &array[],const double &probs[],double &quantile[])
|
||
{
|
||
int size=ArraySize(array);
|
||
int size_p=ArraySize(probs);
|
||
|
||
if(size==0 || size_p==0)
|
||
return(false);
|
||
|
||
//--- check probability
|
||
for(int i=0; i<size_p; i++)
|
||
{
|
||
//--- check NaN
|
||
if(!MathIsValidNumber(probs[i]))
|
||
return(false);
|
||
//--- check probability range
|
||
if(probs[i]<0.0 || probs[i]>1.0)
|
||
return(false);
|
||
}
|
||
//--- prepare array with values
|
||
double x_values[];
|
||
if(ArrayCopy(x_values,array,0,0,WHOLE_ARRAY)!=size)
|
||
return(false);
|
||
//--- prepare output array
|
||
if(ArraySize(quantile)<size_p)
|
||
if(ArrayResize(quantile,size_p)!=size_p)
|
||
return(false);
|
||
|
||
double ind[];
|
||
int lo[];
|
||
int hi[];
|
||
ArrayResize(ind,size_p);
|
||
ArrayResize(lo,size_p);
|
||
ArrayResize(hi,size_p);
|
||
//--- calculate ranges
|
||
for(int i=0; i<size_p; i++)
|
||
{
|
||
ind[i]=(size-1)*probs[i];
|
||
lo[i]=(int)MathFloor(ind[i]);
|
||
hi[i]=(int)MathCeil(ind[i]);
|
||
}
|
||
//--- calculate quantiles
|
||
int indices[];
|
||
MathSequenceByCount(0,size-1,size,indices);
|
||
MathQuickSort(x_values,indices,0,size-1,1);
|
||
for(int i=0; i<size_p; i++)
|
||
{
|
||
quantile[i]=x_values[lo[i]];
|
||
if(ind[i]>lo[i])
|
||
{
|
||
double gamma=(ind[i]-lo[i]);
|
||
quantile[i]=(1.0-gamma)*quantile[i]+gamma*x_values[hi[i]];
|
||
}
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathProbabilityDensityEmpirical |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates the empirical probability density |
|
||
//| function (pdf) for random values from array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with random values |
|
||
//| count : Data count, total count pairs (x,pdf(x)) |
|
||
//| x[] : Output array for x values |
|
||
//| pdf[] : Output array for empirical pdf(x) values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathProbabilityDensityEmpirical(const double &array[],const int count,double &x[],double &pdf[])
|
||
{
|
||
if(count<=1)
|
||
return(false);
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- check NaN values
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]))
|
||
return(false);
|
||
}
|
||
//--- prepare output arrays
|
||
if(ArraySize(x)<count)
|
||
if(ArrayResize(x,count)!=count)
|
||
return(false);
|
||
if(ArraySize(pdf)<count)
|
||
if(ArrayResize(pdf,count)!=count)
|
||
return(false);
|
||
//--- search for min,max and range
|
||
double minv=array[0];
|
||
double maxv=array[0];
|
||
for(int i=1; i<size; i++)
|
||
{
|
||
minv=MathMin(minv,array[i]);
|
||
maxv=MathMax(maxv,array[i]);
|
||
}
|
||
double range=maxv-minv;
|
||
if(range==0)
|
||
return(false);
|
||
//--- calculate probability density of the empirical distribution
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
x[i]=minv+i*range/(count-1);
|
||
pdf[i]=0;
|
||
}
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
double v=(array[i]-minv)/range;
|
||
int ind=int((v*(count-1)));
|
||
pdf[ind]++;
|
||
}
|
||
//--- normalize values
|
||
double dx=range/count;
|
||
double sum=0;
|
||
for(int i=0; i<count; i++)
|
||
sum+=pdf[i]*dx;
|
||
if(sum==0)
|
||
return(false);
|
||
double coef=1.0/sum;
|
||
for(int i=0; i<count; i++)
|
||
pdf[i]*=coef;
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| MathCumulativeDistributionEmpirical |
|
||
//+------------------------------------------------------------------+
|
||
//| The function calculates the empirical cumulative distribution |
|
||
//| function (cdf) for random values from array[]. |
|
||
//| |
|
||
//| Arguments: |
|
||
//| array[] : Array with random values |
|
||
//| count : Data count, total count pairs (x,cdf(x)) |
|
||
//| x[] : Output array for x values |
|
||
//| cdf[] : Output array for empirical cdf(x) values |
|
||
//| |
|
||
//| Return value: true if successful, otherwise false |
|
||
//+------------------------------------------------------------------+
|
||
bool MathCumulativeDistributionEmpirical(const double &array[],const int count,double &x[],double &cdf[])
|
||
{
|
||
if(count<=1)
|
||
return(false);
|
||
int size=ArraySize(array);
|
||
if(size==0)
|
||
return(false);
|
||
//--- check NaN values
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
if(!MathIsValidNumber(array[i]))
|
||
return(false);
|
||
}
|
||
//--- prepare output arrays
|
||
if(ArraySize(x)<count)
|
||
if(ArrayResize(x,count)!=count)
|
||
return(false);
|
||
if(ArraySize(cdf)<count)
|
||
if(ArrayResize(cdf,count)!=count)
|
||
return(false);
|
||
//--- search for min,max and range
|
||
double minv=array[0];
|
||
double maxv=array[0];
|
||
for(int i=1; i<size; i++)
|
||
{
|
||
minv=MathMin(minv,array[i]);
|
||
maxv=MathMax(maxv,array[i]);
|
||
}
|
||
double range=maxv-minv;
|
||
if(range==0)
|
||
return(false);
|
||
//--- calculate probability density of the empirical distribution
|
||
double pdf[];
|
||
if(ArrayResize(pdf,count)!=count)
|
||
return(false);
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
x[i]=minv+i*range/(count-1);
|
||
pdf[i]=0;
|
||
}
|
||
for(int i=0; i<size; i++)
|
||
{
|
||
double v=(array[i]-minv)/range;
|
||
int ind=int((v*(count-1)));
|
||
pdf[ind]++;
|
||
}
|
||
//--- normalize values
|
||
double dx=range/count;
|
||
double sum=0;
|
||
for(int i=0; i<count; i++)
|
||
sum+=pdf[i]*dx;
|
||
if(sum==0)
|
||
return(false);
|
||
double coef=1.0/sum;
|
||
for(int i=0; i<count; i++)
|
||
pdf[i]*=coef;
|
||
//--- calculate cumulative distribution function
|
||
sum=0.0;
|
||
for(int i=0; i<count; i++)
|
||
{
|
||
sum+=pdf[i]*dx;
|
||
cdf[i]=sum;
|
||
}
|
||
//---
|
||
return(true);
|
||
}
|
||
//+------------------------------------------------------------------+
|