| //+------------------------------------------------------------------+
|
| //| Math.mqh |
|
| //| Copyright 2000-2025, MetaQuotes Ltd. |
|
| //| https://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);
|
| }
|
| //+------------------------------------------------------------------+
|
