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_^ f(x)\,dx$

by using the values of at five equally spaced points:

: $\begin & x_0 = a\\ & x_1 = x_1 + h \\ & x_2 = x_1 + 2h \\ & x_3 = x_1 + 3h \\ & x_4 = x_1 +4h = b \end$

It is expressed thus in Abramowitz and Stegun:

: \int_^ f(x)\,dx = \frac\bigl 7f(x_0) + 32 f(x_1) + 12 f(x_2) + 32 f(x_3) + 7f(x_4) \bigr+ \text

where the error term is

: $-\,\frac$

for some number between and where .

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:

(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 $$, b/math>, the composite Boole's rule might be applied. Given $N$ divisions, the integrated value amounts to:

$\int_^ f(x)\,dx = \frac \left( 7(f(x_0) + f(x_N)) + 32\left(\sum_ f(x_i)\right) + 12\left(\sum_ f(x_i)\right) + 14\left(\sum_ f(x_i)\right) \right)$

The following Common Lisp code implements the aforementioned formula:

(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)
(declare (type (integer 0 *) i))
(let ((xi (+ a (* i h))))
(declare (type real xi))
(the real (funcall f xi)))))
(* (/ (* 2 h) 45)
(+ (* 7 (+ (f 0) (f n)))
(* 32 (loop for i from 1 to (- n 1) by 2 sum (f i)))
(* 12 (loop for i from 2 to (- n 2) by 4 sum (f i)))
(* 14 (loop for i from 4 to (- n 4) by 4 sum (f i))))))))

See also

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

Notes

References

*
*
*

{{DEFAULTSORT:Boole's Rule
Integral calculus
Numerical analysis
Numerical integration (quadrature)

Articles with example Lisp (programming language) code