Добавил:

Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.

Вуз:

Московский авиационный институт (национальный исследовательский университет)

Предмет:

[НЕСОРТИРОВАННОЕ]

Файл:

Описание использования комплекса и входящих в н...doc

Скачиваний:

Добавлен:

17.08.2019

Размер:

357.89 Кб

Скачать

☆

<<< < Предыдущая 1 2 3 45 / 55

2.9 Вычисление функции многомерного нормального распределения.

Комплекс предоставляет набор функций для вычисления функции двух- и трехмерного нормального распределения.

Для вычисления функции двумерного нормального распределения применяется функция FPQ_Distr_N_2D. Результат вычислений возвращается как значение функции. Функция имеет следующий прототип:

REAL FPQ_Distr_N_2D(

REAL x,

REAL y,

REAL sigma[2][2],

int nPrecision

)

Функция имеет следующие параметры:

x – входной параметр; значение аргумента, для которого вычисляется функция стандартного нормального распределения.
y – входной параметр; значение аргумента, для которого вычисляется функция стандартного нормального распределения.
sigma – входной параметр; ковариационная матрица размерностью 2x2.
nPrecision – входной параметр; одно из предопределенных значений точности вычислений.

При вызове данной функции в зависимости значения аргумента и требуемой точности комплексом выбирается оптимальный алгоритм вычисления.

Для вычисления функции трехмерного нормального распределения применяется функция FPQ_Distr_N_3D. Результат вычислений возвращается как значение функции. Функция имеет следующий прототип:

REAL FPQ_Distr_N_3D(

REAL x,

REAL y,

REAL z,

REAL sigma[3][3],

int nPrecision

)

Функция имеет следующие параметры:

x – входной параметр; значение аргумента, для которого вычисляется функция стандартного нормального распределения.
y – входной параметр; значение аргумента, для которого вычисляется функция стандартного нормального распределения.
z – входной параметр; значение аргумента, для которого вычисляется функция стандартного нормального распределения.
sigma – входной параметр; ковариационная матрица размерностью 3x3.
nPrecision – входной параметр; одно из предопределенных значений точности вычислений.

2.10 Вычисление радиуса доверительного шара.

Комплекс предоставляет набор функций для вычисления радиуса доверительног шара для многомерного нормального распределения.

Для вычисления вычисления радиуса доверительног шара для многомерного нормального распределения применяется функция FPQ_3dr. Результат вычислений возвращается как значение функции. Функция имеет следующий прототип:

REAL FPQ_3dr(

REAL alpha,

int Dimension,

int nPrecision

)

Функция имеет следующие параметры:

alpha – входной параметр; значение доверительного уровня, для которого вычисляется радиус шара.
Dimension – входной параметр; размерность пространства.
nPrecision – входной параметр; одно из предопределенных значений точности вычислений.

2.11 Пример использования комплекса.

В качестве примера использования комплекса приведен текст программы, позволяющей вычислить значение квантили и радиуса доверительного шара. Для вычисления квантили необходимо в параметрах командной строка задать значение аргумента, результат печатается на стандартный выход программы. Для вычисления радиуса доверительного шара необходимо в параметрах командной строки задать доверительный уровень и размерность пространства, результат печатается на стандартный выход программы. Пример написан без использования платформенно-зависимых расширений и для его компиляции может использоваться любой компилятор C++.

Текст примера находиться в приложении.

Приложение 4.

Исходные тексты комплекса.

// Файл fpq_3dr.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////

// Вычисление радиуса доверительного шара

/////////////////////////////////////////////////////

#include "fpq.h"

REAL FPQ_3dr_if_even(REAL r, int n_div, int nPrecision)

{

REAL sum=1.0, mul=1.0, r2=r*r;

REAL i;

if( r < FPQ_GetPrecisionValue(nPrecision) )

{

return(0.0);

}

for(i=1.; i<n_div; i++)

{

mul*=r2/(2.*i);

sum+=mul;

}

return( 1. - sum*exp(-0.5*r2) );

}

REAL FPQ_3dr_if_odd(REAL r, int n_div, int nPrecision)

{

REAL sum=0.0, mul=r, r2=r*r;

REAL i;

if( r < FPQ_GetPrecisionValue(nPrecision) )

{

return(0.0);

}

for(i=0.; i<n_div; i++)

{

mul/=(2.*i+1.);

sum+=mul;

mul*=r2;

}

return( 2.*(FPQ_Distr_N_01(r,nPrecision) - 0.5) - FPQ_SQRT2*FPQ_1_SQRTPI*sum*exp(-0.5*r2) );

}

// dichotomy

REAL FPQ_3dr(REAL alpha, int Dimension, int nPrecision)

{

REAL a=0.0, b=1.0, c=0.;

int n_div=Dimension/2;

if( Dimension & 0x01 == 0 ) // четный

{

while( FPQ_3dr_if_even(b,n_div,nPrecision)<alpha )

{

a=b;

b*=2.;

}

while( (b-a)>FPQ_GetPrecisionValue(nPrecision) )

{

c=0.5*(a + b);

if( FPQ_3dr_if_even(c,n_div,nPrecision)<alpha )

{

a=c;

}

else

{

b=c;

}

else // нечетный

{

while( FPQ_3dr_if_odd(b,n_div,nPrecision)<alpha )

{

a=b;

b*=2.;

}

while( (b-a)>FPQ_GetPrecisionValue(nPrecision) )

{

c=0.5*(a + b);

if( FPQ_3dr_if_odd(c,n_div,nPrecision)<alpha )

{

a=c;

}

else

{

b=c;

}

return( 0.5*(a+b) );

}

// Файл fpq_f.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление функции нецентрального F-распределения

//////////////////////////////////////////////////////

#include "fpq.h"

REAL FPQ_F_i_IntFunc(REAL t, REAL * pFuncParam)

{

REAL x = pFuncParam[0];

REAL n1 = pFuncParam[1];

REAL n2 = pFuncParam[2];

REAL b1 = pFuncParam[3];

REAL b2 = pFuncParam[4];

// t=t*t*t*t*t;

REAL t2=FPQ_SQR(t);

REAL y=n1*x/n2;

REAL y2=FPQ_SQR(y);

REAL res;

if(t==0.0) return(0.0);

res=exp( (-0.5*b1*t2)/(1.+t2) - 0.5*(b2*y2*t2)/(1.+y2*t2) );

res/=FPQ_POW( t*(1.+t2), 0.25*n1 );

res/=FPQ_POW((1.+y2*t2), 0.25*n2 );

res*=sin( 0.25*n1*atan(t) - 0.25*n2*atan(y*t) + 0.5*b1*t/(1.+t2) - 0.5*b2*y*t/(1.+y2*t2) );

return(res);

}

REAL FPQ_Distr_F(REAL x, int n1, int n2, REAL b1, REAL b2, int nPrecision)

{

REAL aFuncParam[]={x, (REAL)(n1), (REAL)(n2), b1, b2};

// return(0.5 - FPQ_1_PI*FPQ_Int_Simpson(0.0, 50.0, FPQ_Precision_10_2/*nPrecision*/, FPQ_F_i_IntFunc, aFuncParam));

return(0.5 - FPQ_1_PI*FPQ_Int_Simpson_N(0.0, 50.0, 100, FPQ_F_i_IntFunc, aFuncParam));

}

REAL FPQ_F_ii(REAL x, int n1, int n2, REAL b1, REAL b2,int nPrecision)

{

REAL n=100.;

REAL y=n1*x/n2;

REAL s=y*y;

REAL r=(n1+n2)*2.5;

REAL h=exp( -(log(r*1.e-07)+n2*log(y)/2)/r )/n;

REAL f=0.0;

for( REAL i=1.; i<n; i+=1. )

{

REAL t=i*h;

REAL p=t*t*t*t*t;

REAL q=p*p;

REAL r=1.+ q;

REAL z=1.+ s*q;

f+=exp( -(b1/r+s*b2/z)*q/2.-(n2*log(z)+n1*log(r))/4. )*

sin((n1*atan(p)-n2*atan(y*p)+(b1/r-y*b2/z)*p)/2.)/t*

(4. + 2.*(i - i/2.*2. - 1.));

}

return( 0.5-f*h*FPQ_1_PI );

}

// Файл fpq_fi_h.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление функции нормального распределения

//////////////////////////////////////////////////////

#include "fpq.h"

///////////////////////////////////////////////////////

// Common procedure to calculate Distr Func N(0,1)

//////////////////////////////////////////////////////

REAL FPQ_Distr_N_01(REAL x, int nPrecision)

{

REAL x_abs=fabs(x);

REAL x_neg=0;

REAL res;

if( x < 0.0 )

{

x=x_abs;

x_neg=1;

}

if( x_abs <= 2.5 ) // Shenton

{

if( x_abs <= 0.1 )

{

res=(FPQ_fih1_Iter5(x));

}

else if( x_abs <= 0.7 )

{

res=(FPQ_fih1_Iter10(x));

}

else if( x_abs <= 1.5 )

{

res=(FPQ_fih1_Iter15(x));

}

else if( x_abs <= 2.3 )

{

res=(FPQ_fih1_Iter20(x));

}

else

{

res=(FPQ_fih1_Iter25(x));

}

else if( x_abs <= 3.5 ) // Laplas

{

if( x_abs <= 3.2 )

{

res=(FPQ_fih2_Iter25(x));

}

else

{

res=(FPQ_fih2_Iter20(x));

}

else if ( x_abs <= 4.2 ) // Gray

{

res=(FPQ_fih34(x));

}

else // Ruben #1

{

res=(FPQ_fih31(x));

}

if( 0 == x_neg ) return( res );

else return( 1. - res );

}

REAL FPQ_Mills_R(REAL x, int nPrecision)

{

// REAL fi=FPQ_fi_low(x);

// REAL res=(1. - FPQ_Distr_N_01(x,nPrecision))/FPQ_fi_low(x);

// return(res );

REAL R=

(

1./

(x + 1./ // 1

(x + 2./ // 2

(x + 3./ // 3

(x + 4./ // 4

(x + 5./ // 5

(x + 6./ // 6

(x + 7./ // 7

(x + 8./ // 8

(x + 9./ // 9

(x + 10./ // 10

(x + 11./ // 11

(x + 12./ // 12

(x + 13./ // 13

(x + 14./ // 14

(x + 15./ // 15

(x + 16./ // 16

(x + 17./ // 17

(x + 18./ // 18

(x + 19./ // 19

(x + 20./ // 20

(x + 21./ // 21

(x + 22./ // 22

(x + 23./ // 23

(x + 24./ // 24

(x + 25. // 25

)))))))))))))))))))))))))

);

return(R);

}

REAL FPQ_Distr_N(REAL x, REAL m, REAL sigma, int nPrecision)

{

return( FPQ_Distr_N_01( (x - m)/sigma ,nPrecision) );

}

REAL FPQ_Distr_N_01_HiPrec(REAL x)

{

REAL x_abs=fabs(x);

if( x_abs <= 2.5 ) // Shenton

{

return(FPQ_fih1_Iter25(x));

}

else // Laplas

{

return(FPQ_fih2_Iter25(x));

}

//////////////////////////////////////////////////////////////////

REAL FPQ_fih_i(REAL x, int num_end);

REAL FPQ_fih_i2(REAL sqr_x, int i, int num_end);

REAL FPQ_fih_ii(REAL x, int num_end);

REAL FPQ_fih_ii2(REAL x, int i, int num_end);

REAL FPQ_fih_iii1(REAL x);

REAL FPQ_fih_iii2(REAL x);

REAL FPQ_fih_iii3(REAL x);

REAL FPQ_fih_iii4(REAL x);

///////////////////////////////////////////////////////

// Shenon

//////////////////////////////////////////////////////

REAL FPQ_fih1(REAL x, int num_end)

{

return(0.5+FPQ_fih_i(x,num_end)*FPQ_fi_low(x));

}

REAL FPQ_fih_i(REAL x, int num_end)

{

return( x/( (REAL)1.0-FPQ_fih_i2(x*x,1,num_end) ) );

}

REAL FPQ_fih_i2(REAL sqr_x, int i, int num_end)

{

if( i < num_end )

{

if( (i&0x01)==0x00 )//((i<<1)+1)

return(i*sqr_x)/( (i*2+1)-FPQ_fih_i2(sqr_x,i+1,num_end) );

else

return(i*sqr_x)/( (i*2+1)+FPQ_fih_i2(sqr_x,i+1,num_end) );

}

else

{

return(i*sqr_x);

}

///////////////////////////////////////////////////////

// Inline Iteration : Shenton

///////////////////////////////////////////////////////

REAL FPQ_fih1_Iter5(REAL x)

{

REAL sqr_x=FPQ_SQR(x);

REAL fi=

(

(1. - sqr_x/ // 1

(3. + 2. *sqr_x/ // 2

(5. - 3. *sqr_x/ // 3

(7. + 4. *sqr_x/ // 4

(9. - 5. *sqr_x // 5

)))))

);

return(0.5+fi*FPQ_fi_low(x));

}

REAL FPQ_fih1_Iter10(REAL x)

{

REAL sqr_x=FPQ_SQR(x);

REAL fi=

(

(1. - sqr_x/ // 1

(3. + 2. *sqr_x/ // 2

(5. - 3. *sqr_x/ // 3

(7. + 4. *sqr_x/ // 4

(9. - 5. *sqr_x/ // 5

(11.+ 6. *sqr_x/ // 6

(13.- 7. *sqr_x/ // 7

(15.+ 8. *sqr_x/ // 8

(17.- 9. *sqr_x/ // 9

(19.+ 10.*sqr_x // 10

))))))))))

);

return(0.5+fi*FPQ_fi_low(x));

}

REAL FPQ_fih1_Iter15(REAL x)

{

REAL sqr_x=FPQ_SQR(x);

REAL fi=

(

(1. - sqr_x/ // 1

(3. + 2. *sqr_x/ // 2

(5. - 3. *sqr_x/ // 3

(7. + 4. *sqr_x/ // 4

(9. - 5. *sqr_x/ // 5

(11.+ 6. *sqr_x/ // 6

(13.- 7. *sqr_x/ // 7

(15.+ 8. *sqr_x/ // 8

(17.- 9. *sqr_x/ // 9

(19.+ 10.*sqr_x/ // 10

(21.- 11.*sqr_x/ // 11

(23.+ 12.*sqr_x/ // 12

(25.- 13.*sqr_x/ // 13

(27.+ 14.*sqr_x/ // 14

(29.- 15.*sqr_x // 15

)))))))))))))))

);

return(0.5+fi*FPQ_fi_low(x));

}

REAL FPQ_fih1_Iter20(REAL x)

{

REAL sqr_x=FPQ_SQR(x);

REAL fi=

(

(1. - sqr_x/ // 1

(3. + 2. *sqr_x/ // 2

(5. - 3. *sqr_x/ // 3

(7. + 4. *sqr_x/ // 4

(9. - 5. *sqr_x/ // 5

(11.+ 6. *sqr_x/ // 6

(13.- 7. *sqr_x/ // 7

(15.+ 8. *sqr_x/ // 8

(17.- 9. *sqr_x/ // 9

(19.+ 10.*sqr_x/ // 10

(21.- 11.*sqr_x/ // 11

(23.+ 12.*sqr_x/ // 12

(25.- 13.*sqr_x/ // 13

(27.+ 14.*sqr_x/ // 14

(29.- 15.*sqr_x/ // 15

(31.+ 16.*sqr_x/ // 16

(33.- 17.*sqr_x/ // 17

(35.+ 18.*sqr_x/ // 18

(37.- 19.*sqr_x/ // 19

(39.+ 20.*sqr_x // 20

))))))))))))))))))))

);

return(0.5+fi*FPQ_fi_low(x));

}

REAL FPQ_fih1_Iter25(REAL x)

{

REAL sqr_x=FPQ_SQR(x);

REAL fi=

(

(1. - sqr_x/ // 1

(3. + 2. *sqr_x/ // 2

(5. - 3. *sqr_x/ // 3

(7. + 4. *sqr_x/ // 4

(9. - 5. *sqr_x/ // 5

(11.+ 6. *sqr_x/ // 6

(13.- 7. *sqr_x/ // 7

(15.+ 8. *sqr_x/ // 8

(17.- 9. *sqr_x/ // 9

(19.+ 10.*sqr_x/ // 10

(21.- 11.*sqr_x/ // 11

(23.+ 12.*sqr_x/ // 12

(25.- 13.*sqr_x/ // 13

(27.+ 14.*sqr_x/ // 14

(29.- 15.*sqr_x/ // 15

(31.+ 16.*sqr_x/ // 16

(33.- 17.*sqr_x/ // 17

(35.+ 18.*sqr_x/ // 18

(37.- 19.*sqr_x/ // 19

(39.+ 20.*sqr_x/ // 20

(41.- 21.*sqr_x/ // 21

(43.+ 22.*sqr_x/ // 22

(45.- 23.*sqr_x/ // 23

(47.+ 24.*sqr_x/ // 24

(49.- 25.*sqr_x // 25

)))))))))))))))))))))))))

);

return(0.5+fi*FPQ_fi_low(x));

}

///////////////////////////////////////////////////////

// Laplas

//////////////////////////////////////////////////////

REAL FPQ_fih2(REAL x,int num_end)

{

return( 1.0 - FPQ_fih_ii(x,num_end)*FPQ_fi_low(x) );

}

REAL FPQ_fih_ii2(REAL x, int i, int num_end)

{

if( i < num_end )

return( x+(REAL)i/FPQ_fih_ii2(x, i+1, num_end) );

else

return(x);

}

REAL FPQ_fih_ii(REAL x, int num_end)

{

return( 1.0/FPQ_fih_ii2(x, 1, num_end) );

}

///////////////////////////////////////////////////////

// Inline Iteration : Laplas

///////////////////////////////////////////////////////

REAL FPQ_fih2_Iter5(REAL x)

{

REAL fi=

(

1./

(x + 1./ // 1

(x + 2./ // 2

(x + 3./ // 3

(x + 4./ // 4

(x + 5. // 5

)))))

);

return(1.- fi*FPQ_fi_low(x));

}

REAL FPQ_fih2_Iter10(REAL x)

{

REAL fi=

(

1./

(x + 1./ // 1

(x + 2./ // 2

(x + 3./ // 3

(x + 4./ // 4

(x + 5./ // 5

(x + 6./ // 6

(x + 7./ // 7

(x + 8./ // 8

(x + 9./ // 9

(x + 10. // 10

))))))))))

);

return(1.- fi*FPQ_fi_low(x));

}

REAL FPQ_fih2_Iter15(REAL x)

{

REAL fi=

(

1./

(x + 1./ // 1

(x + 2./ // 2

(x + 3./ // 3

(x + 4./ // 4

(x + 5./ // 5

(x + 6./ // 6

(x + 7./ // 7

(x + 8./ // 8

(x + 9./ // 9

(x + 10./ // 10

(x + 11./ // 11

(x + 12./ // 12

(x + 13./ // 13

(x + 14./ // 14

(x + 15. // 15

)))))))))))))))

);

return(1.- fi*FPQ_fi_low(x));

}

REAL FPQ_fih2_Iter20(REAL x)

{

REAL fi=

(

1./

(x + 1./ // 1

(x + 2./ // 2

(x + 3./ // 3

(x + 4./ // 4

(x + 5./ // 5

(x + 6./ // 6

(x + 7./ // 7

(x + 8./ // 8

(x + 9./ // 9

(x + 10./ // 10

(x + 11./ // 11

(x + 12./ // 12

(x + 13./ // 13

(x + 14./ // 14

(x + 15./ // 15

(x + 16./ // 16

(x + 17./ // 17

(x + 18./ // 18

(x + 19./ // 19

(x + 20. // 20

))))))))))))))))))))

);

return(1.- fi*FPQ_fi_low(x));

}

REAL FPQ_fih2_Iter25(REAL x)

{

REAL fi=

(

1./

(x + 1./ // 1

(x + 2./ // 2

(x + 3./ // 3

(x + 4./ // 4

(x + 5./ // 5

(x + 6./ // 6

(x + 7./ // 7

(x + 8./ // 8

(x + 9./ // 9

(x + 10./ // 10

(x + 11./ // 11

(x + 12./ // 12

(x + 13./ // 13

(x + 14./ // 14

(x + 15./ // 15

(x + 16./ // 16

(x + 17./ // 17

(x + 18./ // 18

(x + 19./ // 19

(x + 20./ // 20

(x + 21./ // 21

(x + 22./ // 22

(x + 23./ // 23

(x + 24./ // 24

(x + 25. // 25

)))))))))))))))))))))))))

);

return(1.- fi*FPQ_fi_low(x));

}

///////////////////////////////////////////////////////

// Ruben

//////////////////////////////////////////////////////

REAL FPQ_fih31(REAL x) // x^6

{

return( 1.0 - FPQ_fih_iii1(x)*FPQ_fi_low(x) );

}

REAL FPQ_fih_iii1(REAL x)

{

REAL sqr2x=FPQ_SQR(x);

REAL sqr4x=FPQ_SQR(sqr2x);

return( x*(sqr4x+6.*sqr2x+11.)/( (sqr2x+1.)*(sqr2x+3.)*(sqr2x+3.) ) );

}

REAL FPQ_fih32(REAL x) // x^11

{

return( 1. - FPQ_fih_iii2(x)*FPQ_fi_low(x) );

}

REAL FPQ_fih_iii2(REAL x)

{

REAL sqr2x=FPQ_SQR(x);

REAL sqr4x=FPQ_SQR(sqr2x);

REAL sqr6x=sqr2x*sqr4x;

REAL sqr8x=FPQ_SQR(sqr4x);

REAL sqr10x=sqr8x*sqr2x;

return( x*(sqr10x+21.*sqr8x+176.*sqr6x+740.*sqr4x+1611.*sqr2x+1507.)/

( (sqr2x+1.)*FPQ_SQR(sqr2x+3.)*FPQ_SQR3(sqr2x+5.) )

);

}

REAL FPQ_fih33(REAL x) // sqrt(x^2)

{

return( 1.0 - FPQ_fih_iii3(x)*FPQ_fi_low(x) );

}

REAL FPQ_fih_iii3(REAL x)

{

REAL sqr2x=FPQ_SQR(x);

return( (2./sqrt(sqr2x+2.))-( (1.-1./(sqr2x+4.) )/sqrt(sqr2x+4.) ) );

}

REAL FPQ_fih34(REAL x) // x^8

{

return( 1.0 - FPQ_fih_iii4(x)*FPQ_fi_low(x) );

}

REAL FPQ_fih_iii4(REAL x)

{

REAL sqr2x=FPQ_SQR(x);

REAL sqr4x=FPQ_SQR(sqr2x);

REAL sqr6x=sqr2x*sqr4x;

return( (x/(sqr2x+2.0))*( (sqr6x+6.0*sqr4x-14.0*sqr2x-28.0)/(sqr6x+5.0*sqr4x-20.0*sqr2x-4.0) ) );

}

///////////////////////////////////////////////////////

// Teylor to calculate Distr Func N(0,1)

//////////////////////////////////////////////////////

REAL FPQ_fih_Teylor(REAL x, int nPrecision)

{

REAL res, resPrev;

REAL SQRT2PI_INV=1.0/FPQ_SQRT2PI;

REAL x_sqr2=FPQ_SQR(x);

INTEGER i=1, iFact=1;

REAL nSign = 1.0;

INTEGER nTwoPowI=1;

INTEGER nN=1;

res=0.5+SQRT2PI_INV*x;

{

x*=x_sqr2;

iFact*=i++;

nTwoPowI<<=1;

nN+=2;

nSign*=(-1.0);

resPrev=res;

res+=(SQRT2PI_INV*nSign*x)/(iFact*nTwoPowI*nN);

}

while( i<10 && fabs(res-resPrev)>FPQ_GetPrecisionValue(nPrecision) );

return(res);

}

///////////////////////////////////////////////////////

// N(0,1) 2D

//////////////////////////////////////////////////////

#define FPQ_N_2D_Sigma(K) ( K[0][0]*K[1][1]-FPQ_SQR(K[0][1]) )

#define FPQ_N_2D_SigmaX(K,sigma) ( sqrt(K[1][1]/(2.*sigma)) )

#define FPQ_N_2D_SigmaY(K,sigma) ( sqrt(K[0][0]/(2.*sigma)) )

#define FPQ_N_2D_Ro(K) ( -K[0][1]/sqrt(K[0][0]*K[1][1]) )

REAL FPQ_N_2D_IntFunc(REAL ro, REAL * pArg)

{

// 0-x, 1-y, 2-SigmaX, 3-SigmaY

return( FPQ_fi_low_2D(pArg[0], pArg[1], pArg[2], pArg[3], ro) );

}

REAL FPQ_Distr_N_2D(REAL x, REAL y, REAL KorrelMatr[2][2], int nPrecision)

{

REAL Sigma = FPQ_N_2D_Sigma(KorrelMatr);

REAL SigmaX = FPQ_N_2D_SigmaX(KorrelMatr,Sigma);

REAL SigmaY = FPQ_N_2D_SigmaY(KorrelMatr,Sigma);

REAL Ro = FPQ_N_2D_Ro(KorrelMatr);

REAL pArg[] = { x, y, SigmaX, SigmaY };

return(

FPQ_Distr_N_01(x,nPrecision) *

FPQ_Distr_N_01(y,nPrecision) +

FPQ_Int_Simpson

(

Ro,

nPrecision,

FPQ_N_2D_IntFunc,

pArg

)

);

}

///////////////////////////////////////////////////////

// N(0,1) 3D

//////////////////////////////////////////////////////

REAL FPQ_N_3D_IntFunc(REAL L, REAL * pArg)

{

// 0-x, 1-y, 2-z, 3-SigmaX, 4-SigmaY, 5-ro, 6-roI, 7-nPrecision

REAL x=pArg[0];

REAL y=pArg[1];

REAL z=pArg[2];

REAL SigmaX=pArg[3];

REAL SigmaY=pArg[4];

REAL ro=pArg[5];

REAL roI=pArg[6];

int nPrecision=(int) pArg[7];

REAL L2=FPQ_SQR(L); // lambda^2

REAL FiArg= ( y*(1.-L2) + x*(roI-L2*ro) - z*L*(roI-ro) )/

sqrt( (1.-L2)*(1.-roI*roI-L2*(1.+ro*ro-2.*roI*ro)) ) ;

return(

FPQ_Distr_N_01(FiArg,nPrecision) *

FPQ_fi_low_2D(x, y, SigmaX, SigmaY, L)

);

}

REAL FPQ_Distr_N_3D(REAL x, REAL y, REAL z, REAL KorrelMatr[3][3], int nPrecision)

{

REAL KorrelMatr2D_I1[2][2]=

{

{ KorrelMatr[0][0], KorrelMatr[0][1] },

{ KorrelMatr[1][0], KorrelMatr[1][1] }

};

REAL KorrelMatr2D_I2[2][2]=

{

{ KorrelMatr[1][1], KorrelMatr[1][0] },

{ KorrelMatr[0][1], KorrelMatr[0][0] }

};

REAL RoI1=KorrelMatr[1][2]/KorrelMatr[0][2]; // ro23/ro13

REAL RoI2=KorrelMatr[0][2]/KorrelMatr[1][2]; // ro13/ro23

REAL SigmaI1 = FPQ_N_2D_Sigma(KorrelMatr2D_I1);

REAL SigmaXI1 = FPQ_N_2D_SigmaX(KorrelMatr2D_I1,SigmaI1);

REAL SigmaYI1 = FPQ_N_2D_SigmaY(KorrelMatr2D_I1,SigmaI1);

REAL RoI1L = FPQ_N_2D_Ro(KorrelMatr2D_I1);

REAL pArgI1[]={ x, y, z, SigmaXI1, SigmaYI1, RoI1L, KorrelMatr[0][1], nPrecision };

REAL SigmaI2 = FPQ_N_2D_Sigma(KorrelMatr2D_I2);

REAL SigmaXI2 = FPQ_N_2D_SigmaX(KorrelMatr2D_I2,SigmaI2);

REAL SigmaYI2 = FPQ_N_2D_SigmaY(KorrelMatr2D_I2,SigmaI2);

REAL RoI2L = FPQ_N_2D_Ro(KorrelMatr2D_I2);

REAL pArgI2[]={ y, x, z, SigmaXI2, SigmaYI2, RoI2L, KorrelMatr[1][0], nPrecision };

return(

FPQ_Distr_N_2D(x,y,KorrelMatr2D_I1,nPrecision) *

FPQ_Distr_N_01(z,nPrecision) +

FPQ_Int_Simpson

(

KorrelMatr[0][2], // ro13

nPrecision,

FPQ_N_3D_IntFunc,

pArgI1

) +

FPQ_Int_Simpson

(

KorrelMatr[1][2], // ro23

nPrecision,

FPQ_N_3D_IntFunc,

pArgI2

)

);

}

// Файл fpq_fi_l.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление плотности вероятности для N(0,1)

//////////////////////////////////////////////////////

#include "fpq.h"

REAL FPQ_fi_low(REAL x)

{

return( FPQ_FI_LOW_CONST*exp( (-0.5)*(x*x) ) );

}

REAL FPQ_fi_low_prob(REAL x)

{

return( FPQ_FI_LOW_CONST*exp( (-0.5)*(x*x) )*(-x) );

}

REAL FPQ_fi_low_2D(REAL x, REAL y, REAL sigmaX, REAL sigmaY, REAL ro)

{

REAL _1_ro2=1.-FPQ_SQR(ro);

x/=sigmaX;

y/=sigmaY;

return( FPQ_1_2PI*exp( -0.5*(FPQ_SQR(x)-2.*ro*x*y+FPQ_SQR(y))/_1_ro2 )/(sqrt(_1_ro2)*sigmaX*sigmaY) );

}

// Файл fpq_hi_2.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление функции нецентрального распределения хи-квадрат

//////////////////////////////////////////////////////

#include "fpq.h"

REAL FPQ_hi_2_i_IntFunc(REAL fi, REAL * pFuncParam)

{

REAL x=pFuncParam[0];

REAL n=pFuncParam[1];

REAL b=pFuncParam[2];

if(fi==0.0) return(3.0);

REAL res = exp( -0.5*(x+b)*(1.-cos(fi)) ) * sin( 0.5*(n-1)*fi - 0.5*(x-b)*sin(fi) ) / sin(0.5*fi);

return(res);

}

REAL FPQ_Distr_Chi_2(REAL x, int n, REAL b, int nPrecision)

{

REAL aFuncParam[]={x, (REAL)(n), b};

return(0.5 - 0.5*FPQ_1_PI*FPQ_Int_Simpson(0.0000000001, FPQ_PI, nPrecision, FPQ_hi_2_i_IntFunc, aFuncParam));

}

////////////////////////////////////////////////////////

// Procedure to calculate Distr Func X^2(n,b) with n&0x01==0

////////////////////////////////////////////////////////

REAL FPQ_Fact(REAL n)

{

REAL fact=1.;

for(REAL i=1; i<=n; i++)

{

fact*=i;

}

return(fact);

}

REAL FPQ_hi_2_ii(REAL x, int n, REAL b, int nPrecision)

{

REAL res=0.0;

REAL aa=0.5*b;

REAL bb=0.5*x;

REAL cc=exp(-0.5*(x+b));

REAL i,j,iFact,jFact;

if( n&0x01 != 0 )

{

fprintf(stderr,"Domain error in FPQ_hi_2_ii\n");

exit(2);

}

iFact=1.;

for( i=0.; i<15.; i++ )

{

iFact=FPQ_Fact(i);

for( j=i+n/2.; j<15.+ n; j++ )

{

jFact=FPQ_Fact(j);

//printf("i=%f j=%f iFact=%f jFact=%f\n",i,j,iFact,jFact);

res+=FPQ_POW(aa,i)*FPQ_POW(bb,j)*cc/(iFact*jFact);

}

iFact*=i;

}

return(res);

}

// Файл fpq_hi_2.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Определение параметров точности вычисления

//////////////////////////////////////////////////////

#include "fpq.h"

typedef struct

{

int nDefinition;

REAL realValue;

} FPQ_Precision_Def;

static FPQ_Precision_Def FPQ_Precision_Def_Data[]=

{

{ FPQ_Precision_10_1 , 0.1 },

{ FPQ_Precision_10_2 , 0.01 },

{ FPQ_Precision_10_3 , 0.001 },

{ FPQ_Precision_10_4 , 0.0001 },

{ FPQ_Precision_10_5 , 0.00001 },

{ FPQ_Precision_10_6 , 0.000001 },

{ FPQ_Precision_10_7 , 0.0000001 },

{ FPQ_Precision_10_8 , 0.00000001 },

{ FPQ_Precision_10_10 , 0.0000000001 }

};

REAL FPQ_GetPrecisionValue(int nPrecision)

{

return( FPQ_Precision_Def_Data[FPQMin(FPQ_Precision_10_10,nPrecision)].realValue );

}

static FPQ_Precision_Def FPQ_Int_Precision_Def_Data[]=

{

{ FPQ_Precision_10_1 , 10. },

{ FPQ_Precision_10_2 , 10. },

{ FPQ_Precision_10_3 , 20. },

{ FPQ_Precision_10_4 , 20. },

{ FPQ_Precision_10_5 , 50. },

{ FPQ_Precision_10_6 , 50. },

{ FPQ_Precision_10_7 , 50. },

{ FPQ_Precision_10_8 , 50. },

{ FPQ_Precision_10_10 , 100. }

};

REAL FPQ_GetIntPrecisionPoints(int nPrecision)

{

return( FPQ_Int_Precision_Def_Data[FPQMin(FPQ_Precision_10_10,nPrecision)].realValue );

}

// Файл fpq_qt.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление квантили нормального распределения

//////////////////////////////////////////////////////

#include "fpq.h"

/////////////////////////////////////////////////////

// Common procedure to calculate Quantil N(0,1)

////////////////////////////////////////////////////

REAL FPQ_Quantil_N_01(REAL alpha, int nPrecision)

{

/* if( alpha <= 0.001 )

{

return( FPQ_qt_II(alpha, nPrecision) );

}

else

{

return( FPQ_qt_I(alpha, nPrecision) );

}

if( nPrecision<= FPQ_Precision_10_2 )

{

if( alpha <= 0.001 )

{

return( FPQ_qt_X0_2(alpha) );

}

else

{

return( FPQ_qt_I(alpha, nPrecision) );

}

else

{

return( FPQ_qt_I(alpha, nPrecision) );

}

REAL FPQ_Quantil_N(REAL alpha, REAL m, REAL sigma, int nPrecision)

{

return( FPQ_Quantil_N_01(alpha*sigma + m, nPrecision) );

}

//////////////////////////////////////////////////////

/////////////////////////////////////////

// Start value X0=Psi(alpha)

/////////////////////////////////////////

REAL FPQ_qt_X0_1(REAL alpha)

{

return( (-1.)*sqrt( (-2.)*log(FPQ_SQRT2PI*alpha) ) );

}

REAL FPQ_qt_X0_2(REAL alpha)

{

return( (-1.)*sqrt( (-2.)*log( FPQ_SQRT2PI*alpha*sqrt( -2.*log(FPQ_SQRT2PI*alpha) ) ) ) );

}

///////////////////////////////////////////////////////

// Iteration procedure Xk+1=-sqrt(-2ln(alpha/R(Xk)));

///////////////////////////////////////////////////////

REAL FPQ_Mills_R(REAL x, int nPrecision);

REAL FPQ_qt_II(REAL alpha, int nPrecision)

{

REAL x=FPQ_qt_X0_2(alpha);

// REAL x=0.0;

REAL xPrev;

// int i=0;

{

xPrev=x;

x=(-1.)*sqrt( (-2.)*log(alpha/FPQ_Mills_R((-1.)*xPrev,nPrecision)) );

}

while( /*(i++ < 1000) &&*/ fabs(x-xPrev)>FPQ_GetPrecisionValue(nPrecision) );

return(x);

}

/////////////////////////////////////////

// Iteration procedure X0=Psi(alpha)

/////////////////////////////////////////

REAL FPQ_qt_I_Sum(REAL alpha, REAL Xn, int nPrecision, int nN);

REAL FPQ_qt_i_Vn(REAL x, REAL n);

REAL FPQ_qt_i_VnPoli(Polinom& VnPrev, Polinom& VnPrevProd);

REAL FPQ_qt_I(REAL alpha, int nPrecision)

{

REAL res, resPrev;

int nN=3;

res=0.0;

{

resPrev=res;

res+=FPQ_qt_I_Sum(alpha, resPrev, nPrecision, nN);

}

while( fabs(res-resPrev)>FPQ_GetPrecisionValue(nPrecision) );

return(res);

}

REAL FPQ_qt_I_Sum(REAL alpha, REAL Xn, int nPrecision, int nN)

{

REAL fi, fiPowI;

REAL alphaFi, alphaMinusFiPowI;

REAL i, iFact;

REAL res, resPrev;

REAL N=nN;

alphaFi=alpha - FPQ_Distr_N_01(Xn, nPrecision);

alphaMinusFiPowI=1.0;

fi=FPQ_fi_low(Xn);

fiPowI=1.0;

iFact=1.0;

res=0.0;

// N=FPQMin(nN,15); // factorial oveflow !

if(nN > 3)

{

Polinom Vn;

Polinom VnProd;

Vn.SetV1();

Vn.SetX(Xn);

for(i=1.0; i<=N; i+=1.0)

{

iFact*=i;

fiPowI*=fi;

alphaMinusFiPowI*=alphaFi;

resPrev=res;

res+=(FPQ_qt_i_VnPoli(Vn,VnProd)*alphaMinusFiPowI)/(iFact*fiPowI);

if( fabs(res-resPrev)<FPQ_GetPrecisionValue(nPrecision) )

break;

}

else

{

for(i=1.0; i<=N; i+=1.0)

{

iFact*=i;

fiPowI*=fi;

alphaMinusFiPowI*=alphaFi;

resPrev=res;

res+=(FPQ_qt_i_Vn(Xn,i)*alphaMinusFiPowI)/(iFact*fiPowI);

if( fabs(res-resPrev)<FPQ_GetPrecisionValue(nPrecision) )

break;

}

return(res);

}

REAL FPQ_qt_i_VnPoli(Polinom& VnPrev, Polinom& VnPrevProd)

{

REAL res=VnPrev.Calculate();

VnPrev.SetNextVn(VnPrevProd);

return(res);

}

REAL FPQ_qt_i_Vn(REAL x, REAL n)

{

if(n==1.0) return(1.0);

else if(n==2.0) return(x);

else if(n==3.0) return(2.0*FPQ_SQR(x) + 1.0);

else exit(1);

return(0.0);

}

// Файл fpq_qt_u.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление квантили нецентральных распределений

//////////////////////////////////////////////////////

#include "fpq.h"

/////////////////////////////////////////

// Iteration to any quantil

/////////////////////////////////////////

REAL FPQ_UniQt_Sum(REAL p, REAL Up, FPQ_UniQtFunc funcF, FPQ_UniQtFunc funcf, FPQ_UniQtFunc funcff, REAL * pArg, int nPrecision, int nN);

REAL FPQ_UniQt_Vn(REAL x, REAL n);

REAL FPQ_UniQt_VnPoli(Polinom& VnPrev, Polinom& VnPrevProd);

REAL FPQ_UniQt(REAL p, REAL Up1, FPQ_UniQtFunc funcF, FPQ_UniQtFunc funcf, FPQ_UniQtFunc funcff, REAL * pArg, int nPrecision)

{

REAL res=Up1;

REAL resPrev;

int nN=3;

if( p <= 0.3 ) nN=3;

else if( p <= 0.35) nN=2;

else nN=1;

{

resPrev=res;

res+=FPQ_UniQt_Sum(p, resPrev, funcF, funcf, funcff, pArg, nPrecision, nN);

//printf("UQt %f\n",res);

}

while( fabs(res-resPrev)>FPQ_GetPrecisionValue(nPrecision) );

return(res);

}

REAL FPQ_UniQt_Sum(REAL p, REAL Upk, FPQ_UniQtFunc funcF, FPQ_UniQtFunc funcf, FPQ_UniQtFunc funcff, REAL * pArg, int nPrecision, int nN)

{

REAL i;

REAL res=0., resPrev;

REAL N=nN;

REAL f=funcf(Upk,pArg), fPow=1.;

REAL pk=funcF(Upk,pArg);

REAL ppk=p-pk;

REAL ppkPow=1.;

REAL xu=-funcff(Upk,pArg)/funcf(Upk,pArg);

if(nN > 3)

{

Polinom Vn;

Polinom VnProd;

Vn.SetV1();

Vn.SetX(xu);

for(i=1.; i<=N; i+=1.)

{

ppkPow*=ppk;

fPow*=f;

resPrev=res;

res+=FPQ_UniQt_VnPoli(Vn,VnProd)*ppkPow/fPow;

if( fabs(res-resPrev)<FPQ_GetPrecisionValue(nPrecision) )

break;

}

else // N < 3

{

for(i=1.; i<=N; i+=1.)

{

ppkPow*=ppk;

fPow*=f;

resPrev=res;

res+=FPQ_UniQt_Vn(xu,i)*ppkPow/fPow;

if( fabs(res-resPrev)<FPQ_GetPrecisionValue(nPrecision) )

break;

}

return(res);

}

REAL FPQ_UniQt_VnPoli(Polinom& VnPrev, Polinom& VnPrevProd)

{

REAL res=VnPrev.Calculate();

VnPrev.SetNextVn(VnPrevProd);

return(res);

}

REAL FPQ_UniQt_Vn(REAL x, REAL n)

{

if(n==1.) return(1.);

else if(n==2.) return(x);

else if(n==3.) return(2.*FPQ_SQR(x) + 1.);

else exit(1);

return(0.0);

}

// Файл fpq_t.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление функции нецентрального t-распределения

//////////////////////////////////////////////////////

#include "fpq.h"

///////////////////////////////////////////////////////

// Procedure to calculate Distr Func t(n,x,m)

//////////////////////////////////////////////////////

REAL FPQ_t_i_IntFunc(REAL z, REAL * pFuncParam)

{

REAL x = pFuncParam[0];

REAL n = pFuncParam[1];

REAL m = pFuncParam[2];

int nPrecision = (int) pFuncParam[3];

REAL lambda=z*exp( -0.5*(z*z - 1.) );

REAL lambdaN=1.;

REAL res;

if(z==0.) return(0.);

if( n < 7 )

{

for(int i=0; i < (int) n; i++)

{

lambdaN*=lambda;

}

else

{

lambdaN=FPQ_POW(lambda,n);

}

res=FPQ_Distr_N_01( x*z-m , nPrecision) * lambdaN / z;

return(res);

}

REAL FPQ_t_i_Q(REAL x)

{

return( FPQ_SQRT2PI*( 1. + 1./(12.*x) + 1./(288.*x*x) ) );

}

REAL FPQ_Distr_t(REAL x, int n, REAL m, int nPrecision)

{

REAL aFuncParam[]={x, (REAL)(n), m, (REAL)(nPrecision)};

return( (sqrt(2.*n)/FPQ_t_i_Q(n/2.))* FPQ_Int_Simpson(0.0000000001, 20.0, nPrecision, FPQ_t_i_IntFunc, aFuncParam) );

}

///////////////////////////////////////////////////////////////////////

// Quantile central t

//////////////////////////////////////////////////////////////////////

REAL FPQ_tQuantil_t(REAL alpha, REAL n)

{

REAL res;

res= -0.0953

-0.631/(n+1.) +

0.81/sqrt( -1.*log(4.*alpha*(1.-alpha)) ) +

0.76*pow((4.*alpha*sqrt(n)),1./n);

return(1./res);

}

REAL FPQ_t_F(REAL x, REAL * pArg)

{

REAL n=pArg[0];

return(FPQ_Distr_t_C(x,n));

}

REAL FPQ_t_fi_n(REAL x, REAL * pArg)

{

REAL delta_x=pArg[1];

return( ( FPQ_t_F(x+delta_x,pArg) - FPQ_t_F(x,pArg) )/delta_x );

}

REAL FPQ_t_fi_n_Diff(REAL x, REAL * pArg)

{

REAL delta_x=pArg[1];

return( ( FPQ_t_fi_n(x+delta_x,pArg) - FPQ_t_fi_n(x,pArg) )/delta_x );

}

REAL FPQ_tQuantil_t_2(REAL alpha, REAL n)

{

REAL pArg[]={ n , 0.001 };

if(alpha==1.0) return(100000.);

alpha=1.-alpha;

alpha=1.-0.5*alpha;

return(FPQ_UniQt(alpha,FPQ_tQuantil_t(alpha,n),FPQ_t_F,FPQ_t_fi_n,FPQ_t_fi_n_Diff,pArg,1));

}

REAL FPQ_Distr_t_C(REAL x, REAL n)

{

REAL res;

REAL Tetta=atan(x/sqrt(n));

REAL CosT=cos(Tetta);

REAL SinT=sin(Tetta);

REAL CosT_i;

REAL CosT2=FPQ_SQR(CosT);

REAL sum;

REAL An;

REAL Bn;

if( ((int)n)&0x01!=0 ) // nechotnoe

{

if( n==1. )

{

res = FPQ_1_PI*Tetta + 0.5;

}

else if( n==3. )

{

res = FPQ_1_PI*(Tetta + SinT*CosT) + 0.5;

}

An = 1.;

Bn = 3.;

sum = CosT;

CosT_i = CosT;

for(REAL i=3.; i<(n-1.); i++ )

{

if( ((int)i)&0x01 )

{

An*=i-1.;

CosT_i*=CosT2;

sum+=CosT_i*An/Bn;

}

else

{

Bn*=i+1.;

}

res = FPQ_1_PI*( Tetta + SinT*sum ) + 0.5;

}

else // chetnoe

{

if( n==2. )

{

res = 0.5*SinT + 0.5;

}

else if( n == 4.)

{

res = 0.5*SinT*(1. + 0.5*CosT2 ) + 0.5;

}

An = 1.;

Bn = 2.;

CosT_i = CosT2;

sum = 1. + 0.5*CosT2;

for(REAL i=3.; i<(n-1.); i++ )

{

if( ((int)i)&0x01 ) // nechetnoe

{

Bn*=i+1.;

}

else // chetnoe

{

An*=i-1.;

CosT_i*=CosT2;

sum+=CosT_i*An/Bn;

}

res = 0.5*SinT*sum + 0.5;

}

return(res);

}

REAL FPQ_Distr_t_C_2(REAL t, REAL n)

{

REAL res;

REAL t2=t*t;

REAL t4=t2*t2;

REAL t6=t2*t4;

REAL t8=t4*t4;

REAL t10=t8*t2;

REAL t12=t8*t4;

REAL t14=t8*t6;

REAL nu;

nu=n;

res = t*( t2 + 1. )/( 4.*nu );

nu=n*n; // 2

res += t*( 3.*t6 - 7.*t4 - 5.*t2 - 3. )/( 96.*nu );

nu*=n*n*n; // 3

res += t*( t10 - 11.*t8 + 14.*t6 +6.*t4 -3.*t2 - 15. )/( 384.*nu );

nu*=n*n*n*n; // 4

res += t*( 15.*t14 - 375.*t12 + 2225.*t10 - 2141.*t8 - 939.* t6 - 213.*t4 +915.*t2 + 945. )/( 92160.*nu );

return( 1. - FPQ_fi_low(t)*res );

}

#include "fpq.h"

REAL FPQ_test_fi_low(REAL x, REAL * pFuncParam)

{

// return(exp( (-0.5)*(x*x) ));

return(FPQ_fi_low(x));

}

REAL FPQ_fi_low_test(REAL x, int nPrecision)

{

// return(0.5+FPQ_FI_LOW_CONST*FPQ_Int_Simpson(0.0, x, nPrecision, FPQ_test_fi_low, NULL));

// return(0.5+FPQ_Int_Simpson_N(0.0, x, 1000, FPQ_test_fi_low, NULL));

return(0.5+FPQ_Int_Simpson(0.0, x, nPrecision, FPQ_test_fi_low, NULL));

}

////////////////////////////////////////////////////

// Test Universal Quantil

////////////////////////////////////////////////////

REAL FPQ_Test_UniQt_N01_FHI(REAL x, REAL * pArg)

{

return(FPQ_Distr_N_01(x, FPQ_Precision_10_8));

}

REAL FPQ_Test_UniQt_N01_f(REAL x, REAL * pArg)

{

return(FPQ_fi_low(x));

}

REAL FPQ_Test_UniQt_N01_ff(REAL x, REAL * pArg)

{

return(FPQ_fi_low_prob(x));

}

REAL FPQ_Test_UniQt(REAL p, int nPrecision)

{

REAL Up1=FPQ_qt_X0_2(FPQMin(p,0.3));

return( FPQ_UniQt(p,Up1,FPQ_Test_UniQt_N01_FHI,FPQ_Test_UniQt_N01_f,FPQ_Test_UniQt_N01_ff,NULL,nPrecision) );

}

// Файл integral.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Универсальная процедура вычисления интеграла методом Симпсона

//////////////////////////////////////////////////////

#include "fpq.h"

REAL FPQ_Int_Simpson(REAL x_start, REAL x_end, int nPrecision, FPQ_Integral_Func func, REAL * pFuncParam)

{

REAL res, resPrev;

int nNumStep= (int) FPQ_GetIntPrecisionPoints(nPrecision);

// Проверяем точночть интегрирования

res=FPQ_Int_Simpson_N(x_start, x_end, nNumStep, func, pFuncParam);

{

resPrev=res;

nNumStep*=2;

res = FPQ_Int_Simpson_N(x_start, x_end, nNumStep, func, pFuncParam);

}

while( fabs(res-resPrev) > FPQ_GetPrecisionValue(nPrecision) );

return(res);

}

REAL FPQ_Int_Simpson_N(REAL x_start, REAL x_end, int nNumStep, FPQ_Integral_Func func, REAL * pFuncParam)

{

REAL res=0.;

int nRealNumStep = ( (nNumStep&0x01)==0x00 ) ? (nNumStep) : (nNumStep+1);

REAL x_delta = (x_end - x_start)/nRealNumStep;

REAL x_delta_const=x_delta/3.;

REAL f0,f1,f2;

f2=func(x_start,pFuncParam);

for( REAL x=x_start; x<(x_end-x_delta); )

{

f0=f2;

f1=func(x+=x_delta,pFuncParam);

f2=func(x+=x_delta,pFuncParam);

res+=x_delta_const*( f0 + 4.*f1 + f2 );

}

return(res);

}

#include "fpq.h"

#include "fpq_test.h"

///////////////////////////////////////////////

// Output data format

///////////////////////////////////////////////

static char szFormatF[]=" %+17.15f";

static char szFormatQ[]=" %+17.15f\n";

static char szFormatX[]="%7.5f";

static char szFormatI[]=" %2d----#----#----# ";

///////////////////////////////////////////////

// Init data

///////////////////////////////////////////////

// Probality Function

#define D_X_START_FIH 0.0

#define D_X_END_FIH 10.0

#define D_X_STEP_FIH 0.1

#define D_I_START_FIH 5

#define D_I_END_FIH 50

#define D_I_STEP_FIH 5

// Quantil

#define D_X_START_QT 0.01

#define D_X_END_QT 0.99

#define D_X_STEP_QT 0.01

// Not central Probality Function

#define D_N_START_HTF 5

#define D_N_END_HTF 10

#define D_N_STEP_HTF 5

#define D_B_START_HTF 1.0

#define D_B_END_HTF 5.0

#define D_B_STEP_HTF 1.0

#define D_X_START_HTF 0.1

#define D_X_END_HTF 10.0

#define D_X_STEP_HTF 0.1

// Probality Function 2D

//#define D_X_START_2D 0.0

//#define D_X_END_2D 10.0

//#define D_X_STEP_2D 0.1

#define D_RO_START_2D 0.1

#define D_RO_END_2D 1.0

#define D_RO_STEP_2D 0.1

// Varitables

static INTEGER I_START_FIH=D_I_START_FIH;

static INTEGER I_END_FIH=D_I_END_FIH;

static INTEGER I_STEP_FIH=D_I_STEP_FIH;

static REAL X_START_FIH=D_X_START_FIH;

static REAL X_END_FIH=D_X_END_FIH;

static REAL X_STEP_FIH=D_X_STEP_FIH;

static REAL X_START_QT=D_X_START_QT;

static REAL X_END_QT=D_X_END_QT;

static REAL X_STEP_QT=D_X_STEP_QT;

///////////////////////////////////////////////

// Misc

///////////////////////////////////////////////

int bPrintNeed=1; // default - output need

int nTotalPrecision=FPQ_Precision_10_8;

//int nTotalPrecision=FPQ_Precision_10_1;

void Usage()

{

printf("\tProgram FPQ:\n\tfpq.exe {pqxftud}{ 0|1|2|3 {1|2|3|4|5|6|t} }}[NumberIteration]\n");

exit(1);

}

///////////////////////////////////////////////

// Run function type definition

///////////////////////////////////////////////

typedef REAL FPQ_Test_Prob(REAL x, int i);

typedef REAL FPQ_Test_Prob2(REAL x);

typedef REAL FPQ_Test_Qt(REAL x);

typedef REAL FPQ_Test_QtI(REAL x, int nPresision);

typedef REAL FPQ_Test_X2_XNB(REAL x, int n, REAL b, int nPrecision);

typedef REAL FPQ_Test_F_2XNB(REAL x, int n1, int n2, REAL b1, REAL b2, int nPrecision);

typedef REAL FPQ_Test_t_XNB(REAL x, int n, REAL b, int nPrecision);

typedef REAL FPQ_Test_fi2D(REAL x, REAL y, REAL SigmaX, REAL SigmaY, REAL Ro);

typedef REAL FPQ_Test_N_2D(REAL x, REAL y, REAL KorrelMatr[2][2], int nPrecision);

typedef REAL FPQ_Test_N_3D(REAL x, REAL y, REAL z, REAL KorrelMatr[3][3], int nPrecision);

int FPQ_Test_Distr(FPQ_Test_Prob2 func_to_run, char * szText)

{

REAL x,res;

if(bPrintNeed)

{

printf("Distribution: %s\n",szText);

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

printf(szFormatX,x);

res=func_to_run(x);

printf(szFormatF,res);

printf("\n");

}

else

{

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

res=func_to_run(x);

}

return(0);

}

int FPQ_Test_PXI(FPQ_Test_Prob func_to_run, char * szText)

{

REAL x,res;

int i;

if(bPrintNeed)

{

printf("Cumulative distribution function: %s\nx\\i\n",szText);

printf("----- ");

for(i=I_START_FIH; i<=I_END_FIH; i+=I_STEP_FIH)

{

printf(szFormatI,i);

}

printf("\n");

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

printf(szFormatX,x);

for(i=I_START_FIH; i<=I_END_FIH; i+=I_STEP_FIH)

{

res=func_to_run(x,i)-0.5;

printf(szFormatF,res);

}

printf("\n");

}

else

{

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

for(i=I_START_FIH; i<=I_END_FIH; i+=I_STEP_FIH)

{

res=func_to_run(x,i)-0.5;

}

return(0);

}

int FPQ_Test_PX(FPQ_Test_Prob2 func_to_run, char * szText)

{

REAL x,res;

if(bPrintNeed)

{

printf("Cumulative distribution function: %s\n",szText);

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

printf(szFormatX,x);

res=func_to_run(x)-0.5;

printf(szFormatF,res);

printf("\n");

}

else

{

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

res=func_to_run(x)-0.5;

}

return(0);

}

int FPQ_Test_PX_Pr(FPQ_Test_Prob func_to_run, char * szText)

{

REAL x,res;

if(bPrintNeed)

{

printf("Cumulative distribution function: %s\n",szText);

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

printf(szFormatX,x);

res=func_to_run(x, nTotalPrecision)-0.5;

printf(szFormatF,res);

printf("\n");

}

else

{

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

res=func_to_run(x,nTotalPrecision)-0.5;

}

return(0);

}

int FPQ_Test_QT(FPQ_Test_Qt func_to_run, char * szText)

{

REAL x,res;

if(bPrintNeed)

{

printf("Quantil: %s\n",szText);

for(x=X_START_QT; x<=X_END_QT; x+=X_STEP_QT)

{

printf(szFormatX,x);

res=func_to_run(x);

printf(szFormatQ,res);

}

else

{

for(x=X_START_QT; x<=X_END_QT; x+=X_STEP_QT)

{

res=func_to_run(x);

}

return(0);

}

int FPQ_Test_QT_Pr(FPQ_Test_QtI func_to_run, char * szText)

{

REAL x,res;

if(bPrintNeed)

{

printf("Quantil: %s\n",szText);

for(x=X_START_QT; x<=X_END_QT; x+=X_STEP_QT)

{

printf(szFormatX,x);

res=func_to_run(x,nTotalPrecision);

printf(szFormatQ,res);

}

else

{

for(x=X_START_QT; x<=X_END_QT; x+=X_STEP_QT)

{

res=func_to_run(x,nTotalPrecision);

}

return(0);

}

int FPQ_Test_X2(FPQ_Test_X2_XNB func_to_run, char * szText)

{

REAL x,res;

int n;

REAL b;

if(bPrintNeed)

{

printf("Raspredelenie: %s\n",szText);

for(n=D_N_START_HTF; n<=D_N_END_HTF;n+=D_N_STEP_HTF)

{

for(b=D_B_START_HTF; b<=D_B_END_HTF; b+=D_B_STEP_HTF)

{

for(x=D_X_START_HTF; x<=D_X_END_HTF; x+=D_X_STEP_HTF)

{

printf(szFormatX,x);

res=func_to_run(x,n,b,nTotalPrecision);

printf(szFormatQ,res);

}

else

{

for(n=D_N_START_HTF; n<=D_N_END_HTF;n+=D_N_STEP_HTF)

{

for(b=D_B_START_HTF; b<=D_B_END_HTF; b+=D_B_STEP_HTF)

{

for(x=D_X_START_HTF; x<=D_X_END_HTF; x+=D_X_STEP_HTF)

{

res=func_to_run(x,n,b,nTotalPrecision);

}

return(0);

}

int FPQ_Test_F(FPQ_Test_F_2XNB func_to_run, char * szText)

{

REAL x,res;

int n;

REAL b;

if(bPrintNeed)

{

printf("Raspredelenie: %s\n",szText);

for(n=D_N_START_HTF; n<=D_N_END_HTF;n+=D_N_STEP_HTF)

{

for(b=D_B_START_HTF; b<=D_B_END_HTF; b+=D_B_STEP_HTF)

{

for(x=D_X_START_HTF; x<=D_X_END_HTF; x+=D_X_STEP_HTF)

{

printf(szFormatX,x);

res=func_to_run(x,n,n,b,b,nTotalPrecision);

printf(szFormatQ,res);

}

else

{

for(n=D_N_START_HTF; n<=D_N_END_HTF;n+=D_N_STEP_HTF)

{

for(b=D_B_START_HTF; b<=D_B_END_HTF; b+=D_B_STEP_HTF)

{

for(x=D_X_START_HTF; x<=D_X_END_HTF; x+=D_X_STEP_HTF)

{

res=func_to_run(x,n,n,b,b,nTotalPrecision);

}

return(0);

}

int FPQ_Test_t(FPQ_Test_t_XNB func_to_run, char * szText)

{

REAL x,res;

int n;

REAL b;

if(bPrintNeed)

{

printf("Raspredelenie: %s\n",szText);

for(n=D_N_START_HTF; n<=D_N_END_HTF;n+=D_N_STEP_HTF)

{

for(b=D_B_START_HTF; b<=D_B_END_HTF; b+=D_B_STEP_HTF)

{

for(x=D_X_START_HTF; x<=D_X_END_HTF; x+=D_X_STEP_HTF)

{

printf(szFormatX,x);

res=func_to_run(x,n,b,nTotalPrecision);

printf(szFormatQ,res);

}

else

{

for(n=D_N_START_HTF; n<=D_N_END_HTF;n+=D_N_STEP_HTF)

{

for(b=D_B_START_HTF; b<=D_B_END_HTF; b+=D_B_STEP_HTF)

{

for(x=D_X_START_HTF; x<=D_X_END_HTF; x+=D_X_STEP_HTF)

{

res=func_to_run(x,n,b,nTotalPrecision);

}

return(0);

}

int FPQ_Test_UniQt_StdN(FPQ_Test_QtI func_to_run, char * szText)

{

REAL x,res;

if(bPrintNeed)

{

printf("Universal Quantil: %s\n",szText);

for(x=X_START_QT; x<=X_END_QT; x+=X_STEP_QT)

{

printf(szFormatX,x);

res=func_to_run(x,nTotalPrecision);

printf(szFormatQ,res);

}

else

{

for(x=X_START_QT; x<=X_END_QT; x+=X_STEP_QT)

{

res=func_to_run(x,nTotalPrecision);

}

return(0);

}

int FPQ_Test_fi_low_2D(FPQ_Test_fi2D func_to_run, char * szText)

{

REAL x,ro,res;

if(bPrintNeed)

{

printf("%s\n",szText);

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

for(ro=D_RO_START_2D; ro<=D_RO_END_2D; ro+=D_RO_STEP_2D)

{

printf(szFormatX,x);

res=func_to_run(x,x,0.5,0.5,ro);

printf(szFormatQ,res);

}

else

{

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

for(ro=D_RO_START_2D; ro<=D_RO_END_2D; ro+=D_RO_STEP_2D)

{

res=func_to_run(x,x,0.5,0.5,ro);

}

return(0);

}

int FPQ_TestF_N_2D(FPQ_Test_N_2D func_to_run, char * szText)

{

REAL x,res;

REAL KorrelMatr[2][2]=

{

{ 1., 0. },

{ 0., 1. }

};

if(bPrintNeed)

{

printf("%s\n",szText);

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

printf(szFormatX,x);

res=func_to_run(x,x,KorrelMatr,nTotalPrecision);

printf(szFormatQ,res);

}

else

{

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

res=func_to_run(x,x,KorrelMatr,nTotalPrecision);

}

return(0);

}

int FPQ_TestF_N_3D(FPQ_Test_N_3D func_to_run, char * szText)

{

REAL x,res;

REAL KorrelMatr[3][3]=

{

{ 1., 0., 0. },

{ 0., 1., 0. },

{ 0., 0., 1. }

};

if(bPrintNeed)

{

printf("%s\n",szText);

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

printf(szFormatX,x);

res=func_to_run(x,x,x,KorrelMatr,nTotalPrecision);

printf(szFormatQ,res);

}

else

{

for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH)

{

res=func_to_run(x,x,x,KorrelMatr,nTotalPrecision);

}

return(0);

}

#define FPQ_main_loop(func1, func2, szText) \

clock1=clock(); \

for(n=0; n<nNumIter; n++) \

{ \

func1(func2,szText); \

} \

clock2=clock();

#define FPQ_Speed_Loop(func1,x_st,x_end,x_step) \

for(x=x_st; x<=x_end; x+=x_step) \

{ \

clock1=clock(); \

for(int n=0; n<nNumIter; n++) \

{ \

res=func1(x,nTotalPrecision); \

} \

clock2=clock(); \

printf("%f %f\n",x,((double)nNumIter)/ \

( ((double)(clock2-clock1))/ \

((double)CLOCKS_PER_SEC) ) ); \

}

#define FPQ_Speed_Loop2(func1,x_st,x_end,x_step) \

for(x=x_st; x<=x_end; x+=x_step) \

{ \

clock1=clock(); \

for(int n=0; n<nNumIter; n++) \

{ \

res=func1(x); \

} \

clock2=clock(); \

printf("%f %f\n",x,((double)nNumIter)/ \

( ((double)(clock2-clock1))/ \

((double)CLOCKS_PER_SEC) ) ); \

}

// for(x=X_START_FIH; x<=X_END_FIH; x+=X_STEP_FIH) \

// printf("res(%f)=%f\n",x,res); \

///////////////////////////////////////////////

// Main function definition

///////////////////////////////////////////////

int main(int argc, char * argv[])

{

clock_t clock1,clock2;

int nNumIter=1;

int n;

if(argc==2)

{

nNumIter=1;

bPrintNeed=1;

}

else if(argc==3)

{

nNumIter=atoi(argv[2]);

bPrintNeed=0;

}

else

{

Usage();

}

switch(argv[1][0])

{

case 's':

switch(argv[1][1])

{

REAL x,res;

case 'p':

FPQ_Speed_Loop(FPQ_fi_low_test, 0.0, 10.0, 0.1);

break;

case 'n':

FPQ_Speed_Loop(FPQ_Distr_N_01, 0.0, 10.0, 0.1);

break;

case 'q':

FPQ_Speed_Loop(FPQ_Quantil_N_01, 0.0, 1.0, 0.1);

break;

case '1':

FPQ_Speed_Loop2(FPQ_qt_X0_1, 0.0001, 0.001, 0.0001);

break;

case '2':

FPQ_Speed_Loop2(FPQ_qt_X0_2, 0.0001, 0.001, 0.0001);

break;

case '4':

FPQ_Speed_Loop(FPQ_qt_II, 0.0001, 0.001, 0.0001);

break;

default:

Usage();

break;

}

exit(0);

break;

case 'p':

switch(argv[1][1])

{

case '0':

FPQ_main_loop(FPQ_Test_Distr,&FPQ_fi_low,"N(0,1)");

break;

case '1':

FPQ_main_loop(FPQ_Test_PXI,&FPQ_fih1,"N(0,1) [0.0 ; 3.0]");

break;

case '2':

FPQ_main_loop(FPQ_Test_PXI,&FPQ_fih2,"N(0,1) [3.0 ; +INF]");

break;

case '3':

switch(argv[1][2])

{

case '1':

FPQ_main_loop(FPQ_Test_PX,&FPQ_fih31,"N(0,1) #1");

break;

case '2':

FPQ_main_loop(FPQ_Test_PX,&FPQ_fih32,"N(0,1) #2");

break;

case '3':

FPQ_main_loop(FPQ_Test_PX,&FPQ_fih33,"N(0,1) #3");

break;

case '4':

FPQ_main_loop(FPQ_Test_PX,&FPQ_fih34,"N(0,1) #4");

break;

default:

Usage();

}

break;

case '4':

FPQ_main_loop(FPQ_Test_PX,&FPQ_fih1_Iter25,"N(0,1) #1 10 Iter");

break;

case '5':

FPQ_main_loop(FPQ_Test_PX,&FPQ_fih2_Iter25,"N(0,1) #2 10 Iter");

break;

case 't':

FPQ_main_loop(FPQ_Test_PX_Pr,&FPQ_fih_Teylor,"N(0,1) Teylor");

break;

case '6':

FPQ_main_loop(FPQ_Test_PX_Pr,&FPQ_fi_low_test,"N(0,1) Simpson Integral");

break;

case 'n':

FPQ_main_loop(FPQ_Test_PX_Pr,&FPQ_Distr_N_01,"N(0,1) Optimise Calculation");

break;

default:

Usage();

}

break;

case 'q':

switch(argv[1][1])

{

case '1':

FPQ_main_loop(FPQ_Test_QT,&FPQ_qt_X0_1,"N(0,1) Start Value #1");

break;

case '2':

FPQ_main_loop(FPQ_Test_QT,&FPQ_qt_X0_2,"N(0,1) Start Value #2");

break;

case '3':

FPQ_main_loop(FPQ_Test_QT_Pr,&FPQ_qt_I,"N(0,1) Iteration Procedure #1");

break;

case '4':

FPQ_main_loop(FPQ_Test_QT_Pr,&FPQ_qt_II,"N(0,1) Iteration Procedure #2");

break;

case 'a':

FPQ_main_loop(FPQ_Test_QT_Pr,&FPQ_Quantil_N_01,"N(0,1) All Tests");

break;

case 'r':

{

REAL R, alpha;

int Dim=3;

clock1=clock();

for(int i=0; i<nNumIter; i++)

{

for(Dim=1; Dim<100; Dim++)

{

for(alpha=0.1; alpha<1.0; alpha+=0.1)

{

R=FPQ_3dr(alpha,Dim,nTotalPrecision);

if(bPrintNeed)

{

printf("%f %d %f\n",alpha,Dim,R);

}

clock2=clock();

}

break;

case 't':

{

Polinom Vn, VnProd;

Vn.SetV1();

Vn.SetX(2.0);

for(int i=1; i<10; i++)

{

Vn.Dump(" Vn : ");

printf(" Vn = %3.1f\n",Vn.Calculate());

Vn.SetNextVn(VnProd);

VnProd.Dump("Prod Vn : ");

printf("--------------------------------------------\n");

}

break;

default:

Usage();

}

break;

case 'x':

switch(argv[1][1])

{

case '1':

FPQ_main_loop(FPQ_Test_X2,&FPQ_Distr_Chi_2,"X2(x,n,b) #1");

break;

case '2':

FPQ_main_loop(FPQ_Test_X2,&FPQ_hi_2_ii,"X2(x,n,b) #2");

break;

default:

Usage();

}

break;

case 'f':

switch(argv[1][1])

{

case '1':

FPQ_main_loop(FPQ_Test_F,&FPQ_Distr_F,"F(x,n,n,b,b) #1");

break;

case '2':

FPQ_main_loop(FPQ_Test_F,&FPQ_F_ii,"F(x,n,n,b,b) #2");

break;

default:

Usage();

}

break;

case 't':

switch(argv[1][1])

{

case '1':

FPQ_main_loop(FPQ_Test_t,&FPQ_Distr_t,"t(x,n,b) #1");

break;

default:

Usage();

}

break;

case 'u':

switch(argv[1][1])

{

case '1':

FPQ_main_loop(FPQ_Test_UniQt_StdN,&FPQ_Test_UniQt," UniQt #1");

break;

case 't':

{

for(REAL a=0.01; a<1.0; a+=0.01)

{

//REAL a=0.1;

REAL n=20.;

//printf("t_alpha(%f,%f)=%f\n",a,n,FPQ_tQuantil_t(a,n));

//printf("t(%f,%f)=%f\n",a,n,FPQ_Distr_t_C_2(a,n));

//printf("t(%f,%f)=%f\n",a,n,FPQ_Distr_t_C(a,n));

}

break;

case '2':

{

clock1=clock();

for(int i=0; i<nNumIter; i++)

{

for(REAL a=0.01; a<=0.99; a+=0.01)

{

REAL n=5., res;

if(bPrintNeed)

printf("t_alpha #1 (%f,%f)=%f\n",a,n,FPQ_tQuantil_t_2(a,n));

else

res=FPQ_tQuantil_t_2(a,n);

}

clock2=clock();

}

break;

default:

Usage();

}

break;

case 'd':

switch(argv[1][1])

{

case '0':

FPQ_main_loop(FPQ_Test_fi_low_2D,&FPQ_fi_low_2D," fi N(0,1) 2D");

break;

case '2':

FPQ_main_loop(FPQ_TestF_N_2D,&FPQ_Distr_N_2D," Fi N(0,1) 2D");

break;

case '3':

FPQ_main_loop(FPQ_TestF_N_3D,&FPQ_Distr_N_3D," Fi N(0,1) 3D");

break;

default:

Usage();

}

break;

default:

Usage();

}

printf("Time on %d iteration : %f sec.\n",nNumIter,((double)(clock2-clock1))/((double)CLOCKS_PER_SEC));

printf("Average %f iteration per sec.\n",((double)nNumIter)/((double)(clock2-clock1)/((double)CLOCKS_PER_SEC)));

#ifdef _FPQ_MATH_TEST_OUT

printf("FPQ_SQRT2PI=%15.10f, sqrt(2*pi)=%f15.10\n",FPQ_SQRT2PI,sqrt(2*FPQ_PI));

INTEGER iFact=1;

for(INTEGER i=1; i<100; i++)

{

iFact*=i;

printf("Factoral %d = %d\n",i,iFact);

}

#endif

return(0);

}

/////////////////////////////////////////

// Polinoms work

/////////////////////////////////////////

#include "fpq.h"

Polinom::Polinom(UINT nMaxLength)

{

m_nMaxLength=++nMaxLength;

m_pData= new REAL[nMaxLength];

m_pXValue= new REAL[nMaxLength];

m_nLength=0;

m_pData[m_nLength]=0.0;

m_pXValue[m_nLength]=0.0;

}

Polinom::~Polinom()

{

delete m_pData;

delete m_pXValue;

}

void Polinom::SetSize(UINT nMaxLength)

{

REAL * pData;

REAL * pXValue;

m_nMaxLength=++nMaxLength;

pData= new REAL[nMaxLength];

pXValue= new REAL[nMaxLength];

m_nLength=FPQMin(m_nLength,nMaxLength);

for(int i=0; i<=m_nLength; i++)

{

pData[i]=m_pData[i];

pXValue[i]=m_pXValue[i];

}

delete m_pData;

delete m_pXValue;

m_pData=pData;

m_pXValue=pXValue;

}

REAL Polinom::Calculate()

{

REAL realValue=0.0;

for(UINT i=0; i<=m_nLength; i++)

{

realValue+=m_pXValue[i]*m_pData[i];

}

return(realValue);

}

REAL Polinom::Product()

{

REAL realProduct=0.0;

for(int i=1; i<=m_nLength; i++)

{

realProduct+=(i)*m_pData[i]*m_pXValue[i-1];

}

return(realProduct);

}

void Polinom::SetX(REAL x)

{

REAL realExpX=1.0;

m_realXValue=x;

for(int i=0; i<=m_nLength; i++)

{

m_pXValue[i]=realExpX;

realExpX*=x;

}

void Polinom::SetProductTo(Polinom& poliProduct)

{

poliProduct.m_pData[0]=0.0;

for(int i=0; i<m_nLength; i++)

{

poliProduct.m_pData[i]=m_pData[i+1]*(i+1);

}

poliProduct.m_nLength=m_nLength-1;

poliProduct.m_nK=m_nK;

}

Polinom& Polinom::operator+=(const Polinom& poliAdding)

{

return(AddPolinom(poliAdding));

}

Polinom& Polinom::operator*=(REAL realKoef)

{

for(int i=0; i<=m_nLength; i++)

{

m_pData[i]*=realKoef;

}

return(*this);

}

Polinom& Polinom::MultKoefAndX(REAL realKoef)

{

for(int i=0; i<=m_nLength; i++)

{

m_pData[i]*=realKoef;

}

m_nLength++;

for(i=m_nLength; i>0; i--)

{

m_pData[i]=m_pData[i-1];

}

m_pData[0]=0.0;

m_pXValue[m_nLength]=m_realXValue*m_pXValue[m_nLength-1];

return(*this);

}

void Polinom::SetV1()

{

m_nLength=0;

m_pData[0]=1.0;

m_nK=1;

}

void Polinom::SetNextVn(Polinom& poliProd)

{

SetProductTo(poliProd);

MultKoefAndX((REAL)(m_nK++));

AddPolinom(poliProd);

}

Polinom& Polinom::AddPolinom(const Polinom & poliAdding)

{

if(poliAdding.m_nLength>m_nLength) // it`s not correct to full version

{

exit(1);

}

for(int i=0; i<=poliAdding.m_nLength; i++)

{

m_pData[i]+=poliAdding.m_pData[i];

}

return(*this);

}

void Polinom::Dump(char * szText)

{

printf("%s",szText);

for(int i=m_nLength; i>=0; i--)

{

printf("%+4.2f*X^%d",m_pData[i],i);

}

printf(" K=%d\n",m_nK);

}

// Файл fpq.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

#ifndef _FPQ__H_INCLUDED

#define _FPQ__H_INCLUDED

#include <fstream.h>

#include <math.h>

#include <time.h>

#include <stdio.h>

#include <stdlib.h>

#include <stddef.h>

#include <errno.h>

#include "fpqsetup.h"

#include "fpq_type.h"

#include "fpq_fi_h.h"

#include "fpq_fi_l.h"

#include "fpq_qt.h"

#include "fpq_prec.h"

#include "fpq_hi_2.h"

#include "fpq_t.h"

#include "fpq_F.h"

#include "fpq_qt_u.h"

#include "fpq_3dr.h"

#include "Polinom.h"

#include "Integral.h"

#endif

// Файл fpq_3dr.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////

// Вычисление радиуса доверительного шара

/////////////////////////////////////////////////////

#ifndef _FPQ_3DR_H_INCLUDED

#define _FPQ_3DR_H_INCLUDED

#include "fpq_type.h"

REAL FPQ_3dr(REAL alpha, int Dimension, int nPrecision);

#endif

// Файл fpq_f.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление функции нецентрального F-распределения

//////////////////////////////////////////////////////

#ifndef _FPQ_F_H_INCLUDED

#define _FPQ_F_H_INCLUDED

#include "fpq_type.h"

REAL FPQ_Distr_F(REAL x, int n1, int n2, REAL b1, REAL b2, int nPrecision);

REAL FPQ_F_ii(REAL x, int n1, int n2, REAL b1, REAL b2, int nPrecision);

#endif

// Файл fpq_fi_h.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление функции нормального распределения

//////////////////////////////////////////////////////

#ifndef _FPQ_FI_HIGH_H_INCLUDED

#define _FPQ_FI_HIGH_H_INCLUDED

#include "fpq_type.h"

REAL FPQ_Distr_N_01(REAL x, int nPrecision);

REAL FPQ_Distr_N(REAL x, REAL m, REAL sigma, int nPrecision);

REAL FPQ_Distr_N_01_HiPrec(REAL x);

REAL FPQ_Distr_N_2D(REAL x, REAL y, REAL KorrelMatr[2][2], int nPrecision);

REAL FPQ_Distr_N_3D(REAL x, REAL y, REAL z, REAL KorrelMatr[3][3], int nPrecision);

///////////////////////////////////////////

//////////////////////////////////////////

REAL FPQ_fih1(REAL x,int num_end);

REAL FPQ_fih1_Iter5(REAL x);

REAL FPQ_fih1_Iter10(REAL x);

REAL FPQ_fih1_Iter15(REAL x);

REAL FPQ_fih1_Iter20(REAL x);

REAL FPQ_fih1_Iter25(REAL x);

REAL FPQ_fih2(REAL x,int num_end);

REAL FPQ_fih2_Iter5(REAL x);

REAL FPQ_fih2_Iter10(REAL x);

REAL FPQ_fih2_Iter15(REAL x);

REAL FPQ_fih2_Iter20(REAL x);

REAL FPQ_fih2_Iter25(REAL x);

REAL FPQ_fih31(REAL x);

REAL FPQ_fih32(REAL x);

REAL FPQ_fih33(REAL x);

REAL FPQ_fih34(REAL x);

REAL FPQ_fih_Teylor(REAL x, int nPrecision);

#endif

// Файл fpq_fi_l.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление плотности вероятности для N(0,1)

//////////////////////////////////////////////////////

#ifndef _FPQ_FI_LOW_H_INCLUDED

#define _FPQ_FI_LOW_H_INCLUDED

#include "fpq_type.h"

REAL FPQ_fi_low(REAL x);

REAL FPQ_fi_low_prob(REAL x);

REAL FPQ_fi_low_2D(REAL x, REAL y, REAL sigmaX, REAL sigmaY, REAL ro);

#endif

// Файл fpq_hi_2.cpp

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление функции нецентрального распределения хи-квадрат

//////////////////////////////////////////////////////

#ifndef _FPQ_HI_2_H_INCLUDED

#define _FPQ_HI_2_H_INCLUDED

#include "fpq_type.h"

//REAL FPQ_hi_2_i(REAL x, int n, REAL b);

REAL FPQ_Distr_Chi_2(REAL x, int n, REAL b, int nPrecision);

REAL FPQ_hi_2_ii(REAL x, int n, REAL b, int nPrecision);

#endif

// Файл fpq_hi_2.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Определение параметров точности вычисления

//////////////////////////////////////////////////////

#ifndef _FPQ_PREC_H_INCLUDED

#define _FPQ_PREC_H_INCLUDED

///////////////////////////////////////////////////////

// Standart precision definition

///////////////////////////////////////////////////////

enum

{

FPQ_Precision_10_1 = 0,

FPQ_Precision_10_2 = FPQ_Precision_10_1+1,

FPQ_Precision_10_3 = FPQ_Precision_10_2+1,

FPQ_Precision_10_4 = FPQ_Precision_10_3+1,

FPQ_Precision_10_5 = FPQ_Precision_10_4+1,

FPQ_Precision_10_6 = FPQ_Precision_10_5+1,

FPQ_Precision_10_7 = FPQ_Precision_10_6+1,

FPQ_Precision_10_8 = FPQ_Precision_10_7+1,

FPQ_Precision_10_10 = FPQ_Precision_10_8+1,

FPQ_Precision_Default = FPQ_Precision_10_4

};

REAL FPQ_GetPrecisionValue(int nPrecision);

REAL FPQ_GetIntPrecisionPoints(int nPrecision);

#endif

// Файл fpq_qt.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление квантили нормального распределения

//////////////////////////////////////////////////////

#ifndef _FPQ_QT_H_INCLUDED

#define _FPQ_QT_H_INCLUDED

#include "fpqsetup.h"

#include "fpq_type.h"

REAL FPQ_Quantil_N_01(REAL alpha, int nPrecision);

REAL FPQ_Quantil_N(REAL alpha, REAL m, REAL sigma, int nPrecision);

REAL FPQ_qt_X0_1(REAL alpha);

REAL FPQ_qt_X0_2(REAL alpha);

REAL FPQ_qt_I(REAL alpha, int nPrecision);

REAL FPQ_qt_II(REAL alpha, int nPrecision);

#endif

// Файл fpq_qt_u.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление квантили нецентральных распределений

//////////////////////////////////////////////////////

#ifndef _FPQ_UNI_QT_H_INCLUDED

#define _FPQ_UNI_QT_H_INCLUDED

#include "fpq_type.h"

typedef REAL FPQ_UniQtFunc(REAL x, REAL * pArg);

REAL FPQ_UniQt(REAL p, REAL Up0, FPQ_UniQtFunc funcF, FPQ_UniQtFunc funcf, FPQ_UniQtFunc funcff, REAL * pArg, int nPrecision);

#endif

// Файл fpq_t.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Вычисление функции нецентрального t-распределения

//////////////////////////////////////////////////////

#ifndef _FPQ_T_H_INCLUDED

#define _FPQ_T_H_INCLUDED

#include "fpq_type.h"

REAL FPQ_Distr_t(REAL x, int n, REAL m, int nPrecision);

//REAL FPQ_t_i(REAL x, int n, REAL m);

REAL FPQ_tQuantil_t(REAL alpha, REAL n);

REAL FPQ_tQuantil_t_2(REAL alpha, REAL n);

REAL FPQ_Distr_t_C(REAL x, REAL n);

REAL FPQ_Distr_t_C_2(REAL t, REAL n);

#endif

#ifndef _FPQ_TEST_H_INCLUDED

#define _FPQ_TEST_H_INCLUDED

#include "fpq_type.h"

REAL FPQ_fi_low_test(REAL x, int nPrecision);

REAL FPQ_Test_UniQt(REAL x, int nPrecision);

#endif

// Файл fpq_type.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Определение основных типов и констант

//////////////////////////////////////////////////////

#ifndef _FPQ_TYPE_H_INCLUDED

#define _FPQ_TYPE_H_INCLUDED

#define FPQ_PI 3.1415926535897932384626433832795 /* Pi */

#define FPQ_1_PI 0.3183098861837906715377675267450 /* 1/Pi */

#define FPQ_1_2PI (0.5*FPQ_1_PI) /* 1/2Pi */

#define FPQ_E 2.71828182845904523536 /* E */

#define FPQ_1_SQRTPI 0.5641895835477562869480794515608 /* 1/sqpt(Pi) */

#define FPQ_SQRT2 1.4142135623730950488016887242097 /* sqrt(2) */

#define FPQ_SQRT2PI 2.5066282746310005024117175417289 /* sqrt(2*Pi) */

#define FPQ_1_SQRT2PI 0.3989422804014326779405902782544 /* 1/sqrt(2*Pi) */

#define FPQ_FI_LOW_CONST FPQ_1_SQRT2PI

typedef double REAL;

typedef long INTEGER;

#ifndef FPQMax

#define FPQMax(a,b) (((a) > (b)) ? (a) : (b))

#endif

#ifndef FPQMin

#define FPQMin(a,b) (((a) < (b)) ? (a) : (b))

#endif

#define FPQ_SQR(x) ( (x)*(x) ) /* x^2 */

#define FPQ_SQR3(x) ( (x)*(x)*(x) ) /* x^3 */

#define FPQ_POW(x,y) ( pow( (x) , (y) ) ) /* x^y */

//#define FPQ_POW(x,y) ( 0.==(x) ? 0. : exp( (y)*log(x) )) /* x^y */

#endif

// Файл fpqsetup.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Определение основных констант для настройки комплекса

//////////////////////////////////////////////////////

#ifndef _FPQ_SETUP_H_INCLUDED

#define _FPQ_SETUP_H_INCLUDED

#undef _FPQ_MATH_TEST_OUT

//#define _FPQ_MATH_TEST_OUT

#endif

// Файл integral.h

///////////////////////////////////////////////////////////////////

// Библиотека вычисления функций распределения и квантилей

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////

// Универсальная процедура вычисления интеграла методом Симпсона

//////////////////////////////////////////////////////

#ifndef _INTEGRAL_H_INCLUDED

#define _INTEGRAL_H_INCLUDED

#include "fpq.h"

typedef REAL FPQ_Integral_Func(REAL fi, REAL * pFuncConst);

REAL FPQ_Int_Simpson(REAL x_start, REAL x_end, int nPrecision, FPQ_Integral_Func func, REAL * pFuncParam);

REAL FPQ_Int_Simpson_N(REAL x_start, REAL x_end, int nNumStep, FPQ_Integral_Func func, REAL * pFuncParam);

#endif

#ifndef _POLINOM_H_INCLUDED

#define _POLINOM_H_INCLUDED

//typedef double REAL;

//typedef int INTEGER;

typedef int UINT;

#define POLI_MAX_LEN_DEF 50

#define POLI_LENGTH_INC 25

class Polinom

{

public:

int m_nK;

void Dump(char * szText);

Polinom& AddPolinom(const Polinom& poliAdding);

void SetNextVn(Polinom& poliProd);

void SetV1();

Polinom(UINT nMaxLength=POLI_MAX_LEN_DEF);

~Polinom();

void SetX(REAL x);

REAL Calculate();

REAL Product();

void SetProductTo(Polinom& poliProduct);

Polinom& operator+=(const Polinom& poliAdding);

Polinom& operator*=(REAL realKoef);

Polinom& MultKoefAndX(REAL realKoef);

private:

REAL * m_pData; // koefficients

REAL * m_pXValue; // x exponent

REAL m_realXValue;

UINT m_nLength; // Current max polinom exponent

UINT m_nMaxLength; // Mem length

void SetSize(UINT nMaxLength);

};

#endif

<<< < Предыдущая 1 2 3 45 / 55

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

#
27.09.20191.63 Mб58ОКПиМ РЭС (лекции, ч.1).doc
#
01.05.20253.35 Mб0ОКС.doc
#
21.07.201975.78 Кб6Октябрьская революция 1917 года.doc
#
23.09.201937.83 Кб4ООП.docx
#
07.11.2018464.38 Кб30ОП. Пргорамма 2011.doc
#
17.08.2019357.89 Кб6Описание использования комплекса и входящих в н...doc
#
01.05.2025131.58 Кб0Опр. уд.вяз. неметал.doc
#
01.05.202592.16 Кб0Определение теплоёмкости металла.doc
#
06.12.20181.08 Mб12Оптимизация - Лекции.doc
#
14.11.2019366.08 Кб2орг. повед 2012.doc
#
25.09.201965.13 Кб5Организация для всех.docx