# 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: $\int _{a}^{b}f(x)\,dx$ by using the values of f at five equally spaced points: ${\begin{aligned}&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{aligned}}$
It is expressed thus in Abramowitz and Stegun: $\int _{x_{0}}^{x_{4}}f(x)\,dx={\frac {2h}{45}}{\bigl7f(x_{0})+32f(x_{1})+12f(x_{2})+32f(x_{3})+7f(x_{4}){\bigr ]}+{\text{error term}}$ where the error term is $-\,{\frac {8f^{(6)}(\xi )h^{7}}{945}}$ for some number ⁠$\xi$⁠ between ⁠$x_{0}$⁠ and ⁠$x_{4}$⁠ 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:
$\int _{x_{0}}^{x_{N}}f(x)\,dx={\frac {2h}{45}}\left(7(f(x_{0})+f(x_{N}))+32\left(\sum _{i\in \{1,3,5,\ldots ,N-1\}}f(x_{i})\right)+12\left(\sum _{i\in \{2,6,10,\ldots ,N-2\}}f(x_{i})\right)+14\left(\sum _{i\in \{4,8,12,\ldots ,N-4\}}f(x_{i})\right)\right)+{\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