`DomainIntegrals.AbstractIntegral`

— Type`Integral`

is a functional that represents integration of a function.

`DomainIntegrals.AbstractJacobiWeight`

— TypeSupertype of Jacobi weights.

`DomainIntegrals.AbstractQuadraticForm`

— TypeSupertype of quadratic forms that derive from a two-form.

If `F`

is a TwoForm, then we call `F(f,f)`

the associated quadratic form.

`DomainIntegrals.AlgebraicSingPoint`

— TypeAn algebraic singularity at a specific point.

`DomainIntegrals.BestRule`

— TypeUse a quadrature rule adapted to the measure.

`DomainIntegrals.BilinearForm`

— TypeA bilinear form is linear in its two arguments.

`DomainIntegrals.CanonicalInt`

— TypeA canonical domain for the purposes of evaluating integrals.

`DomainIntegrals.ChebyshevIntervalRule`

— TypeApply a quadrature rule defined on `[-1,1]`

.

`DomainIntegrals.ChebyshevTWeight`

— TypeThe `Chebyshev`

or `ChebyshevT`

weight is the measure on `[-1,1]`

with the Chebyshev weight function `w(x) = 1/√(1-x^2)`

.

`DomainIntegrals.ChebyshevUWeight`

— TypeThe ChebyshevU weight is the measure on `[-1,1]`

with the Chebyshev weight function of the second kind `w(x) = √(1-x^2).`

`DomainIntegrals.CurveSingularity`

— TypeSupertype of singularities along a curve.

`DomainIntegrals.DiracWeight`

— TypeA continuous Dirac measure at a point

`DomainIntegrals.DiscreteWeight`

— TypeA `DiscreteWeight`

is a measure defined in terms of a discrete set of points and an associated set of weights.

The measure implements the `points`

and `weights`

functions.

`DomainIntegrals.DomainRule`

— TypeA quadrature rule associated with a domain.

`DomainIntegrals.DuffyTransform`

— TypeThe Duffy transform maps the unit square to the unit simplex.

It does so by collapsing the rightmost edge onto the x-axis.

`DomainIntegrals.DummyDiscreteDomain`

— TypeA dummy domain to be associated with a discrete measure, for internal purposes.

`DomainIntegrals.FunIntegrand`

— TypeRepresentation of an integrand function.

`DomainIntegrals.GaussianWeight`

— TypeThe Gaussian measure with weight exp(-|x|^2/2).

`DomainIntegrals.GenericDiscreteWeight`

— TypeA generic discrete weight that stores points and weights.

`DomainIntegrals.GenericInnerProduct`

— TypeA generic inner product that stores a positive definite Hermitian sesquilinear form.

`DomainIntegrals.GenericWeight`

— TypeA generic continuous weight function.

`DomainIntegrals.HalfLineRule`

— TypeApply a fixed quadrature rule defined on the halfline `[0,∞)`

.

`DomainIntegrals.HermiteWeight`

— TypeThe Hermite measure with weight exp(-x^2) on the real line.

`DomainIntegrals.InducedBilinearForm`

— TypeA bilinear form induced by a measure.

It is the case that `F(f,g)`

equals `integral(x -> f(x)*g(x), measure(F))`

.

`DomainIntegrals.InducedSesquilinearForm`

— TypeA sesquilinear form induced by a measure.

It is the case that `F(f,g)`

equals `integral(x -> f(x)*conj(g(x)), measure(F))`

.

`DomainIntegrals.InnerProduct`

— TypeAn inner-product is a positive definite sesquilinear form.

`DomainIntegrals.Integrand`

— TypeSupertype of an integrand which evaluates to `T`

.

`DomainIntegrals.JacobiWeight`

— TypeThe Jacobi weight on the interval `[-1,1]`

.

`DomainIntegrals.LaguerreWeight`

— TypeThe generalised Laguerre measure on the halfline `[0,∞)`

.

`DomainIntegrals.Lebesgue`

— TypeThe Lebesgue measure on the space `FullSpace{T}`

.

`DomainIntegrals.LebesgueDomain`

— TypeLebesgue measure supported on a general domain.

`DomainIntegrals.LebesgueMeasure`

— TypeSupertype of Lebesgue measures

`DomainIntegrals.LebesgueUnit`

— TypeThe Lebesgue measure on the unit interval `[0,1]`

.

`DomainIntegrals.LegendreWeight`

— TypeThe Legendre weight is a Lebesgue measure on the interval `[-1,1]`

.

`DomainIntegrals.LogSingPoint`

— TypeA logarithmic singularity at a specific point.

`DomainIntegrals.LoggingFunction`

— TypeWrap a function and log any point at which it is evaluated.

`DomainIntegrals.LowerRightTriangle`

— TypeThe triangle below the diagonal of a square `[a,b] × [a,b]`

.

`DomainIntegrals.MappedWeight`

— TypeRepresentation of a weight mapped to a new weight.

Given a weight `w(x)dx`

and a map `y=m(x)`

, the mapped weight is defined as `w(m(x))/J(m(x))dx`

, where `J`

is the jacobian determinant of `m`

.

The definition is such that we have the following equality after a change of variables:

integral(t->f(t), domain, weight) = integral(t -> f(inverse(m,t))), m.(domain), MappedWeight(m, weight)

`DomainIntegrals.Measure`

— TypeSupertype of measures.

`DomainIntegrals.MeasureBilinearForm`

— TypeA bilinear form induced by a generic measure.

`DomainIntegrals.MeasureSesquilinearForm`

— TypeA sesquilinear form induced by a generic measure.

`DomainIntegrals.NoProperty`

— TypeNo property of the integrand is known.

`DomainIntegrals.NoSingularity`

— TypeNo singularity of the integrand is known.

`DomainIntegrals.OneForm`

— TypeA one-form is a map `V → K`

, i.e., it is a generic function of one argument.

A one-form is applied to an argument using the `F(f)`

syntax, which itself invokes `form(F::OneForm, f)`

. The `form`

function can be specialized for concrete types of `F`

and `f`

.

The main use cases in `DomainIntegrals.jl`

are a lazy `Integral`

object and a quadratic form that derives from a bilinear form.

`DomainIntegrals.PointSingularity`

— TypeSupertype of all kinds of point singularities.

`DomainIntegrals.ProductWeight`

— TypeA product weight.

`DomainIntegrals.Property`

— TypeA `Property`

type describes a property of the integrand that is independent from the other aspects of the integral (domain, measure).

The main examples are singularities of the integrand function, i.e., smoothness properties.

`DomainIntegrals.Q_hcubature`

— TypeAdaptive quadrature using hcubature

`DomainIntegrals.Q_quadgk`

— TypeAdaptive quadrature using quadgk

`DomainIntegrals.QuadAdaptive`

— TypeAn adaptive quadrature strategy

`DomainIntegrals.QuadraticForm`

— TypeA quadratic form derived from a stored two-form.

`DomainIntegrals.RealLineRule`

— TypeApply a fixed quadrature rule defined on the real line.

`DomainIntegrals.SesquilinearForm`

— TypeA sesquilinear form is linear in the first and conjugate linear in the second argument.

`DomainIntegrals.SingCorner`

— TypeAn unspecified singularity occurring at a corner point.

`DomainIntegrals.SingPoint`

— TypeAn unspecified singularity occurring at a specific point.

`DomainIntegrals.SingularDiagonal`

— TypeFor 2D integrands, a singularity along the line `x=y`

.

`DomainIntegrals.Singularity`

— TypeThe supertype of all kinds of singularities of an integrand.

`DomainIntegrals.TransformationLogIntegrand`

— TypeAn integrand that logs any transformations which are applied to it.

`DomainIntegrals.Triangle`

— TypeA triangle defined by three points in a plane.

`DomainIntegrals.TwoForm`

— TypeA two-form is a map `V x W → K`

, i.e., it is a generic function of two arguments.

The two-form is applied to two arguments using the `F(f,g)`

syntax, which itself invokes `form(F::TwoForm, f, g)`

. The `form`

function can be specialized for concrete types of `F`

, `f`

and `g`

.

`DomainIntegrals.UnitIntervalRule`

— TypeApply a fixed quadrature rule defined on `[0,1]`

.

`DomainIntegrals.UpperRightTriangle`

— TypeThe triangle above the diagonal of a square `[a,b] × [a,b]`

.

`DomainIntegrals.Waypoints`

— TypeA list of breakpoints of the integrand, for example because the integrand is piecewise smooth.

`DomainIntegrals.Weight`

— TypeA `Weight`

is a continuous measure that is defined in terms of a weight function: `dμ = w(x) dx`

.

`DomainIntegrals.cauchy_integral`

— Method`cauchy_integral(f [; a = 0, n = 1, radius = 1])`

Evaluate the integral of `n!/(2πi) f(z)/(z-a)^n`

along a circular contour with radius `radius`

around the point `a`

.

If the integrand is analytic inside the contour except at the pole around `z=a`

then its value should correspond to the derivative `f^(n)(a)`

.

`DomainIntegrals.composite_rule`

— MethodTurn the interval rule into a composite quadrature rule with `L`

segments on the same interval.

`DomainIntegrals.domain_split`

— MethodSplit the integration domain into subdomains.

`DomainIntegrals.domain_splits`

— MethodDoes the integration domain naturally split into subdomains?

`DomainIntegrals.form`

— MethodApply a two-form to the given arguments.

`form(F::TwoForm, f, g)`

By default, `form`

invokes `form1`

which in turn invokes `form2`

. The `form`

function itself can be specialized on the type of `F`

without ambiguity. Similarly, `form1`

and `form2`

can be specialized without ambiguity on the types of `f`

and `g`

respectively.

Each of these functions can be specialized on all three types involved, as long as the main type is at least as specific as any other specialization.

`DomainIntegrals.form1`

— MethodHelper function for `form(F, f, g)`

that can be specialized on the type of `f`

.

`DomainIntegrals.form2`

— MethodHelper function for `form(F, f, g)`

that can be specialized on the type of `g`

.

`DomainIntegrals.graded_rule_left`

— FunctionConstruct a graded quadrature rule towards the left of the unit interval.

The rule is a composite quadrature rule on intervals of the form `σ^(k+1):σ^k`

. The number of points on interval `i`

is `⌈n*i*μ⌉`

, where `μ`

is an optional parameter.

`DomainIntegrals.graded_rule_right`

— MethodConstruct a graded quadrature rule towards the right of the unit interval.

See: `graded_rule_left`

.

`DomainIntegrals.has_integration_domain`

— MethodIs the domain associated with a simpler domain for numerical integration?

`DomainIntegrals.integral`

— FunctionCompute an integral of the given integrand on the given domain, or with the given measure.

Example:

`integral(cos, 0.0..1.0)`

`DomainIntegrals.integrate`

— FunctionLike integral, but also returns an error estimate (if applicable).

`DomainIntegrals.integration_domain`

— MethodReturn the integration domain associated with `d`

.

`DomainIntegrals.iscontinuous`

— MethodIs the measure continuous?

`DomainIntegrals.isdiscrete`

— MethodIs the measure discrete?

`DomainIntegrals.ismappedmeasure`

— MethodIs the given measure the map of another measure?

`DomainIntegrals.isnormalized`

— MethodIs the measure normalized?

`DomainIntegrals.isuniform`

— MethodDoes the discrete measure have equal weights?

`DomainIntegrals.lebesguemeasure`

— MethodThe Lebesgue measure associated with the given domain

`DomainIntegrals.mapfrom_integration_domain`

— MethodReturn the map from the integration domain of `d`

to `d`

.

`DomainIntegrals.mappedmeasure`

— MethodMap the weight using the given map.

`DomainIntegrals.nonoverlapping_domains`

— MethodConvert a union of domains into a vector of domains without overlap.

`DomainIntegrals.process_properties`

— MethodTransform the integral problem based on the supplied properties.

For example, if the integrand is known to be singular, then the domain may be split into several components such that there are no singularities in the interior.

`DomainIntegrals.productmeasure`

— MethodConstruct the product of the given measures.

`DomainIntegrals.splitdomain_point`

— MethodSplit the domain according to a singularity at the point `x`

.

`DomainIntegrals.splitdomain_sing`

— MethodSplit the domain into a list of domains, such that any singularity lies on the boundary of one or more of the constituting parts.

Care is taken to avoid a singularity in the interior due to roundoff errors.

`DomainIntegrals.suggestedstrategy`

— MethodThe suggested quadrature strategy based on the `integral`

arguments.

By default, adaptive quadrature is chosen.

`DomainIntegrals.support`

— MethodReturn the support of the measure.

`DomainIntegrals.weightfun`

— MethodEvaluate the weight function associated with the measure.

`DomainSets.codomaintype`

— MethodWhat is the codomain type of the measure?