bquadpy 0.16.10

Numerical integration, quadrature for various domains

Your one-stop shop for numerical integration in Python.

More than 1500 numerical integration schemes for line segments, circles, disks, triangles, quadrilaterals, spheres, balls, tetrahedra, hexahedra, wedges, pyramids, n-spheres, n-balls, n-cubes, n-simplices, the 1D half-space with weight functions exp(-r), the 2D space with weight functions exp(-r), the 3D space with weight functions exp(-r), the nD space with weight functions exp(-r), the 1D space with weight functions exp(-r²), the 2D space with weight functions exp(-r²), the 3D space with weight functions exp(-r²), and the nD space with weight functions exp(-r²), for fast integration of real-, complex-, and vector-valued functions.

For example, to numerically integrate any function over any given interval, install quadpy from the Python Package Index with

pip install quadpy

and do

import numpy as np
import quadpy


def f(x):
    return np.sin(x) - x


val, err = quadpy.quad(f, 0.0, 6.0)

This is like scipy with the addition that quadpy handles complex-, vector-, matrix-valued integrands, and "intervals" in spaces of arbitrary dimension.

To integrate over a triangle, do

import numpy as np
import quadpy


def f(x):
    return np.sin(x[0]) * np.sin(x[1])


triangle = np.array([[0.0, 0.0], [1.0, 0.0], [0.7, 0.5]])

# get a "good" scheme of degree 10
scheme = quadpy.t2.get_good_scheme(10)
val = scheme.integrate(f, triangle)

Most domains have get_good_scheme(degree). If you would like to use a particular scheme, you can pick one from the dictionary quadpy.t2.schemes.

All schemes have

scheme.points
scheme.weights
scheme.degree
scheme.source
scheme.test_tolerance

scheme.show()
scheme.integrate(
    # ...
)

and many have

scheme.points_symbolic
scheme.weights_symbolic

quadpy is fully vectorized, so if you like to compute the integral of a function on many domains at once, you can provide them all in one integrate() call, e.g.,

# shape (3, 5, 2), i.e., (corners, num_triangles, xy_coords)
triangles = np.stack(
    [
        [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]],
        [[1.2, 0.6], [1.3, 0.7], [1.4, 0.8]],
        [[26.0, 31.0], [24.0, 27.0], [33.0, 28]],
        [[0.1, 0.3], [0.4, 0.4], [0.7, 0.1]],
        [[8.6, 6.0], [9.4, 5.6], [7.5, 7.4]],
    ],
    axis=-2,
)

The same goes for functions with vectorized output, e.g.,

def f(x):
    return [np.sin(x[0]), np.sin(x[1])]

More examples under test/examples_test.py.

Read more about the dimensionality of the input/output arrays in the wiki.

Advanced topics:

• Adaptive quadrature
• Creating your own Gauss scheme
• tanh-sinh quadrature

Schemes

Line segment (C₁)

• Chebyshev-Gauss (type 1 and 2, arbitrary degree)
• Clenshaw-Curtis (arbitrary degree)
• Fejér (type 1 and 2, arbitrary degree)
• Gauss-Jacobi (arbitrary degree)
• Gauss-Legendre (arbitrary degree)
• Gauss-Lobatto (arbitrary degree)
• Gauss-Kronrod (arbitrary degree)
• Gauss-Patterson (9 nested schemes up to degree 767)
• Gauss-Radau (arbitrary degree)
• Newton-Cotes (open and closed, arbitrary degree)

See here for how to generate Gauss formulas for your own weight functions.

Example:

import numpy as np
import quadpy

scheme = quadpy.c1.gauss_patterson(5)
scheme.show()
val = scheme.integrate(lambda x: np.exp(x), [0.0, 1.0])

1D half-space with weight function exp(-r) (E₁^r)

• Generalized Gauss-Laguerre

Example:

import quadpy

scheme = quadpy.e1r.gauss_laguerre(5, alpha=0)
scheme.show()
val = scheme.integrate(lambda x: x ** 2)

1D space with weight function exp(-r²) (E₁^r2)

• Gauss-Hermite (arbitrary degree)
• Genz-Keister (1996, 8 nested schemes up to degree 67)

Example:

import quadpy

scheme = quadpy.e1r2.gauss_hermite(5)
scheme.show()
val = scheme.integrate(lambda x: x ** 2)

Circle (U₂)

• Krylov (1959, arbitrary degree)

Example:

import numpy as np
import quadpy

scheme = quadpy.u2.get_good_scheme(7)
scheme.show()
val = scheme.integrate(lambda x: np.exp(x[0]), [0.0, 0.0], 1.0)

Triangle (T₂)

Apart from the classical centroid, vertex, and seven-point schemes we have

• Hammer-Marlowe-Stroud (1956, 5 schemes up to degree 5)
• Albrecht-Collatz (1958, degree 3)
• Stroud (1971, conical product scheme of degree 7)
• Franke (1971, 2 schemes of degree 7)
• Strang-Fix/Cowper (1973, 10 schemes up to degree 7),
• Lyness-Jespersen (1975, 21 schemes up to degree 11, two of which are used in TRIEX),
• Lether (1976, degree 2n-2, arbitrary n, not symmetric),
• Hillion (1977, 10 schemes up to degree 3),
• Laursen-Gellert (1978, 17 schemes up to degree 10),
• CUBTRI (Laurie, 1982, degree 8),
• Dunavant (1985, 20 schemes up to degree 20),
• Cools-Haegemans (1987, degrees 8 and 11),
• Gatermann (1988, degree 7)
• Berntsen-Espelid (1990, 4 schemes of degree 13, the first one being DCUTRI),
• Liu-Vinokur (1998, 13 schemes up to degree 5),
• Griener-Schmid, (1999, 2 schemes of degree 6),
• Walkington (2000, 5 schemes up to degree 5),
• Wandzura-Xiao (2003, 6 schemes up to degree 30),
• Taylor-Wingate-Bos (2005, 5 schemes up to degree 14),
• Zhang-Cui-Liu (2009, 3 schemes up to degree 20),
• Xiao-Gimbutas (2010, 50 schemes up to degree 50),
• Vioreanu-Rokhlin (2014, 20 schemes up to degree 62),
• Williams-Shunn-Jameson (2014, 8 schemes up to degree 12),
• Witherden-Vincent (2015, 19 schemes up to degree 20),
• Papanicolopulos (2016, 27 schemes up to degree 25),
• all schemes for the n-simplex.

Example:

import numpy as np
import quadpy

scheme = quadpy.t2.get_good_scheme(12)
scheme.show()
val = scheme.integrate(lambda x: np.exp(x[0]), [[0.0, 0.0], [1.0, 0.0], [0.5, 0.7]])

Disk (S₂)

• Radon (1948, degree 5)
• Peirce (1956, 3 schemes up to degree 11)
• Peirce (1957, arbitrary degree)
• Albrecht-Collatz (1958, degree 3)
• Hammer-Stroud (1958, 8 schemes up to degree 15)
• Albrecht (1960, 8 schemes up to degree 17)
• Mysovskih (1964, 3 schemes up to degree 15)
• Rabinowitz-Richter (1969, 6 schemes up to degree 15)
• Lether (1971, arbitrary degree)
• Piessens-Haegemans (1975, 1 scheme of degree 9)
• Haegemans-Piessens (1977, degree 9)
• Cools-Haegemans (1985, 4 schemes up to degree 13)
• Wissmann-Becker (1986, 3 schemes up to degree 8)
• Kim-Song (1997, 15 schemes up to degree 17)
• Cools-Kim (2000, 3 schemes up to degree 21)
• Luo-Meng (2007, 6 schemes up to degree 17)
• all schemes from the n-ball

Example:

import numpy as np
import quadpy

scheme = quadpy.s2.get_good_scheme(6)
scheme.show()
val = scheme.integrate(lambda x: np.exp(x[0]), [0.0, 0.0], 1.0)

Quadrilateral (C₂)

• Maxwell (1890, degree 7)
• Burnside (1908, degree 5)
• Irwin (1923, 3 schemes up to degree 5)
• Tyler (1953, 3 schemes up to degree 7)
• Hammer-Stroud (1958, 3 schemes up to degree 7)
• Albrecht-Collatz (1958, 4 schemes up to degree 5)
• Miller (1960, degree 1, degree 11 for harmonic integrands)
• Meister (1966, degree 7)
• Phillips (1967, degree 7)
• Rabinowitz-Richter (1969, 6 schemes up to degree 15)
• Franke (1971, 10 schemes up to degree 9)
• Piessens-Haegemans (1975, 2 schemes of degree 9)
• Haegemans-Piessens (1977, degree 7)
• Schmid (1978, 3 schemes up to degree 6)
• Cools-Haegemans (1985, 6 schemes up to degree 17)
• Dunavant (1985, 11 schemes up to degree 19)
• Morrow-Patterson (1985, 2 schemes up to degree 20, single precision)
• Cohen-Gismalla, (1986, 2 schemes up to degree 3)
• Wissmann-Becker (1986, 6 schemes up to degree 8)
• Cools-Haegemans (1988, 2 schemes up to degree 13)
• Waldron (1994, infinitely many schemes of degree 3)
• Sommariva (2012, 55 schemes up to degree 55)
• Witherden-Vincent (2015, 11 schemes up to degree 21)
• products of line segment schemes
• all schemes from the n-cube

Example:

import numpy as np
import quadpy

scheme = quadpy.c2.get_good_scheme(7)

val = scheme.integrate_box(lambda x: np.exp(x[0]), (0.0, 1.0), (0.0, 1.0))

This is if the integration limits in x and y can be given separately.

If you're dealing with a general quadrilateral, the points are specified in an array of shape (2, 2, ...) such that arr[0][0] is the lower left corner, arr[1][1] the upper right.

val = scheme.integrate(
    lambda x: np.exp(x[0]),
    [[[0.0, 0.0], [1.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]]],
)

2D space with weight function exp(-r) (E₂^r)

• Stroud-Secrest (1963, 2 schemes up to degree 7)
• Rabinowitz-Richter (1969, 4 schemes up to degree 15)
• Stroud (1971, degree 4)
• Haegemans-Piessens (1977, 2 schemes up to degree 9)
• Cools-Haegemans (1985, 3 schemes up to degree 13)
• all schemes from the nD space with weight function exp(-r)

Example:

import quadpy

scheme = quadpy.e2r.get_good_scheme(5)
scheme.show()
val = scheme.integrate(lambda x: x[0] ** 2)

2D space with weight function exp(-r²) (E₂^r2)

• Stroud-Secrest (1963, 2 schemes up to degree 7)
• Rabinowitz-Richter (1969, 5 schemes up to degree 15)
• Stroud (1971, 3 schemes up to degree 7)
• Haegemans-Piessens (1977, 2 schemes of degree 9)
• Cools-Haegemans (1985, 3 schemes up to degree 13)
• all schemes from the nD space with weight function exp(-r²)

Example:

import quadpy

scheme = quadpy.e2r2.get_good_scheme(3)
scheme.show()
val = scheme.integrate(lambda x: x[0] ** 2)

Sphere (U₃)

• Albrecht-Collatz (1958, 5 schemes up to degree 7)
• McLaren (1963, 10 schemes up to degree 14)
• Lebedev (1976, 34 schemes up to degree 131)
• Bažant-Oh (1986, 3 schemes up to degree 13)
• Heo-Xu (2001, 27 schemes up to degree 39)
• Fliege-Maier (2007, 4 schemes up to degree 4, single-precision)
• all schemes from the n-sphere

Example:

import numpy as np
import quadpy

scheme = quadpy.u3.get_good_scheme(19)
# scheme.show()
val = scheme.integrate(lambda x: np.exp(x[0]), [0.0, 0.0, 0.0], 1.0)

Integration on the sphere can also be done for functions defined in spherical coordinates:

import numpy as np
import quadpy


def f(theta_phi):
    theta, phi = theta_phi
    return np.sin(phi) ** 2 * np.sin(theta)


scheme = quadpy.u3.get_good_scheme(19)
val = scheme.integrate_spherical(f)

Ball (S₃)

• Ditkin (1948, 3 schemes up to degree 7)
• Hammer-Stroud (1958, 6 schemes up to degree 7)
• Mysovskih (1964, degree 7)
• Stroud (1971, 2 schemes up to degree 14)
• all schemes from the n-ball

Example:

import numpy as np
import quadpy

scheme = quadpy.s3.get_good_scheme(4)
# scheme.show()
val = scheme.integrate(lambda x: np.exp(x[0]), [0.0, 0.0, 0.0], 1.0)

Tetrahedron (T₃)

• Hammer-Marlowe-Stroud (1956, 3 schemes up to degree 3, also appearing in Hammer-Stroud)
• Stroud (1971, degree 7)
• Yu (1984, 5 schemes up to degree 6)
• Keast (1986, 10 schemes up to degree 8)
• Beckers-Haegemans (1990, degrees 8 and 9)
• Gatermann (1992, degree 5)
• Liu-Vinokur (1998, 14 schemes up to degree 5)
• Walkington (2000, 6 schemes up to degree 7)
• Zhang-Cui-Liu (2009, 2 schemes up to degree 14)
• Xiao-Gimbutas (2010, 15 schemes up to degree 15)
• Shunn-Ham (2012, 6 schemes up to degree 7)
• Vioreanu-Rokhlin (2014, 10 schemes up to degree 13)
• Williams-Shunn-Jameson (2014, 1 scheme with degree 9)
• Witherden-Vincent (2015, 9 schemes up to degree 10)
• Jaśkowiec-Sukumar (2020, 21 schemes up to degree 20)
• all schemes for the n-simplex.

Example:

import numpy as np
import quadpy

scheme = quadpy.t3.get_good_scheme(5)
# scheme.show()
val = scheme.integrate(
    lambda x: np.exp(x[0]),
    [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 0.7, 0.0], [0.3, 0.9, 1.0]],
)

Hexahedron (C₃)

• Sadowsky (1940, degree 5)
• Tyler (1953, 2 schemes up to degree 5)
• Hammer-Wymore (1957, degree 7)
• Albrecht-Collatz (1958, degree 3)
• Hammer-Stroud (1958, 6 schemes up to degree 7)
• Mustard-Lyness-Blatt (1963, 6 schemes up to degree 5)
• Stroud (1967, degree 5)
• Sarma-Stroud (1969, degree 7)
• Witherden-Vincent (2015, 7 schemes up to degree degree 11)
• all schemes from the n-cube
• Product schemes derived from line segment schemes

Example:

import numpy as np
import quadpy

scheme = quadpy.c3.product(quadpy.c1.newton_cotes_closed(3))
# scheme.show()
val = scheme.integrate_box(lambda x: np.exp(x[0]), (0.0, 1.0), (-0.3, 0.4), (1.0, 2.1))

Pyramid (P₃)

• Felippa (2004, 9 schemes up to degree 5)

Example:

import numpy as np
import quadpy

scheme = quadpy.p3.felippa_5()

val = scheme.integrate(
    lambda x: np.exp(x[0]),
    [
        [0.0, 0.0, 0.0],
        [1.0, 0.0, 0.0],
        [0.5, 0.7, 0.0],
        [0.3, 0.9, 0.0],
        [0.0, 0.1, 1.0],
    ],
)

Wedge (W₃)

• Felippa (2004, 6 schemes up to degree 6)
• Kubatko-Yeager-Maggi (2013, 21 schemes up to degree 9)

Example:

import numpy as np
import quadpy

scheme = quadpy.w3.felippa_3()
val = scheme.integrate(
    lambda x: np.exp(x[0]),
    [
        [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 0.7, 0.0]],
        [[0.0, 0.0, 1.0], [1.0, 0.0, 1.0], [0.5, 0.7, 1.0]],
    ],
)

3D space with weight function exp(-r) (E₃^r)

• Stroud-Secrest (1963, 5 schemes up to degree 7)
• all schemes from the nD space with weight function exp(-r)

Example:

import quadpy

scheme = quadpy.e3r.get_good_scheme(5)
# scheme.show()
val = scheme.integrate(lambda x: x[0] ** 2)

3D space with weight function exp(-r²) (E₃^r2)

• Stroud-Secrest (1963, 7 schemes up to degree 7)
• Stroud (1971, scheme of degree 14)
• all schemes from the nD space with weight function exp(-r²)

Example:

import quadpy

scheme = quadpy.e3r2.get_good_scheme(6)
# scheme.show()
val = scheme.integrate(lambda x: x[0] ** 2)

n-Simplex (T_n)

• Lauffer (1955, 5 schemes up to degree 5)
• Hammer-Stroud (1956, 3 schemes up to degree 3)
• Stroud (1964, degree 3)
• Stroud (1966, 7 schemes of degree 3)
• Stroud (1969, degree 5)
• Silvester (1970, arbitrary degree),
• Grundmann-Möller (1978, arbitrary degree)
• Walkington (2000, 5 schemes up to degree 7)

Example:

import numpy as np
import quadpy

dim = 4
scheme = quadpy.tn.grundmann_moeller(dim, 3)
val = scheme.integrate(
    lambda x: np.exp(x[0]),
    np.array(
        [
            [0.0, 0.0, 0.0, 0.0],
            [1.0, 2.0, 0.0, 0.0],
            [0.0, 1.0, 0.0, 0.0],
            [0.0, 3.0, 1.0, 0.0],
            [0.0, 0.0, 4.0, 1.0],
        ]
    ),
)

n-Sphere (U_n)

• Stroud (1967, degree 7)
• Stroud (1969, 3 <= n <= 16, degree 11)
• Stroud (1971, 6 schemes up to degree 5)
• Dobrodeev (1978, n >= 2, degree 5)
• Mysovskikh (1980, 2 schemes up to degree 5)

Example:

import numpy as np
import quadpy

dim = 4
scheme = quadpy.un.dobrodeev_1978(dim)
val = scheme.integrate(lambda x: np.exp(x[0]), np.zeros(dim), 1.0)

n-Ball (S_n)

• Stroud (1957, degree 2)
• Hammer-Stroud (1958, 2 schemes up to degree 5)
• Stroud (1966, 4 schemes of degree 5)
• Stroud (1967, 4 <= n <= 7, 2 schemes of degree 5)
• Stroud (1967, n >= 3, 3 schemes of degree 7)
• Stenger (1967, 6 schemes up to degree 11)
• McNamee-Stenger (1967, 6 schemes up to degree 9)
• Dobrodeev (1970, n >= 3, degree 7)
• Dobrodeev (1978, 2 <= n <= 20, degree 5)
• Stoyanova (1997, n >= 5, degree 7)

Example:

import numpy as np
import quadpy

dim = 4
scheme = quadpy.sn.dobrodeev_1970(dim)
val = scheme.integrate(lambda x: np.exp(x[0]), np.zeros(dim), 1.0)

n-Cube (C_n)

• Ewing (1941, degree 3)
• Tyler (1953, degree 3)
• Stroud (1957, 2 schemes up to degree 3)
• Hammer-Stroud (1958, degree 5)
• Mustard-Lyness-Blatt (1963, degree 5)
• Thacher (1964, degree 2)
• Stroud (1966, 4 schemes of degree 5)
• Phillips (1967, degree 7)
• McNamee-Stenger (1967, 6 schemes up to degree 9)
• Stroud (1968, degree 5)
• Dobrodeev (1970, n >= 5, degree 7)
• Dobrodeev (1978, n >= 2, degree 5)
• Cools-Haegemans (1994, 2 schemes up to degree 5)

Example:

import numpy as np
import quadpy

scheme = quadpy.cn.stroud_cn_3_3(n=4)
val = scheme.integrate_box(
    lambda x: np.exp(x[0]), (0.0, 1.0), (0.1, 0.9), (-1.0, 1.0), (-1.0, -0.5)
)

nD space with weight function exp(-r) (E_n^r)

• Stroud-Secrest (1963, 4 schemes up to degree 5)
• McNamee-Stenger (1967, 6 schemes up to degree 9)
• Stroud (1971, 2 schemes up to degree 5)

Example:

import quadpy

dim = 4
scheme = quadpy.enr.stroud_enr_5_4(dim)
val = scheme.integrate(lambda x: x[0] ** 2)

nD space with weight function exp(-r²) (E_n^r2)

• Stroud-Secrest (1963, 4 schemes up to degree 5)
• McNamee-Stenger (1967, 6 schemes up to degree 9)
• Stroud (1967, 2 schemes of degree 5)
• Stroud (1967, 3 schemes of degree 7)
• Stenger (1971, 6 schemes up to degree 11, varying dimensionality restrictions)
• Stroud (1971, 5 schemes up to degree 5)
• Phillips (1980, degree 5)
• Cools-Haegemans (1994, 3 schemes up to degree 7)
• Lu-Darmofal (2004, degree 5)
• Xiu (2008, degree 2)

Example:

import quadpy

dim = 4
scheme = quadpy.enr2.stroud_enr2_5_2(dim)
val = scheme.integrate(lambda x: x[0] ** 2)

Installation

quadpy is available from the Python Package Index, so with

pip install quadpy

you can install.

Testing

To run the tests, check out this repository and type

MPLBACKEND=Agg pytest

License

This software is published under the GPLv3 license.