as241.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205
  1. #include <math.h>
  2. /*-
  3. * algorithm as241 appl. statist. (1988) 37(3):477-484.
  4. * produces the normal deviate z corresponding to a given lower tail
  5. * area of p; z is accurate to about 1 part in 10**7.
  6. *
  7. * the hash sums below are the sums of the mantissas of the coefficients.
  8. * they are included for use in checking transcription.
  9. */
  10. double Cdhc_ppnd7(double p)
  11. {
  12. static double zero = 0.0, one = 1.0, half = 0.5;
  13. static double split1 = 0.425, split2 = 5.0;
  14. static double const1 = 0.180625, const2 = 1.6;
  15. /* coefficients for p close to 0.5 */
  16. static double a[4] = { 3.3871327179, 5.0434271938e+01,
  17. 1.5929113202e+02, 5.9109374720e+01
  18. };
  19. static double b[4] = { 0.0, 1.7895169469e+01, 7.8757757664e+01,
  20. 6.7187563600e+01
  21. };
  22. /* hash sum ab 32.3184577772 */
  23. /* coefficients for p not close to 0, 0.5 or 1. */
  24. static double c[4] = { 1.4234372777e+00, 2.7568153900e+00,
  25. 1.3067284816e+00, 1.7023821103e-01
  26. };
  27. static double d[3] = { 0.0, 7.3700164250e-01, 1.2021132975e-01 };
  28. /* hash sum cd 15.7614929821 */
  29. /* coefficients for p near 0 or 1. */
  30. static double e[4] = { 6.6579051150e+00, 3.0812263860e+00,
  31. 4.2868294337e-01, 1.7337203997e-02
  32. };
  33. static double f[3] = { 0.0, 2.4197894225e-01, 1.2258202635e-02 };
  34. /* hash sum ef 19.4052910204 */
  35. double q, r, ret;
  36. q = p - half;
  37. if (fabs(q) <= split1) {
  38. r = const1 - q * q;
  39. ret = q * (((a[3] * r + a[2]) * r + a[1]) * r + a[0]) /
  40. (((b[3] * r + b[2]) * r + b[1]) * r + one);
  41. return ret;;
  42. }
  43. /* else */
  44. if (q < zero)
  45. r = p;
  46. else
  47. r = one - p;
  48. if (r <= zero)
  49. return zero;
  50. r = sqrt(-log(r));
  51. if (r <= split2) {
  52. r = r - const2;
  53. ret = (((c[3] * r + c[2]) * r + c[1]) * r + c[0]) /
  54. ((d[2] * r + d[1]) * r + one);
  55. }
  56. else {
  57. r = r - split2;
  58. ret = (((e[3] * r + e[2]) * r + e[1]) * r + e[0]) /
  59. ((f[2] * r + f[1]) * r + one);
  60. }
  61. if (q < zero)
  62. ret = -ret;
  63. return ret;;
  64. }
  65. /*-
  66. * algorithm as241 appl. statist. (1988) 37(3):
  67. *
  68. * produces the normal deviate z corresponding to a given lower
  69. * tail area of p; z is accurate to about 1 part in 10**16.
  70. *
  71. * the hash sums below are the sums of the mantissas of the
  72. * coefficients. they are included for use in checking
  73. * transcription.
  74. */
  75. double ppnd16(double p)
  76. {
  77. static double zero = 0.0, one = 1.0, half = 0.5;
  78. static double split1 = 0.425, split2 = 5.0;
  79. static double const1 = 0.180625, const2 = 1.6;
  80. /* coefficients for p close to 0.5 */
  81. static double a[8] = {
  82. 3.3871328727963666080e0,
  83. 1.3314166789178437745e+2,
  84. 1.9715909503065514427e+3,
  85. 1.3731693765509461125e+4,
  86. 4.5921953931549871457e+4,
  87. 6.7265770927008700853e+4,
  88. 3.3430575583588128105e+4,
  89. 2.5090809287301226727e+3
  90. };
  91. static double b[8] = { 0.0,
  92. 4.2313330701600911252e+1,
  93. 6.8718700749205790830e+2,
  94. 5.3941960214247511077e+3,
  95. 2.1213794301586595867e+4,
  96. 3.9307895800092710610e+4,
  97. 2.8729085735721942674e+4,
  98. 5.2264952788528545610e+3
  99. };
  100. /* hash sum ab 55.8831928806149014439 */
  101. /* coefficients for p not close to 0, 0.5 or 1. */
  102. static double c[8] = {
  103. 1.42343711074968357734e0,
  104. 4.63033784615654529590e0,
  105. 5.76949722146069140550e0,
  106. 3.64784832476320460504e0,
  107. 1.27045825245236838258e0,
  108. 2.41780725177450611770e-1,
  109. 2.27238449892691845833e-2,
  110. 7.74545014278341407640e-4
  111. };
  112. static double d[8] = { 0.0,
  113. 2.05319162663775882187e0,
  114. 1.67638483018380384940e0,
  115. 6.89767334985100004550e-1,
  116. 1.48103976427480074590e-1,
  117. 1.51986665636164571966e-2,
  118. 5.47593808499534494600e-4,
  119. 1.05075007164441684324e-9
  120. };
  121. /* hash sum cd 49.33206503301610289036 */
  122. /* coefficients for p near 0 or 1. */
  123. static double e[8] = {
  124. 6.65790464350110377720e0,
  125. 5.46378491116411436990e0,
  126. 1.78482653991729133580e0,
  127. 2.96560571828504891230e-1,
  128. 2.65321895265761230930e-2,
  129. 1.24266094738807843860e-3,
  130. 2.71155556874348757815e-5,
  131. 2.01033439929228813265e-7
  132. };
  133. static double f[8] = { 0.0,
  134. 5.99832206555887937690e-1,
  135. 1.36929880922735805310e-1,
  136. 1.48753612908506148525e-2,
  137. 7.86869131145613259100e-4,
  138. 1.84631831751005468180e-5,
  139. 1.42151175831644588870e-7,
  140. 2.04426310338993978564e-15
  141. };
  142. /* hash sum ef 47.52583317549289671629 */
  143. double q, r, ret;
  144. q = p - half;
  145. if (fabs(q) <= split1) {
  146. r = const1 - q * q;
  147. ret = q * (((((((a[7] * r + a[6]) * r + a[5]) * r + a[4]) * r + a[3])
  148. * r + a[2]) * r + a[1]) * r + a[0]) /
  149. (((((((b[7] * r + b[6]) * r + b[5]) * r + b[4]) * r + b[3])
  150. * r + b[2]) * r + b[1]) * r + one);
  151. return ret;
  152. }
  153. /* else */
  154. if (q < zero)
  155. r = p;
  156. else
  157. r = one - p;
  158. if (r <= zero)
  159. return zero;
  160. r = sqrt(-log(r));
  161. if (r <= split2) {
  162. r -= const2;
  163. ret = (((((((c[7] * r + c[6]) * r + c[5]) * r + c[4]) * r + c[3])
  164. * r + c[2]) * r + c[1]) * r + c[0]) /
  165. (((((((d[7] * r + d[6]) * r + d[5]) * r + d[4]) * r + d[3])
  166. * r + d[2]) * r + d[1]) * r + one);
  167. }
  168. else {
  169. r -= split2;
  170. ret = (((((((e[7] * r + e[6]) * r + e[5]) * r + e[4]) * r + e[3])
  171. * r + e[2]) * r + e[1]) * r + e[0]) /
  172. (((((((f[7] * r + f[6]) * r + f[5]) * r + f[4]) * r + f[3])
  173. * r + f[2]) * r + f[1]) * r + one);
  174. }
  175. if (q < zero)
  176. ret = -ret;
  177. return ret;
  178. }