Implementation of the composite rules used to approximate defined integrals, written in ruby.

integral_aproximation_rules.rb

def x_sub(index, lower, h)
  x_k = lower + (index * h)
end

def booles_rule(lower, upper, &block)
  h = (upper - lower) / 4.0

  sum = 0
  sum += 7 * yield(lower)
  sum += 32 * yield(x_sub(1, lower, h))
  sum += 12 * yield(x_sub(2, lower, h))
  sum += 32 * yield(x_sub(3, lower, h))
  sum += 7 * yield(upper)

  (2 / 45.0) * h * sum
end

def composite_booles_rule(lower, upper, n, &block)
  h = (upper - lower) / (4 * n).to_f

  sum = 0
  (1..n).each do |i|
    sum += 7 * yield(x_sub(4 * i - 4, lower, h))
    sum += 32 * yield(x_sub(4 * i - 3, lower, h))
    sum += 12 * yield(x_sub(4 * i - 2, lower, h))
    sum += 32 * yield(x_sub(4 * i - 1, lower, h))
    sum += 7 * yield(x_sub(4 * i, lower, h))
  end

  sum * ((2 * h)/45.0)
end

def composite_3_8_simpson(lower, upper, n, &block)
  h = (upper - lower) / (3 * n).to_f

  sum = 0
  (1..n).each do |i|
    sum += yield(x_sub(3 * i - 3, lower, h))
    sum += 3 * yield(x_sub(3 * i - 2, lower, h))
    sum += 3 * yield(x_sub(3 * i - 1, lower, h))
    sum += yield(x_sub(3 * i, lower, h))
  end

  ((3 * h)/8.0) * sum
end

def composite_simpsons_rule(lower, upper, n, &block)
  h = (upper - lower) / (2 * n).to_f

  sum = 0
  (1..n).each do |i|
    sum += yield(x_sub(2 * i - 2, lower, h))
    sum += 4 * yield(x_sub(2 * i - 1, lower, h))
    sum += yield(x_sub(2 * i, lower, h))
  end

  (h / 3.0) * sum
end