Boole's rule

In mathematics, Boole's rule, named after George Boole, is a method of numerical integration.

Formula

Simple Boole's Rule

It approximates an integral: $$\underset{a}{\overset{b}{\int }}f(x)dx$$ by using the values of Template:Mvar at five equally spaced points: $$\begin{array}{rl}& x_0=a\\ & x_1=x_0+h\\ & x_2=x_0+2h\\ & x_3=x_0+3h\\ & x_4=x_0+4h=b\end{array}$$

It is expressed thus in Abramowitz and Stegun: $$\underset{x_0}{\overset{x_4}{\int }}f(x)dx=\frac{2h}{45}[7f(x_0)+32f(x_1)+12f(x_2)+32f(x_3)+7f(x_4)]+\text{error term}$$ where the error term is $$-\frac{8f^{(6)}(\xi )h^7}{945}$$ for some number Template:Tmath between Template:Tmath and Template:Tmath where 945 = 1 × 3 × 5 × 7 × 9.

It is often known as Bode's rule, due to a typographical error that propagated from Abramowitz and Stegun.

The following constitutes a very simple implementation of the method in Common Lisp which ignores the error term:

Example implementation in Common Lisp

(defun integrate-booles-rule (f x1 x5)
  "Calculates the Boole's rule numerical integral of the function F in
   the closed interval extending from inclusive X1 to inclusive X5
   without error term inclusion."
  (declare (type (function (real) real) f))
  (declare (type real                   x1 x5))
  (let ((h (/ (- x5 x1) 4)))
    (declare (type real h))
    (let* ((x2 (+ x1 h))
           (x3 (+ x2 h))
           (x4 (+ x3 h)))
      (declare (type real x2 x3 x4))
      (* (/ (* 2 h) 45)
         (+ (*  7 (funcall f x1))
            (* 32 (funcall f x2))
            (* 12 (funcall f x3))
            (* 32 (funcall f x4))
            (*  7 (funcall f x5)))))))

Composite Boole's Rule

In cases where the integration is permitted to extend over equidistant sections of the interval $[a,b]$, the composite Boole's rule might be applied. Given $N$ divisions, where $N$ mod $4=0$, the integrated value amounts to:

$$\underset{x_0}{\overset{x_N}{\int }}f(x)dx=\frac{2h}{45}(7(f(x_0)+f(x_N))+32(\sum _{i\in \{1,3,5,\dots ,N-1\}}f(x_i))+12(\sum _{i\in \{2,6,10,\dots ,N-2\}}f(x_i))+14(\sum _{i\in \{4,8,12,\dots ,N-4\}}f(x_i)))+\text{error term}$$

where the error term is similar to above. The following Common Lisp code implements the aforementioned formula:

Example implementation in Common Lisp

(defun integrate-composite-booles-rule (f a b n)
  "Calculates the composite Boole's rule numerical integral of the
   function F in the closed interval extending from inclusive A to
   inclusive B across N subintervals."
  (declare (type (function (real) real) f))
  (declare (type real                   a b))
  (declare (type (integer 1 *)          n))
  (let ((h (/ (- b a) n)))
    (declare (type real h))
    (flet ((f[i] (i)
            (declare (type (integer 0 *) i))
            (let ((xi (+ a (* i h))))
              (declare (type real xi))
              (the real (funcall f xi)))))
      (* (/ (* 2 h) 45)
         (+ (*  7 (+ (f[i] 0) (f[i] n)))
            (* 32 (loop for i from 1 to (- n 1) by 2 sum (f[i] i)))
            (* 12 (loop for i from 2 to (- n 2) by 4 sum (f[i] i)))
            (* 14 (loop for i from 4 to (- n 4) by 4 sum (f[i] i))))))))

Example implementation in R

booleQuad <- function(fx, dx) {
  # Calculates the composite Boole's rule numerical 
  # integral for a function with a vector of precomputed
  # values fx evaluated at the points in vector dx.
  n <- length(dx)
  h <- diff(dx)
  stopifnot(exprs = {
    length(fx) == n
    n > 8L
    h[1L] >= 0
    n >= 2L
    n %% 4L == 1L
    isTRUE(all.equal(h, rep(h[1L], length(h))))
  })
  nm2 <- n - 2L
  cf <- double(nm2)
  cf[seq.int(1, nm2, 2L)] <- 32
  cf[seq.int(2, nm2, 4L)] <- 12
  cf[seq.int(4, nm2, 4L)] <- 14
  cf <- c(7, cf, 7)
  sum(cf * fx) * 2 * h[1L] / 45
}

See also

• Newton–Cotes formulas
• Simpson's rule
• Romberg's method