integration 0.1.3 → 0.1.4

data/lib/integration/methods.rb

@@ -0,0 +1,394 @@
+class Integration
+  class << self
+
+    # Rectangle method
+    # +n+ implies number of subdivisions
+    # Source:
+    #   * Ayres : Outline of calculus
+    def rectangle(t1, t2, n, &f)
+      d = (t2 - t1) / n.to_f
+      n.times.inject(0) do|ac, i|
+        ac + f[t1 + d * (i + 0.5)]
+      end * d
+    end
+
+    alias_method :midpoint, :rectangle
+
+    # Trapezoid method
+    # +n+ implies number of subdivisions
+    # Source:
+    #   * Ayres : Outline of calculus
+    def trapezoid(t1, t2, n, &f)
+      d = (t2 - t1) / n.to_f
+      (d / 2.0) * (f[t1] + 2 * (1..(n - 1)).inject(0) do|ac, i|
+        ac + f[t1 + d * i]
+      end + f[t2])
+    end
+
+    # Simpson's rule
+    # +n+ implies number of subdivisions
+    # Source:
+    #   * Ayres : Outline of calculus
+    def simpson(t1, t2, n, &f)
+      n += 1 unless n.even?
+      d = (t2 - t1) / n.to_f
+      out = (d / 3.0) * (f[t1.to_f].to_f + ((1..(n - 1)).inject(0) do|ac, i|
+        ac + ((i.even?) ? 2 : 4) * f[t1 + d * i]
+      end) + f[t2.to_f].to_f)
+      out
+    end
+
+    # Simpson's 3/8 Rule
+    # +n+ implies number of subdivisions
+    # Source:
+    #   * Burden, Richard L. and Faires, J. Douglas (2000): Numerical Analysis (7th ed.). Brooks/Cole
+    def simpson3by8(t1, t2, n, &f)
+      d = (t2 - t1) / n.to_f
+      ac = 0
+      (0..n - 1).each do |i|
+        ac += (d / 8.0) * (f[t1 + i * d] + 3 * f[t1 + i * d + d / 3] + 3 * f[t1 + i * d + 2 * d / 3] + f[t1 + (i + 1) * d])
+      end
+      ac
+    end
+
+    # Boole's Rule
+    # +n+ implies number of subdivisions
+    # Source:
+    # Weisstein, Eric W. "Boole's Rule." From MathWorld—A Wolfram Web Resource
+    def boole(t1, t2, n, &f)
+      d = (t2 - t1) / n.to_f
+      ac = 0
+      (0..n - 1).each do |i|
+        ac += (d / 90.0) * (7 * f[t1 + i * d] + 32 * f[t1 + i * d + d / 4] + 12 * f[t1 + i * d + d / 2] + 32 * f[t1 + i * d + 3 * d / 4] + 7 * f[t1 + (i + 1) * d])
+      end
+      ac
+    end
+
+    # Open Trapezoid method
+    # +n+ implies number of subdivisions
+    # Values computed at mid point and end point instead of starting points
+    def open_trapezoid(t1, t2, n, &f)
+      d = (t2 - t1) / n.to_f
+      ac = 0
+      (0..n - 1).each do |i|
+        ac += (d / 2.0) * (f[t1 + i * d + d / 3] + f[t1 + i * d + 2 * d / 3])
+      end
+      ac
+    end
+
+    # Milne's Method
+    # +n+ implies number of subdivisions
+    # Source:
+    # Abramowitz, M. and Stegun, I. A. (Eds.).
+    # Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables,
+    # 9th printing. New York: Dover, pp. 896-897, 1972.
+    def milne(t1, t2, n, &f)
+      d = (t2 - t1) / n.to_f
+      ac = 0
+      (0..n - 1).each do |i|
+        ac += (d / 3.0) * (2 * f[t1 + i * d + d / 4] - f[t1 + i * d + d / 2] + 2 * f[t1 + i * d + 3 * d / 4])
+      end
+      ac
+    end
+
+    # Adaptive Quadrature
+    # Calls the Simpson's rule recursively on subintervals
+    # in case the error exceeds the desired tolerance
+    # +tolerance+ is the desired tolerance of error
+    def adaptive_quadrature(a, b, tolerance)
+      h = (b.to_f - a) / 2
+      fa = yield(a)
+      fc = yield(a + h)
+      fb = yield(b)
+      s = h * (fa + (4 * fc) + fb) / 3
+
+      helper = proc do |_a, _b, _fa, _fb, _fc, _h, _s, level|
+        if level < 1 / tolerance.to_f
+          fd = yield(_a + (_h / 2))
+          fe = yield(_a + (3 * (_h / 2)))
+          s1 = _h * (_fa + (4.0 * fd) + _fc) / 6
+          s2 = _h * (_fc + (4.0 * fe) + _fb) / 6
+          if ((s1 + s2) - _s).abs <= tolerance
+            s1 + s2
+          else
+            helper.call(_a, _a + _h, _fa, _fc, fd, _h / 2, s1, level + 1) +
+            helper.call(_a + _h, _b, _fc, _fb, fe, _h / 2, s2, level + 1)
+          end
+        else
+          fail 'Integral did not converge'
+        end
+
+      end
+      helper.call(a, b, fa, fb, fc, h, s, 1)
+    end
+
+    # Gaussian Quadrature
+    # n-point Gaussian quadrature rule gives an exact result for polynomials of degree 2n − 1 or less
+    def gauss(t1, t2, n)
+      case n
+        when 1
+          z = [0.0]
+          w = [2.0]
+        when 2
+          z = [-0.57735026919, 0.57735026919]
+          w = [1.0, 1.0]
+        when 3
+          z = [-0.774596669241, 0.0, 0.774596669241]
+          w = [0.555555555556, 0.888888888889, 0.555555555556]
+        when 4
+          z = [-0.861136311594, -0.339981043585, 0.339981043585, 0.861136311594]
+          w = [0.347854845137, 0.652145154863, 0.652145154863, 0.347854845137]
+        when 5
+          z = [-0.906179845939, -0.538469310106, 0.0, 0.538469310106, 0.906179845939]
+          w = [0.236926885056, 0.478628670499, 0.568888888889, 0.478628670499, 0.236926885056]
+        when 6
+          z = [-0.932469514203, -0.661209386466, -0.238619186083, 0.238619186083, 0.661209386466, 0.932469514203]
+          w = [0.171324492379, 0.360761573048, 0.467913934573, 0.467913934573, 0.360761573048, 0.171324492379]
+        when 7
+          z = [-0.949107912343, -0.741531185599, -0.405845151377, 0.0, 0.405845151377, 0.741531185599, 0.949107912343]
+          w = [0.129484966169, 0.279705391489, 0.381830050505, 0.417959183673, 0.381830050505, 0.279705391489, 0.129484966169]
+        when 8
+          z = [-0.960289856498, -0.796666477414, -0.525532409916, -0.183434642496, 0.183434642496, 0.525532409916, 0.796666477414, 0.960289856498]
+          w = [0.10122853629, 0.222381034453, 0.313706645878, 0.362683783378, 0.362683783378, 0.313706645878, 0.222381034453, 0.10122853629]
+        when 9
+          z = [-0.968160239508, -0.836031107327, -0.613371432701, -0.324253423404, 0.0, 0.324253423404, 0.613371432701, 0.836031107327, 0.968160239508]
+          w = [0.0812743883616, 0.180648160695, 0.260610696403, 0.31234707704, 0.330239355001, 0.31234707704, 0.260610696403, 0.180648160695, 0.0812743883616]
+        when 10
+          z = [-0.973906528517, -0.865063366689, -0.679409568299, -0.433395394129, -0.148874338982, 0.148874338982, 0.433395394129, 0.679409568299, 0.865063366689, 0.973906528517]
+          w = [0.0666713443087, 0.149451349151, 0.219086362516, 0.26926671931, 0.295524224715, 0.295524224715, 0.26926671931, 0.219086362516, 0.149451349151, 0.0666713443087]
+        else
+          fail "Invalid number of spaced abscissas #{n}, should be 1-10"
+      end
+
+      sum = 0
+      (0...n).each do |i|
+        t = ((t1.to_f + t2) / 2.0) + (((t2 - t1) / 2.0) * z[i])
+        sum += w[i] * yield(t)
+      end
+      ((t2 - t1) / 2.0) * sum
+    end
+
+    # Gauss Kronrod Rule:
+    # Provides a 3n+1 order estimate while re-using the function values of a lower-order(n order) estimate
+    # Source:
+    # "Gauss–Kronrod quadrature formula", Encyclopedia of Mathematics, Springer, ISBN 978-1-55608-010-4
+    def gauss_kronrod(t1, t2, n, points)
+      # g7k15
+      case points
+        when 15
+
+          z = [-0.9914553711208126, -0.9491079123427585, -0.8648644233597691,
+               -0.7415311855993945, -0.5860872354676911, -0.4058451513773972,
+               -0.20778495500789848, 0.0, 0.20778495500789848,
+               0.4058451513773972, 0.5860872354676911, 0.7415311855993945,
+               0.8648644233597691, 0.9491079123427585, 0.9914553711208126]
+
+          w = [0.022935322010529224, 0.06309209262997856, 0.10479001032225019,
+               0.14065325971552592, 0.1690047266392679, 0.19035057806478542,
+               0.20443294007529889, 0.20948214108472782, 0.20443294007529889,
+               0.19035057806478542, 0.1690047266392679, 0.14065325971552592,
+               0.10479001032225019, 0.06309209262997856, 0.022935322010529224]
+
+        when 21
+          # g10k21
+
+          z = [-0.9956571630258081, -0.9739065285171717, -0.9301574913557082,
+               -0.8650633666889845, -0.7808177265864169, -0.6794095682990244,
+               -0.5627571346686047, -0.4333953941292472, -0.2943928627014602,
+               -0.14887433898163122, 0.0, 0.14887433898163122,
+               0.2943928627014602, 0.4333953941292472, 0.5627571346686047,
+               0.6794095682990244, 0.7808177265864169, 0.8650633666889845,
+               0.9301574913557082, 0.9739065285171717, 0.9956571630258081]
+
+          w = [0.011694638867371874, 0.032558162307964725,
+               0.054755896574351995, 0.07503967481091996, 0.0931254545836976,
+               0.10938715880229764, 0.12349197626206584, 0.13470921731147334,
+               0.14277593857706009, 0.14773910490133849, 0.1494455540029169,
+               0.14773910490133849, 0.14277593857706009, 0.13470921731147334,
+               0.12349197626206584, 0.10938715880229764, 0.0931254545836976,
+               0.07503967481091996, 0.054755896574351995, 0.032558162307964725,
+               0.011694638867371874]
+
+        when 31
+          # g15k31
+
+          z = [-0.9980022986933971, -0.9879925180204854, -0.9677390756791391,
+               -0.937273392400706, -0.8972645323440819, -0.8482065834104272,
+               -0.790418501442466, -0.7244177313601701, -0.650996741297417,
+               -0.5709721726085388, -0.4850818636402397, -0.3941513470775634,
+               -0.29918000715316884, -0.20119409399743451, -0.1011420669187175,
+               0.0, 0.1011420669187175, 0.20119409399743451,
+               0.29918000715316884, 0.3941513470775634, 0.4850818636402397,
+               0.5709721726085388, 0.650996741297417, 0.7244177313601701,
+               0.790418501442466, 0.8482065834104272, 0.8972645323440819,
+               0.937273392400706, 0.9677390756791391, 0.9879925180204854,
+               0.9980022986933971]
+
+          w = [0.005377479872923349, 0.015007947329316122, 0.02546084732671532,
+               0.03534636079137585, 0.04458975132476488, 0.05348152469092809,
+               0.06200956780067064, 0.06985412131872826, 0.07684968075772038,
+               0.08308050282313302, 0.08856444305621176, 0.09312659817082532,
+               0.09664272698362368, 0.09917359872179196, 0.10076984552387559,
+               0.10133000701479154, 0.10076984552387559, 0.09917359872179196,
+               0.09664272698362368, 0.09312659817082532, 0.08856444305621176,
+               0.08308050282313302, 0.07684968075772038, 0.06985412131872826,
+               0.06200956780067064, 0.05348152469092809, 0.04458975132476488,
+               0.03534636079137585, 0.02546084732671532, 0.015007947329316122,
+               0.005377479872923349]
+
+        when 41
+          # g20k41
+
+          z = [-0.9988590315882777, -0.9931285991850949, -0.9815078774502503,
+               -0.9639719272779138, -0.9408226338317548, -0.912234428251326,
+               -0.878276811252282, -0.8391169718222188, -0.7950414288375512,
+               -0.7463319064601508, -0.6932376563347514, -0.636053680726515,
+               -0.5751404468197103, -0.5108670019508271, -0.4435931752387251,
+               -0.37370608871541955, -0.301627868114913, -0.22778585114164507,
+               -0.15260546524092267, -0.07652652113349734, 0.0,
+               0.07652652113349734, 0.15260546524092267, 0.22778585114164507,
+               0.301627868114913, 0.37370608871541955, 0.4435931752387251,
+               0.5108670019508271, 0.5751404468197103, 0.636053680726515,
+               0.6932376563347514, 0.7463319064601508, 0.7950414288375512,
+               0.8391169718222188, 0.878276811252282, 0.912234428251326,
+               0.9408226338317548, 0.9639719272779138, 0.9815078774502503,
+               0.9931285991850949, 0.9988590315882777]
+
+          w = [0.0030735837185205317, 0.008600269855642943,
+               0.014626169256971253, 0.020388373461266523, 0.02588213360495116,
+               0.0312873067770328, 0.036600169758200796, 0.041668873327973685,
+               0.04643482186749767, 0.05094457392372869, 0.05519510534828599,
+               0.05911140088063957, 0.06265323755478117, 0.06583459713361842,
+               0.06864867292852161, 0.07105442355344407, 0.07303069033278667,
+               0.07458287540049918, 0.07570449768455667, 0.07637786767208074,
+               0.07660071191799965, 0.07637786767208074, 0.07570449768455667,
+               0.07458287540049918, 0.07303069033278667, 0.07105442355344407,
+               0.06864867292852161, 0.06583459713361842, 0.06265323755478117,
+               0.05911140088063957, 0.05519510534828599, 0.05094457392372869,
+               0.04643482186749767, 0.041668873327973685, 0.036600169758200796,
+               0.0312873067770328, 0.02588213360495116, 0.020388373461266523,
+               0.014626169256971253, 0.008600269855642943,
+               0.0030735837185205317]
+
+        when 61
+          # g30k61
+
+          z = [-0.9994844100504906, -0.9968934840746495, -0.9916309968704046,
+               -0.9836681232797472, -0.9731163225011262, -0.9600218649683075,
+               -0.94437444474856, -0.9262000474292743, -0.9055733076999078,
+               -0.8825605357920527, -0.8572052335460612, -0.8295657623827684,
+               -0.799727835821839, -0.7677774321048262, -0.7337900624532268,
+               -0.6978504947933158, -0.6600610641266269, -0.6205261829892429,
+               -0.5793452358263617, -0.5366241481420199, -0.49248046786177857,
+               -0.44703376953808915, -0.4004012548303944, -0.3527047255308781,
+               -0.30407320227362505, -0.25463692616788985,
+               -0.20452511668230988, -0.15386991360858354,
+               -0.10280693796673702, -0.0514718425553177, 0.0,
+               0.0514718425553177, 0.10280693796673702, 0.15386991360858354,
+               0.20452511668230988, 0.25463692616788985, 0.30407320227362505,
+               0.3527047255308781, 0.4004012548303944, 0.44703376953808915,
+               0.49248046786177857, 0.5366241481420199, 0.5793452358263617,
+               0.6205261829892429, 0.6600610641266269, 0.6978504947933158,
+               0.7337900624532268, 0.7677774321048262, 0.799727835821839,
+               0.8295657623827684, 0.8572052335460612, 0.8825605357920527,
+               0.9055733076999078, 0.9262000474292743, 0.94437444474856,
+               0.9600218649683075, 0.9731163225011262, 0.9836681232797472,
+               0.9916309968704046, 0.9968934840746495, 0.9994844100504906]
+
+          w = [0.0013890136986770077, 0.003890461127099884,
+               0.0066307039159312926, 0.009273279659517764,
+               0.011823015253496341, 0.014369729507045804, 0.01692088918905327,
+               0.019414141193942382, 0.021828035821609193, 0.0241911620780806,
+               0.0265099548823331, 0.02875404876504129, 0.030907257562387762,
+               0.03298144705748372, 0.034979338028060025, 0.03688236465182123,
+               0.038678945624727595, 0.040374538951535956,
+               0.041969810215164244, 0.04345253970135607, 0.04481480013316266,
+               0.04605923827100699, 0.04718554656929915, 0.04818586175708713,
+               0.04905543455502978, 0.04979568342707421, 0.05040592140278235,
+               0.05088179589874961, 0.051221547849258774, 0.05142612853745902,
+               0.05149472942945157, 0.05142612853745902, 0.051221547849258774,
+               0.05088179589874961, 0.05040592140278235, 0.04979568342707421,
+               0.04905543455502978, 0.04818586175708713, 0.04718554656929915,
+               0.04605923827100699, 0.04481480013316266, 0.04345253970135607,
+               0.041969810215164244, 0.040374538951535956,
+               0.038678945624727595, 0.03688236465182123, 0.034979338028060025,
+               0.03298144705748372, 0.030907257562387762, 0.02875404876504129,
+               0.0265099548823331, 0.0241911620780806, 0.021828035821609193,
+               0.019414141193942382, 0.01692088918905327, 0.014369729507045804,
+               0.011823015253496341, 0.009273279659517764,
+               0.0066307039159312926, 0.003890461127099884,
+               0.0013890136986770077]
+
+        else # using 15 point quadrature
+
+          n = 15
+
+          z = [-0.9914553711208126, -0.9491079123427585, -0.8648644233597691,
+               -0.7415311855993945, -0.5860872354676911, -0.4058451513773972,
+               -0.20778495500789848, 0.0, 0.20778495500789848,
+               0.4058451513773972, 0.5860872354676911, 0.7415311855993945,
+               0.8648644233597691, 0.9491079123427585, 0.9914553711208126]
+
+          w = [0.022935322010529224, 0.06309209262997856, 0.10479001032225019,
+               0.14065325971552592, 0.1690047266392679, 0.19035057806478542,
+               0.20443294007529889, 0.20948214108472782, 0.20443294007529889,
+               0.19035057806478542, 0.1690047266392679, 0.14065325971552592,
+               0.10479001032225019, 0.06309209262997856, 0.022935322010529224]
+
+      end
+
+      sum = 0
+      (0...n).each do |i|
+        t = ((t1.to_f + t2) / 2.0) + (((t2 - t1) / 2.0) * z[i])
+        sum += w[i] * yield(t)
+      end
+
+      ((t2 - t1) / 2.0) * sum
+    end
+
+    # Romberg Method:
+    # It is obtained by applying extrapolation techniques repeatedly on the trapezoidal rule
+    def romberg(a, b, tolerance, max_iter = 20)
+      # NOTE one-based arrays are used for convenience
+      h = b.to_f - a
+      close = 1
+      r = [[(h / 2) * (yield(a) + yield(b))]]
+      j = 0
+      hn = ->(n) { h / (2**n) }
+      while j <= max_iter && tolerance < close
+        j += 1
+        r.push((j + 1).times.map { [] })
+        ul = 2**(j - 1)
+        r[j][0] = r[j - 1][0] / 2.0 + hn[j] * (1..ul).inject(0) { |ac, k| ac + yield(a + (2 * k - 1) * hn[j]) }
+        (1..j).each do |k|
+          r[j][k] = ((4**k) * r[j][k - 1] - r[j - 1][k - 1]) / ((4**k) - 1)
+        end
+        close = (r[j][j] - r[j - 1][j - 1])
+      end
+      r[j][j]
+    end
+
+    # Monte Carlo
+    #
+    # Uses a non-deterministic approach for calculation of definite integrals.
+    # Estimates the integral by randomly choosing points in a set and then
+    # calculating the number of points that fall in the desired area.
+    def monte_carlo(t1, t2, n)
+      width = (t2 - t1).to_f
+      height = nil
+      vals = []
+      n.times do
+        t = t1 + (rand * width)
+        ft = yield(t)
+        height = ft if height.nil? || ft > height
+        vals << ft
+      end
+      area_ratio = 0
+      vals.each do |ft|
+        area_ratio += (ft / height.to_f) / n.to_f
+      end
+      (width * height) * area_ratio
+    end
+
+  end
+end

data/lib/integration/version.rb

@@ -1,3 +1,3 @@
 class Integration
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/spec/integration_spec.rb

@@ -1,77 +1,66 @@
-require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+$LOAD_PATH.unshift File.expand_path('../spec', __FILE__)
+
+require 'spec_helper'
+
 describe Integration do
-  a=lambda {|x| x**2}
-  b=lambda {|x| Math.log(x)/x**2}
-  b2=lambda {|x| -(Math.log(x)+1)/x}
+  a = lambda { |x| x**2 }
+  b = lambda { |x| Math.log(x) / x**2 }
+  b2 = lambda { |x| -(Math.log(x) + 1) / x }
+
   # Integration over [1,2]=x^3/3=7/3
-  methods=[:rectangle,:trapezoid, :simpson, :adaptive_quadrature,  :romberg, :gauss, :gauss_kronrod, :simpson3by8, :boole, :open_trapezoid, :milne]
+  methods = [:rectangle, :trapezoid, :simpson, :adaptive_quadrature,  :romberg,
+             :gauss, :gauss_kronrod, :simpson3by8, :boole, :open_trapezoid,
+             :milne]
+
   methods.each do |m|
     it "should integrate int_{1}^2{2} x^2 correctly with ruby method #{m}" do
-      Integration.integrate(1,2,{:method=>m,:tolerance=>1e-8},&a).should be_within(1e-6).of(7.0 / 3 )
+      Integration.integrate(1, 2, { method: m, tolerance: 1e-8 }, &a).should be_within(1e-6).of(7.0 / 3)
     end
+
     it "should integrate int_{1}^2{2} log(x)/x^2 correctly with ruby method #{m}" do
-      Integration.integrate(1,2,{:method=>m,:tolerance=>1e-8},&b).should be_within(1e-6).of(
-        b2[2]-b2[1]
-       )
+      Integration.integrate(1, 2, { method: m, tolerance: 1e-8 }, &b).should be_within(1e-6).of(
+        b2[2] - b2[1]
+      )
     end
-
   end
 
-
-  it "should return correct for trapezoid" do
-    a=rand()
-    b=rand()*10
-    f=lambda {|x| x*a}
-    Integration.trapezoid(0,b,2,&f).should be_within(1e-14).of((a*b**2) / 2.0)
-  end
-  it "should return a correct value for a complex integration with ruby methods" do
-    normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
-    Integration.integrate(0,1,{:tolerance=>1e-12,:method=>:simpson},&normal_pdf).should be_within(1e-11).of(0.341344746068)
-    Integration.integrate(0,1,{:tolerance=>1e-12,:method=>:adaptive_quadrature},&normal_pdf).should be_within(1e-11).of(0.341344746068)
-  end
-  it "should return a correct value for a complex integration with gsl methods" do
-    if Integration.has_gsl?
-      normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
-      Integration.integrate(0,1,{:tolerance=>1e-12,:method=>:qng},&normal_pdf).should be_within(1e-11).of(0.341344746068)
-      Integration.integrate(0,1,{:tolerance=>1e-12,:method=>:qag},&normal_pdf).should be_within(1e-11).of(0.341344746068)
-    else
-      skip("GSL not available")
-    end
+  it 'should return correct for trapezoid' do
+    a = rand
+    b = rand * 10
+    f = lambda { |x| x * a }
+    Integration.trapezoid(0, b, 2, &f).should be_within(1e-14).of((a * b**2) / 2.0)
   end
 
-      
-  it "should return correct integration for infinity bounds" do
-    if Integration.has_gsl?
-      normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
+  it 'should return a correct value for a complex integration with ruby methods' do
+    normal_pdf = lambda { |x| (1 / Math.sqrt(2 * Math::PI)) * Math.exp(-(x**2 / 2)) }
+    Integration.integrate(0, 1, { tolerance: 1e-12, method: :simpson }, &normal_pdf).should be_within(1e-11).of(0.341344746068)
+    Integration.integrate(0, 1, { tolerance: 1e-12, method: :adaptive_quadrature }, &normal_pdf).should be_within(1e-11).of(0.341344746068)
+  end
 
-      Integration.integrate(Integration::MInfinity, Integration::Infinity,{:tolerance=>1e-10}, &normal_pdf).should be_within(1e-09).of(1)
-    else
-      skip("GSL not available")
-    end
+  it 'should return a correct value for a complex integration with gsl methods' do
+    normal_pdf = lambda { |x| (1 / Math.sqrt(2 * Math::PI)) * Math.exp(-(x**2 / 2)) }
+    Integration.integrate(0, 1, { tolerance: 1e-12, method: :qng }, &normal_pdf).should be_within(1e-11).of(0.341344746068)
+    Integration.integrate(0, 1, { tolerance: 1e-12, method: :qag }, &normal_pdf).should be_within(1e-11).of(0.341344746068)
   end
-  it "should return correct integration for infinity lower bound" do
-    if Integration.has_gsl?
-      normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
 
-      Integration.integrate(Integration::MInfinity, 0 , {:tolerance=>1e-10}, &normal_pdf).should be_within(1e-09).of(0.5)
+  it 'should return correct integration for infinity bounds' do
+    normal_pdf = lambda { |x| (1 / Math.sqrt(2 * Math::PI)) * Math.exp(-(x**2 / 2)) }
 
-    else
-      skip("GSL not available")
-    end
+    Integration.integrate(Integration::MInfinity, Integration::Infinity, { tolerance: 1e-10 }, &normal_pdf).should be_within(1e-09).of(1)
   end
- it "should return correct integration for infinity upper bound" do
-    if Integration.has_gsl?
 
-      normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
-      Integration.integrate(0,Integration::Infinity,{:tolerance=>1e-10}, &normal_pdf).should be_within(1e-09).of(0.5)
+  it 'should return correct integration for infinity lower bound' do
+    normal_pdf = lambda { |x| (1 / Math.sqrt(2 * Math::PI)) * Math.exp(-(x**2 / 2)) }
+    Integration.integrate(Integration::MInfinity, 0, { tolerance: 1e-10 }, &normal_pdf).should be_within(1e-09).of(0.5)
+  end
 
-    else
-      skip("GSL not available")
-    end
+  it 'should return correct integration for infinity upper bound' do
+    normal_pdf = lambda { |x| (1 / Math.sqrt(2 * Math::PI)) * Math.exp(-(x**2 / 2)) }
+    Integration.integrate(0, Integration::Infinity, { tolerance: 1e-10 }, &normal_pdf).should be_within(1e-09).of(0.5)
   end
-  it "should raise an error if a ruby methods is called with infinite bounds" do
-    normal_pdf=lambda {|x| (1/Math.sqrt(2*Math::PI))*Math.exp(-(x**2/2))}
-    lambda {Integration.integrate(0,Integration::Infinity,{:method=>:simpson}, &normal_pdf).should be_within(1e-09).of(0.5)}.should raise_exception()
+
+  it 'should raise an error if a ruby methods is called with infinite bounds' do
+    normal_pdf = lambda { |x| (1 / Math.sqrt(2 * Math::PI)) * Math.exp(-(x**2 / 2)) }
+    lambda { Integration.integrate(0, Integration::Infinity, { method: :simpson }, &normal_pdf).should be_within(1e-09).of(0.5) }.should raise_exception
   end
 end
-