rubystats 0.1.2 → 0.2.0

data/lib/rubystats/fishers_exact_test.rb

@@ -0,0 +1,171 @@
+#! /usr/local/bin/ruby
+
+# Fisher's Exact Test Function Library
+#
+# Based on JavaScript version created by: Oyvind Langsrud
+# Ported to Ruby by Bryan Donovan
+module Rubystats
+  class FishersExactTest 
+
+    def initialize
+      @sn11    = 0.0
+      @sn1_    = 0.0
+      @sn_1    = 0.0
+      @sn      = 0.0
+      @sprob   = 0.0
+
+      @sleft   = 0.0
+      @sright  = 0.0 
+      @sless   = 0.0 
+      @slarg   = 0.0
+
+      @left    = 0.0
+      @right   = 0.0
+      @twotail = 0.0
+    end
+
+    # Reference: "Lanczos, C. 'A precision approximation
+    # of the gamma function', J. SIAM Numer. Anal., B, 1, 86-96, 1964."
+    # Translation of  Alan Miller's FORTRAN-implementation
+    # See http://lib.stat.cmu.edu/apstat/245
+    def lngamm(z) 
+      x = 0
+      x += 0.0000001659470187408462/(z+7)
+      x += 0.000009934937113930748 /(z+6)
+      x -= 0.1385710331296526      /(z+5)
+      x += 12.50734324009056       /(z+4)
+      x -= 176.6150291498386       /(z+3)
+      x += 771.3234287757674       /(z+2)
+      x -= 1259.139216722289       /(z+1)
+      x += 676.5203681218835       /(z)
+      x += 0.9999999999995183
+
+      return(Math.log(x)-5.58106146679532777-z+(z-0.5) * Math.log(z+6.5))
+    end
+
+    def lnfact(n)
+      if n <= 1
+        return 0
+      else
+        return lngamm(n+1)
+      end
+    end
+
+    def lnbico(n,k)
+      return lnfact(n) - lnfact(k) - lnfact(n-k)
+    end
+
+    def hyper_323(n11, n1_, n_1, n)
+      return Math.exp(lnbico(n1_, n11) + lnbico(n-n1_, n_1-n11) - lnbico(n, n_1))
+    end
+
+    def hyper(n11)
+      return hyper0(n11, 0, 0, 0)
+    end
+
+    def hyper0(n11i,n1_i,n_1i,ni)
+      if n1_i == 0 and n_1i ==0 and ni == 0
+        unless n11i % 10 == 0
+          if n11i == @sn11+1
+            @sprob *= ((@sn1_ - @sn11)/(n11i.to_f))*((@sn_1 - @sn11)/(n11i.to_f + @sn - @sn1_ - @sn_1))
+            @sn11 = n11i
+            return @sprob
+          end
+          if n11i == @sn11-1
+            @sprob *= ((@sn11)/(@sn1_-n11i.to_f))*((@sn11+@sn-@sn1_-@sn_1)/(@sn_1-n11i.to_f))
+            @sn11 = n11i
+            return @sprob
+          end
+        end
+        @sn11 = n11i
+      else
+        @sn11 = n11i
+        @sn1_ = n1_i
+        @sn_1 = n_1i
+        @sn   = ni
+      end
+      @sprob = hyper_323(@sn11,@sn1_,@sn_1,@sn)
+      return @sprob
+    end
+
+    def exact(n11,n1_,n_1,n)
+
+      p = i = j = prob = 0.0
+
+      max = n1_
+      max = n_1 if n_1 < max
+      min = n1_ + n_1 - n
+      min = 0 if min < 0
+
+      if min == max
+        @sless  = 1
+        @sright = 1
+        @sleft  = 1
+        @slarg  = 1
+        return 1
+      end
+
+      prob = hyper0(n11,n1_,n_1,n)
+      @sleft = 0
+
+      p = hyper(min)
+      i = min + 1
+      while p < (0.99999999 * prob)
+        @sleft += p
+        p = hyper(i)
+        i += 1
+      end
+
+      i -= 1
+
+      if p < (1.00000001*prob)
+        @sleft += p
+      else 
+        i -= 1	
+      end
+
+      @sright = 0
+
+      p = hyper(max)
+      j = max - 1
+      while p < (0.99999999 * prob)
+        @sright += p
+        p = hyper(j)
+        j -= 1
+      end
+      j += 1
+
+      if p < (1.00000001*prob)
+        @sright += p
+      else 
+        j += 1
+      end
+
+      if (i - n11).abs < (j - n11).abs 
+        @sless = @sleft
+        @slarg = 1 - @sleft + prob
+      else
+        @sless = 1 - @sright + prob
+        @slarg = @sright
+      end
+      return prob
+    end
+
+    def calculate(n11_,n12_,n21_,n22_)
+      n11_ *= -1 if n11_ < 0
+      n12_ *= -1 if n12_ < 0
+      n21_ *= -1 if n21_ < 0 
+      n22_ *= -1 if n22_ < 0 
+      n1_     = n11_ + n12_
+      n_1     = n11_ + n21_
+      n       = n11_ + n12_ + n21_ + n22_
+      prob    = exact(n11_,n1_,n_1,n)
+      left    = @sless
+      right   = @slarg
+      twotail = @sleft + @sright
+      twotail = 1 if twotail > 1
+      values_hash = { :left =>left, :right =>right, :twotail =>twotail }
+      return values_hash
+    end
+  end
+end

data/lib/rubystats/modules.rb

@@ -0,0 +1,742 @@
+module Rubystats
+
+  module ExtraMath
+    def binomial (n, k)
+      return Math.exp(log_gamma(n + 1.0) - log_gamma(k + 1.0) - log_gamma(n - k + 1.0))
+    end
+  end
+
+  module NumericalConstants
+    Max_float = 3.40282346638528860e292
+    Eps = 2.22e-16
+    Max_value = 1.2e290
+    Log_gamma_x_max_value = 2.55e292
+    Gamma_x_max_value = 171.624
+    Sqrt2pi = 2.5066282746310005024157652848110452530069867406099
+    Sqrt2 = 1.4142135623730950488016887242096980785696718753769
+    Xminin = 2.23e-303
+    Max_iterations = 1000
+    Precision = 8.88e-016
+    Two_pi = 6.2831853071795864769252867665590057683943387987502
+    Gamma = 0.57721566490153286060651209008240243104215933593992
+    Golden_ratio = 1.6180339887498948482045868343656381177203091798058
+  end
+
+
+  # Ruby port of SpecialMath.php from PHPMath, which is
+  # a port of JSci methods found in SpecialMath.java.
+  #
+  #
+  # Ruby port by Bryan Donovan bryandonovan.com
+  #
+  # Author:: Jaco van Kooten
+  # Author:: Paul Meagher
+  # Author:: Bryan Donovan
+  module SpecialMath
+
+    include Rubystats::NumericalConstants
+
+    @logGammaCache_res = 0.0
+    @logGammaCache_x   = 0.0
+    @logBetaCache_res  = 0.0
+    @logBetaCache_p    = 0.0
+    @logBetaCache_q    = 0.0
+
+    def log_beta(p,q)
+      if p != @logBetaCache_p || q != @logBetaCache_q 
+        logBetaCache_p = p
+        logBetaCache_q = q
+        if p <= 0.0 || q <= 0.0 || (p + q) > Log_gamma_x_max_value
+          logBetaCache_res = 0.0
+        else
+          logBetaCache_res = log_gamma(p) + log_gamma(q) - log_gamma(p + q)
+        end
+        return logBetaCache_res
+      end
+    end
+
+    # Gamma function.
+    # Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz<BR>
+    # Applied Mathematics Division<BR>
+    # Argonne National Laboratory<BR>
+    # Argonne, IL 60439<BR>
+    # <P>
+    # References:
+    # <OL>
+    # <LI>"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.
+    # <LI>Computer Approximations, Hart, Et. Al., Wiley and sons, New York, 1968.
+    # </OL></P><P>
+    # From the original documentation:
+    # </P><P>
+    # 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.
+    # The accuracy achieved depends on the arithmetic system, the
+    # compiler, the intrinsic functions, and proper selection of the
+    # machine-dependent constants.
+    # </P><P>
+    # Error returns:<BR>
+    # The program returns the value XINF for singularities or when overflow would occur.
+    # The computation is believed to be free of underflow and overflow.
+    # </P>
+    # Author:: Jaco van Kooten
+
+    def gamma(x) 
+      # gamma related constants
+      g_p = [ -1.71618513886549492533811, 24.7656508055759199108314,
+        -379.804256470945635097577, 629.331155312818442661052,
+        866.966202790413211295064, -31451.2729688483675254357,
+        -36144.4134186911729807069, 66456.1438202405440627855 ]
+      g_q = [-30.8402300119738975254353, 315.350626979604161529144,
+        -1015.15636749021914166146, -3107.77167157231109440444,
+        22538.1184209801510330112, 4755.84627752788110767815,
+        -134659.959864969306392456, -115132.259675553483497211 ] 
+      g_c = [-0.001910444077728, 8.4171387781295e-4, -5.952379913043012e-4,
+        7.93650793500350248e-4, -0.002777777777777681622553,
+        0.08333333333333333331554247, 0.0057083835261 ]
+      fact=1.0
+      i=0
+      n=0
+      y=x
+      parity=false
+      if y <= 0.0 
+        # ----------------------------------------------------------------------
+        #  Argument is negative
+        # ----------------------------------------------------------------------
+        y = -(x)
+        y1 = y.to_i
+        res = y - y1
+        if res != 0.0 
+          if y1 != (((y1*0.5).to_i) * 2.0)
+            parity = true
+            fact = -M_pi/sin(M_pi * res)
+            y += 1
+          end
+        else
+          return Max_value
+        end
+      end
+
+      # ----------------------------------------------------------------------
+      #  Argument is positive
+      # ----------------------------------------------------------------------
+      if y < Eps
+        # ----------------------------------------------------------------------
+        #  Argument .LT. EPS
+        # ----------------------------------------------------------------------
+        if y >= Xminin
+          res = 1.0 / y
+        else
+          return Max_value
+        end
+      elsif y < 12.0
+        y1 = y
+        #end
+        if y < 1.0
+          # ----------------------------------------------------------------------
+          #  0.0 .LT. argument .LT. 1.0
+          # ----------------------------------------------------------------------
+          z = y
+          y += 1
+        else 
+          # ----------------------------------------------------------------------
+          #  1.0 .LT. argument .LT. 12.0, reduce argument if necessary
+          # ----------------------------------------------------------------------
+          n = y.to_i - 1
+          y -= n.to_f
+          z = y - 1.0
+        end
+        # ----------------------------------------------------------------------
+        #  Evaluate approximation for 1.0 .LT. argument .LT. 2.0
+        # ----------------------------------------------------------------------
+        xnum = 0.0
+        xden = 1.0
+        for i in (0...8) 
+          xnum = (xnum + g_p[i]) * z
+          xden = xden * z + g_q[i]
+        end
+        res = xnum / xden + 1.0
+        if y1 < y
+          # ----------------------------------------------------------------------
+          #  Adjust result for case  0.0 .LT. argument .LT. 1.0
+          # ----------------------------------------------------------------------
+          res /= y1
+        elsif y1 > y 
+          # ----------------------------------------------------------------------
+          #  Adjust result for case  2.0 .LT. argument .LT. 12.0
+          # ----------------------------------------------------------------------
+          for i in (0...n)
+            res *= y
+            y += 1
+          end
+        end
+      else 
+        # ----------------------------------------------------------------------
+        #  Evaluate for argument .GE. 12.0
+        # ----------------------------------------------------------------------
+        if y <= Gamma_x_max_value
+          ysq = y * y
+          sum = g_c[6]
+          for i in(0...6) 
+            sum = sum / ysq + g_c[i]
+            sum = sum / y - y + log(sqrt2pi)
+            sum += (y - 0.5) * log(y)
+            res = Math.exp(sum)
+          end
+        else
+          return Max_value
+        end
+        # ----------------------------------------------------------------------
+        #  Final adjustments and return
+        # ----------------------------------------------------------------------
+        if parity
+          res = -res
+          if fact != 1.0
+            res = fact / res
+            return res
+          end
+        end
+      end
+    end
+
+    def log_gamma(x)
+      logGammaCache_res = @logGammaCache_res
+      logGammaCache_x = @logGammaCache_x
+
+      lg_d1 = -0.5772156649015328605195174
+      lg_d2 = 0.4227843350984671393993777
+      lg_d4 = 1.791759469228055000094023
+
+      lg_p1 = [ 4.945235359296727046734888,
+        201.8112620856775083915565, 2290.838373831346393026739,
+        11319.67205903380828685045, 28557.24635671635335736389,
+        38484.96228443793359990269, 26377.48787624195437963534,
+        7225.813979700288197698961 ]
+
+      lg_p2 = [ 4.974607845568932035012064,
+        542.4138599891070494101986, 15506.93864978364947665077,
+        184793.2904445632425417223, 1088204.76946882876749847,
+        3338152.967987029735917223, 5106661.678927352456275255,
+        3074109.054850539556250927 ]
+
+      lg_p4 = [ 14745.02166059939948905062,
+        2426813.369486704502836312, 121475557.4045093227939592,
+        2663432449.630976949898078, 29403789566.34553899906876,
+        170266573776.5398868392998, 492612579337.743088758812,
+        560625185622.3951465078242 ]
+
+      lg_q1 = [ 67.48212550303777196073036,
+        1113.332393857199323513008, 7738.757056935398733233834,
+        27639.87074403340708898585, 54993.10206226157329794414,
+        61611.22180066002127833352, 36351.27591501940507276287,
+        8785.536302431013170870835 ]
+
+      lg_q2 = [ 183.0328399370592604055942,
+        7765.049321445005871323047, 133190.3827966074194402448,
+        1136705.821321969608938755, 5267964.117437946917577538,
+        13467014.54311101692290052, 17827365.30353274213975932,
+        9533095.591844353613395747 ]
+
+      lg_q4 = [ 2690.530175870899333379843,
+        639388.5654300092398984238, 41355999.30241388052042842,
+        1120872109.61614794137657, 14886137286.78813811542398,
+        101680358627.2438228077304, 341747634550.7377132798597,
+        446315818741.9713286462081 ]
+
+      lg_c  = [ -0.001910444077728,8.4171387781295e-4,
+        -5.952379913043012e-4, 7.93650793500350248e-4,
+        -0.002777777777777681622553, 0.08333333333333333331554247,
+        0.0057083835261 ]
+
+      # Rough estimate of the fourth root of logGamma_xBig
+      lg_frtbig = 2.25e76
+      pnt68     = 0.6796875
+
+      if x == logGammaCache_x
+        return logGammaCache_res
+      end
+
+      y = x
+      if y > 0.0 && y <= Log_gamma_x_max_value
+        if y <= Eps
+          res = -Math.log(y)
+        elsif y <= 1.5
+          # EPS .LT. X .LE. 1.5
+          if y < pnt68
+            corr = -Math.log(y)
+            # xm1 is x-m-one, not x-m-L
+            xm1 = y
+          else
+            corr = 0.0
+            xm1 = y - 1.0
+          end
+          if y <= 0.5 || y >= pnt68
+            xden = 1.0
+            xnum = 0.0
+            for i in (0...8)
+              xnum = xnum * xm1 + lg_p1[i]
+              xden = xden * xm1 + lg_q1[i]
+            end
+            res = corr * xm1 * (lg_d1 + xm1 * (xnum / xden))
+          else
+            xm2 = y - 1.0
+            xden = 1.0
+            xnum = 0.0
+            for i in (0 ... 8)
+              xnum = xnum * xm2 + lg_p2[i]
+              xden = xden * xm2 + lg_q2[i]
+            end
+            res = corr + xm2 * (lg_d2 + xm2 * (xnum / xden))
+          end
+        elsif y <= 4.0
+          # 1.5 .LT. X .LE. 4.0
+          xm2 = y - 2.0
+          xden = 1.0
+          xnum = 0.0
+          for i in (0 ... 8)
+            xnum = xnum * xm2 + lg_p2[i]
+            xden = xden * xm2 + lg_q2[i]
+          end
+          res = xm2 * (lg_d2 + xm2 * (xnum / xden))
+        elsif y <= 12.0
+          # 4.0 .LT. X .LE. 12.0
+          xm4 = y - 4.0
+          xden = -1.0
+          xnum = 0.0
+          for i in (0 ... 8)
+            xnum = xnum * xm4 + lg_p4[i]
+            xden = xden * xm4 + lg_q4[i]
+          end
+          res = lg_d4 + xm4 * (xnum / xden)
+        else
+          # Evaluate for argument .GE. 12.0
+          res = 0.0
+          if y <= lg_frtbig
+            res = lg_c[6]
+            ysq = y * y
+            for i in (0...6)
+              res = res / ysq + lg_c[i]
+            end
+          end
+          res = res/y
+          corr = Math.log(y)
+          res = res + Math.log(Sqrt2pi) - 0.5 * corr
+          res = res + y * (corr - 1.0)
+        end
+      else
+        #return for bad arguments
+        res = Max_value
+      end
+      # final adjustments and return
+      logGammaCache_x = x
+      logGammaCache_res = res
+      return res
+    end
+
+
+    # Incomplete gamma function.
+    # The computation is based on approximations presented in 
+    # Numerical Recipes, Chapter 6.2 (W.H. Press et al, 1992).
+    # @param a require a>=0
+    # @param x require x>=0
+    # @return 0 if x<0, a<=0 or a>2.55E305 to avoid errors and over/underflow
+    # @author Jaco van Kooten
+
+    def incomplete_gamma(a, x) 
+      if x <= 0.0 || a <= 0.0 || a > Log_gamma_x_max_value
+        return 0.0
+      elsif x < (a + 1.0)
+        return gamma_series_expansion(a, x)
+      else
+        return 1.0-gamma_fraction(a, x)
+      end
+    end
+
+    # Author:: Jaco van Kooten
+    def gamma_series_expansion(a, x)
+      ap  = a
+      del = 1.0 / a
+      sum = del
+      for n in (1...Max_iterations)
+        ap += 1
+        del *= x / ap
+        sum += del
+        if del < sum * Precision
+          return sum * Math.exp(-x + a * Math.log(x) - log_gamma(a))
+        end
+      end
+      return "Maximum iterations exceeded: please file a bug report."
+    end
+
+    # Author:: Jaco van Kooten
+    def gamma_fraction(a, x) 
+      b  = x + 1.0 - a
+      c  = 1.0 / Xminin
+      d  = 1.0 / b
+      h  = d
+      del= 0.0
+      an = 0.0
+      for i in (1...Max_iterations) 
+        if (del-1.0).abs > Precision
+          an = -i * (i - a)
+          b += 2.0
+          d  = an * d + b
+          c  = b + an / c
+          if c.abs < Xminin
+            c = Xminin
+            if d.abs < Xminin
+              c = Xminin
+              d   = 1.0 / d
+              del = d * c
+              h  *= del
+            end
+          end
+        end
+        return Math.exp(-x + a * Math.log(x) - log_gamma(a)) * h
+      end
+    end
+
+    # Beta function.
+    #
+    # Author:: Jaco van Kooten
+
+    def beta(p, q) 
+      if p <= 0.0 || q <= 0.0 || (p + q) > Log_gamma_x_max_value
+        return 0.0
+      else 
+        return Math.exp(log_beta(p, q))
+      end
+    end
+
+    # Incomplete Beta function.
+    #
+    # Author:: Jaco van Kooten
+    # Author:: Paul Meagher
+    #
+    #  The computation is based on formulas from Numerical Recipes, 
+    #  Chapter 6.4 (W.H. Press et al, 1992).
+
+    def incomplete_beta(x, p, q) 
+      if x <= 0.0
+        return 0.0
+      elsif x >= 1.0
+        return 1.0
+      elsif p <= 0.0 || q <= 0.0 || (p + q) > Log_gamma_x_max_value
+        return 0.0
+      else 
+        beta_gam = Math.exp( -log_beta(p, q) + p * Math.log(x) + q * Math.log(1.0 - x) )
+        if x < (p + 1.0) / (p + q + 2.0)
+          return beta_gam * beta_fraction(x, p, q) / p
+        else
+          beta_frac = beta_fraction(1.0 - x, p, q)
+          return 1.0 - (beta_gam * beta_fraction(1.0 - x, q, p) / q)
+        end
+      end
+    end
+
+
+    # Evaluates of continued fraction part of incomplete beta function.
+    # Based on an idea from Numerical Recipes (W.H. Press et al, 1992).
+    # Author:: Jaco van Kooten
+
+    def beta_fraction(x, p, q) 
+      c = 1.0
+      sum_pq  = p + q
+      p_plus  = p + 1.0
+      p_minus = p - 1.0
+      h = 1.0 - sum_pq * x / p_plus
+      if h.abs < Xminin 
+        h = Xminin
+      end
+      h     = 1.0 / h
+      frac  = h
+      m     = 1
+      delta = 0.0
+
+      while (m <= Max_iterations) && ((delta - 1.0).abs > Precision) 
+        m2 = 2 * m
+        # even index for d
+        d = m * (q - m) * x / ( (p_minus + m2) * (p + m2))
+        h = 1.0 + d * h
+        if h.abs < Xminin
+          h = Xminin
+        end
+        h = 1.0 / h
+        c = 1.0 + d / c
+        if c.abs < Xminin
+          c = Xminin
+        end
+        frac *= h * c
+        # odd index for d
+        d = -(p + m) * (sum_pq + m) * x / ((p + m2) * (p_plus + m2))
+        h = 1.0 + d * h
+        if h.abs < Xminin
+          h = Xminin
+        end
+        h = 1.0 / h
+        c = 1.0 + d / c
+        if c.abs < Xminin
+          c = Xminin
+        end
+        delta = h * c
+        frac *= delta
+        m += 1
+      end
+      return frac
+    end
+
+
+
+    # Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+    #
+    # Developed at SunSoft, a Sun Microsystems, Inc. business.
+    # Permission to use, copy, modify, and distribute this
+    # software is freely granted, provided that this notice
+    # is preserved.
+    #
+    #                 x
+    #              2      |\
+    #     erf(x)  =  ---------  | exp(-t*t)dt
+    #            sqrt(pi) \|
+    #                 0
+    #
+    #     erfc(x) =  1-erf(x)
+    #  Note that
+    #        erf(-x) = -erf(x)
+    #        erfc(-x) = 2 - erfc(x)
+    #
+    # Method:
+    #    1. For |x| in [0, 0.84375]
+    #        erf(x)  = x + x*R(x^2)
+    #          erfc(x) = 1 - erf(x)           if x in [-.84375,0.25]
+    #                  = 0.5 + ((0.5-x)-x*R)  if x in [0.25,0.84375]
+    #       where R = P/Q where P is an odd poly of degree 8 and
+    #       Q is an odd poly of degree 10.
+    #                         -57.90
+    #            | R - (erf(x)-x)/x | <= 2
+    #
+    #
+    #       Remark. The formula is derived by noting
+    #          erf(x) = (2/sqrt(pi))*(x - x^3/3 + x^5/10 - x^7/42 + ....)
+    #       and that
+    #          2/sqrt(pi) = 1.128379167095512573896158903121545171688
+    #       is close to one. The interval is chosen because the fix
+    #       point of erf(x) is near 0.6174 (i.e., erf(x)=x when x is
+    #       near 0.6174), and by some experiment, 0.84375 is chosen to
+    #        guarantee the error is less than one ulp for erf.
+    #
+    #      2. For |x| in [0.84375,1.25], let s = |x| - 1, and
+    #         c = 0.84506291151 rounded to single (24 bits)
+    #             erf(x)  = sign(x) * (c  + P1(s)/Q1(s))
+    #             erfc(x) = (1-c)  - P1(s)/Q1(s) if x > 0
+    #              1+(c+P1(s)/Q1(s))    if x < 0
+    #             |P1/Q1 - (erf(|x|)-c)| <= 2**-59.06
+    #       Remark: here we use the taylor series expansion at x=1.
+    #        erf(1+s) = erf(1) + s*Poly(s)
+    #             = 0.845.. + P1(s)/Q1(s)
+    #              That is, we use rational approximation to approximate
+    #                 erf(1+s) - (c = (single)0.84506291151)
+    #            Note that |P1/Q1|< 0.078 for x in [0.84375,1.25]
+    #            where
+    #             P1(s) = degree 6 poly in s
+    #             Q1(s) = degree 6 poly in s
+    #     
+    #           3. For x in [1.25,1/0.35(~2.857143)],
+    #                  erfc(x) = (1/x)*exp(-x*x-0.5625+R1/S1)
+    #                  erf(x)  = 1 - erfc(x)
+    #            where
+    #             R1(z) = degree 7 poly in z, (z=1/x^2)
+    #             S1(z) = degree 8 poly in z
+    #     
+    #           4. For x in [1/0.35,28]
+    #                  erfc(x) = (1/x)*exp(-x*x-0.5625+R2/S2) if x > 0
+    #                 = 2.0 - (1/x)*exp(-x*x-0.5625+R2/S2) if -6<x<0
+    #                 = 2.0 - tiny        (if x <= -6)
+    #                  erf(x)  = sign(x)*(1.0 - erfc(x)) if x < 6, else
+    #                  erf(x)  = sign(x)*(1.0 - tiny)
+    #            where
+    #             R2(z) = degree 6 poly in z, (z=1/x^2)
+    #             S2(z) = degree 7 poly in z
+    #     
+    #           Note1:
+    #            To compute exp(-x*x-0.5625+R/S), let s be a single
+    #            precision number and s := x then
+    #             -x*x = -s*s + (s-x)*(s+x)
+    #                 exp(-x*x-0.5626+R/S) =
+    #                 exp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S)
+    #           Note2:
+    #            Here 4 and 5 make use of the asymptotic series
+    #                   exp(-x*x)
+    #             erfc(x) ~ ---------- * ( 1 + Poly(1/x^2) )
+    #                   x*sqrt(pi)
+    #            We use rational approximation to approximate
+    #               g(s)=f(1/x^2) = log(erfc(x)*x) - x*x + 0.5625
+    #            Here is the error bound for R1/S1 and R2/S2
+    #               |R1/S1 - f(x)|  < 2**(-62.57)
+    #               |R2/S2 - f(x)|  < 2**(-61.52)
+    #
+    #            5. For inf > x >= 28
+    #                             erf(x)  = sign(x) *(1 - tiny)  (raise inexact)
+    #                             erfc(x) = tiny*tiny (raise underflow) if x > 0
+    #                           = 2 - tiny if x<0
+    #                
+    #            7. Special case:
+    #                             erf(0)  = 0, erf(inf)  = 1, erf(-inf) = -1,
+    #                             erfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2,
+    #                           erfc/erf(NaN) is NaN
+    #               
+    #               $efx8 = 1.02703333676410069053e00
+    #                
+    #                 Coefficients for approximation to erf on [0,0.84375]
+    #                
+
+    # Error function.
+    # Based on C-code for the error function developed at Sun Microsystems.
+    # Author:: Jaco van Kooten
+
+    def error(x)
+      e_efx = 1.28379167095512586316e-01
+
+      ePp = [ 1.28379167095512558561e-01,
+        -3.25042107247001499370e-01,
+        -2.84817495755985104766e-02,
+        -5.77027029648944159157e-03,
+        -2.37630166566501626084e-05 ]
+
+      eQq = [ 3.97917223959155352819e-01,
+        6.50222499887672944485e-02,
+        5.08130628187576562776e-03,
+        1.32494738004321644526e-04,
+        -3.96022827877536812320e-06 ]
+
+      # Coefficients for approximation to erf in [0.84375,1.25]
+      ePa = [-2.36211856075265944077e-03,
+        4.14856118683748331666e-01,
+        -3.72207876035701323847e-01,
+        3.18346619901161753674e-01,
+        -1.10894694282396677476e-01,
+        3.54783043256182359371e-02,
+        -2.16637559486879084300e-03 ]
+
+      eQa = [ 1.06420880400844228286e-01,
+        5.40397917702171048937e-01,
+        7.18286544141962662868e-02,
+        1.26171219808761642112e-01,
+        1.36370839120290507362e-02,
+        1.19844998467991074170e-02 ]
+
+      e_erx = 8.45062911510467529297e-01
+
+      abs_x = (if x >= 0.0 then x else -x end)
+      # 0 < |x| < 0.84375
+      if abs_x < 0.84375
+        #|x| < 2**-28
+        if abs_x < 3.7252902984619141e-9 
+          retval = abs_x + abs_x * e_efx
+        else
+          s = x * x
+          p = ePp[0] + s * (ePp[1] + s * (ePp[2] + s * (ePp[3] + s * ePp[4])))
+
+          q = 1.0 + s * (eQq[0] + s * (eQq[1] + s *
+                                       ( eQq[2] + s * (eQq[3] + s * eQq[4]))))
+          retval = abs_x + abs_x * (p / q)
+        end
+      elsif abs_x < 1.25
+        s = abs_x - 1.0
+        p = ePa[0] + s * (ePa[1] + s * 
+                          (ePa[2] + s * (ePa[3] + s * 
+           (ePa[4] + s * (ePa[5] + s * ePa[6])))))
+
+        q = 1.0 + s * (eQa[0] + s * 
+                       (eQa[1] + s * (eQa[2] + s * 
+           (eQa[3] + s * (eQa[4] + s * eQa[5])))))
+        retval = e_erx + p / q
+
+      elsif abs_x >= 6.0
+        retval = 1.0
+      else
+        retval = 1.0 - complementary_error(abs_x)
+      end
+      return (if x >= 0.0 then retval else -retval end)
+    end
+
+  # Complementary error function.
+  # Based on C-code for the error function developed at Sun Microsystems.
+  # author Jaco van Kooten
+
+   def complementary_error(x)
+    # Coefficients for approximation of erfc in [1.25,1/.35]
+
+    eRa = [-9.86494403484714822705e-03,
+      -6.93858572707181764372e-01,
+      -1.05586262253232909814e01,
+      -6.23753324503260060396e01,
+      -1.62396669462573470355e02,
+      -1.84605092906711035994e02,
+      -8.12874355063065934246e01,
+      -9.81432934416914548592e00 ]
+
+    eSa = [ 1.96512716674392571292e01,
+      1.37657754143519042600e02,
+      4.34565877475229228821e02,
+      6.45387271733267880336e02,
+      4.29008140027567833386e02,
+      1.08635005541779435134e02,
+      6.57024977031928170135e00,
+      -6.04244152148580987438e-02 ]
+
+    # Coefficients for approximation to erfc in [1/.35,28]
+
+    eRb = [-9.86494292470009928597e-03,
+      -7.99283237680523006574e-01,
+      -1.77579549177547519889e01,
+      -1.60636384855821916062e02,
+      -6.37566443368389627722e02,
+      -1.02509513161107724954e03,
+      -4.83519191608651397019e02 ]
+
+    eSb = [ 3.03380607434824582924e01,
+      3.25792512996573918826e02,
+      1.53672958608443695994e03,
+      3.19985821950859553908e03,
+      2.55305040643316442583e03,
+      4.74528541206955367215e02,
+      -2.24409524465858183362e01 ]
+
+    abs_x = (if x >= 0.0 then x else -x end)
+    if abs_x < 1.25
+      retval = 1.0 - error(abs_x)
+    elsif abs_x > 28.0
+      retval = 0.0
+
+      # 1.25 < |x| < 28
+    else
+      s = 1.0/(abs_x * abs_x)
+      if abs_x < 2.8571428
+        r = eRa[0] + s * (eRa[1] + s * 
+                          (eRa[2] + s * (eRa[3] + s * (eRa[4] + s * 
+                                                       (eRa[5] + s *(eRa[6] + s * eRa[7])
+                                                       )))))
+
+                                                       s = 1.0 + s * (eSa[0] + s * (eSa[1] + s * 
+                                          (eSa[2] + s * (eSa[3] + s * (eSa[4] + s * 
+                           (eSa[5] + s * (eSa[6] + s * eSa[7])))))))
+
+      else
+        r = eRb[0] + s * (eRb[1] + s * 
+                          (eRb[2] + s * (eRb[3] + s * (eRb[4] + s * 
+             (eRb[5] + s * eRb[6])))))
+
+        s = 1.0 + s * (eSb[0] + s * 
+                       (eSb[1] + s * (eSb[2] + s * (eSb[3] + s * 
+             (eSb[4] + s * (eSb[5] + s * eSb[6]))))))
+      end
+      retval =  Math.exp(-x * x - 0.5625 + r/s) / abs_x
+    end
+    return ( if x >= 0.0 then retval else 2.0 - retval end )
+    end
+  end
+end