`FunctionIntegrator.adaptive_simpsons_rule`

— Function`adaptive_simpsons_rule(f::Function, a::Number, b::Number, ε::Float64=1e-10)`

uses adaptive Simpson's rule with Lyness's criterion to approximate the integral:

$\displaystyle \int_a^b f(x) dx$

with a relative tolerance of $\epsilon$ (which by default is 1e-10).

`FunctionIntegrator.chebyshev_quadrature`

— Method`chebyshev_quadrature(f::Function, N::Number, k::Integer, a::Number, b::Number)`

uses Chebyshev-Gauss quadrature to approximate the integral:

$\displaystyle\int_a^b f(x) dx$.

$N$ is the number of nodes (or grid points) used. Whilst the type mentioned in the function definition is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'), an error message will be printed if it is not a positive integer.

$k$ determines the kind of the Chebyshev polynomial used in the quadrature.

- $k=1$ uses Chebyshev polynomials of the first kind $T_n(x)$.
- $k=2$ uses Chebyshev polynomials of the second kind $U_n(x)$.
- $k=3$ uses Chebyshev polynomials of the third kind $V_n(x)$.
- $k=4$ uses Chebyshev polynomials of the fourth kind $W_n(x)$.

`FunctionIntegrator.hermite_quadrature`

— Function`hermite_quadrature(f::Function, N::Number, k::Integer=1)`

when $k=2$ approximates the integral:

$\displaystyle \int_{-\infty}^{\infty} e^{-x^2} f(x) dx$

and otherwise approximates the integral:

$\displaystyle \int_{-\infty}^{\infty} f(x) dx$

in both instances it uses Gauss-Hermite quadrature to make this approximation.

$N$ is the number of nodes (or grid points) used. Whilst the type mentioned in the function definition is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'), an error message will be printed if it is not a positive integer.

`FunctionIntegrator.jacobi_quadrature`

— Method`jacobi_quadrature(f::Function, N::Number, α::Number, β::Number, a::Number, b::Number)`

uses Gauss-Jacobi quadrature to approximate:

$\displaystyle \int_a^b f(x) dx.$

The remaining inputs of this function are:

- $N$ is the number of nodes (or grid points) used. Whilst the type mentioned in the function definition is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'), an error message will be printed if it is not a positive integer.
- $α$ and $β$, which are parameters of the weighting function.

`FunctionIntegrator.laguerre_quadrature`

— Function`laguerre_quadrature(f::Function, N::Number, k::Integer=1)`

approximates the integral:

$\displaystyle \int_0^{\infty} f(x) dx$

or if $k$ is set to something other than 1:

$\displaystyle \int_0^{\infty} e^{-x} f(x) dx$

using Gauss-Laguerre quadrature.

`FunctionIntegrator.legendre_quadrature`

— Method`legendre_quadrature(f::Function, N::Number, a::Number, b::Number)`

Uses Legendre-Gauss quadrature to approximate:

$\displaystyle \int_a^b f(x) dx$.

`FunctionIntegrator.lobatto_quadrature`

— Method`lobatto_quadrature(f::Function, N::Number, a::Number, b::Number)`

uses Gauss-Lobatto quadrature to approximate:

$\displaystyle \int_a^b f(x) dx.$

`FunctionIntegrator.radau_quadrature`

— Method`radau_quadrature(f::Function, N::Number, a::Number, b::Number)`

uses Radau quadrature to approximate:

$\displaystyle \int_a^b f(x) dx.$

`FunctionIntegrator.rectangle_rule_left`

— Method`rectangle_rule_left(f::Function, N::Number, a::Number, b::Number)`

numerically approximates:

$\displaystyle\int_a^b f(x) dx$

using the left rectangle rule with $N$ gridpoint values. Whilst the type mentioned in the function definition for $N$ is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'); an error message will be printed if it is not a positive integer.

`FunctionIntegrator.rectangle_rule_midpoint`

— Method`rectangle_rule_midpoint(f::Function, N::Number, a::Number, b::Number)`

numerically approximates:

$\displaystyle\int_a^b f(x) dx$

using the midpoint rectangle rule with $N$ gridpoint values. Whilst the type mentioned in the function definition for $N$ is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'); an error message will be printed if it is not a positive integer.

`FunctionIntegrator.rectangle_rule_right`

— Method`rectangle_rule_right(f::Function, N::Number, a::Number, b::Number)`

numerically approximates:

$\displaystyle\int_a^b f(x) dx$

using the right rectangle rule with $N$ gridpoint values. Whilst the type mentioned in the function definition for $N$ is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'); an error message will be printed if it is not a positive integer.

`FunctionIntegrator.rombergs_method`

— Method`rombergs_method(f::Function, N::Number, a::Number, b::Number)`

computes the integral:

$\displaystyle \int_a^b f(x) dx$

using Romberg's method with the $n$ mentioned in the linked article being equal to $N$ in the function arguments.

`FunctionIntegrator.simpsons38_rule`

— Method`simpsons38_rule(f::Function, N::Number, a::Number, b::Number)`

uses Simpson's 3/8 rule to approximate:

$\displaystyle\int_a^b f(x) dx$.

$N+1$ steps are used, if endpoints are included. Whilst the type mentioned in the function definition for $N$ is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'), an error message will be printed if it is not a positive integer. In order to apply Simpson's 3/8 rule, $N$ must be divisible by 3.

`FunctionIntegrator.simpsons_rule`

— Method`simpsons_rule(f::Function, N::Number, a::Number, b::Number)`

uses Simpson's rule to approximate:

$\displaystyle\int_a^b f(x) dx$.

$N+1$ steps are used, if endpoints are included. Whilst the type mentioned in the function definition for $N$ is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'), an error message will be printed if it is not a positive even integer.

`FunctionIntegrator.trapezoidal_rule`

— Method`trapezoidal_rule(f::Function, N::Number, a::Number, b::Number)`

uses the trapezoidal rule to approximate:

$\displaystyle\int_a^b f(x) dx$.

$N+1$ steps are used, if endpoints are included. Whilst the type mentioned in the function definition for $N$ is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'), an error message will be printed if it is not a positive integer.