# Internal API Reference

This is an exhaustive list of all non-exported modules, constants, types, functions and macros in `DomainSets.jl`

.

Unexported functions and types are subject to change across different releases of the package, even if the release is said to be non-breaking. This overview is useful to better understand or to help develop the internals of DomainSets.

## Constants

## Functions

`DomainSets.FunctionMaps.toexternalpoint`

— MethodInverse of `tointernalpoint`

.

`DomainSets.FunctionMaps.tointernalpoint`

— MethodTranslate a point of the lazy domain to a point (or points) of the composing domain.

`DomainSets.combine`

— FunctionCombine the outputs of `in`

of member domains into a single output of the lazy domain.

`DomainSets.domain_tolerance`

— MethodReturn a suitable tolerance to use for verifying whether a point is close to a domain. Typically, the tolerance is close to the precision limit of the numeric type associated with the domain.

`DomainSets.indicatorfunction`

— MethodThe indicator function of a domain is the function `f(x) = x ∈ D`

.

`DomainSets.intersectbox`

— MethodReturn the bounding box of the intersection of two or more bounding boxes.

`DomainSets.iscompatiblepair`

— MethodIs the given combination of point and domain compatible?

`DomainSets.parametric_domain`

— Method`parametric_domain(fmap, domain)`

The domain that results from mapping the given domain.

`DomainSets.promotable_domains`

— MethodCan the domains be promoted without throwing an error?

`DomainSets.promote_domains`

— MethodPromote the given domains to have a common element type.

`DomainSets.promote_map_domain_pair`

— Method`promote_map_domain_pair(map, domain)`

Promote the map and the domain such that the output satisfies `codomaintype(map) == domaineltype(domain)`

.

`DomainSets.promote_pair`

— MethodPromote point and domain to compatible types.

`DomainSets.similar_interval`

— MethodReturn an interval that is similar to the given interval, but with endpoints `a`

and `b`

instead.

`DomainSets.simplifies`

— Method`simplifies(domain)`

Does the domain simplify?

`DomainSets.simplify`

— Method`simplify(domain)`

Simplify the given domain to an equal domain.

`DomainSets.todomainset`

— MethodConvert the given domain to a domain defined in DomainSets.jl.

`DomainSets.unionbox`

— MethodReturn the bounding box of the union of two or more bounding boxes.

`DomainSets.vectorized_approx_in`

— MethodVectorized version of `approx_in`

: apply `x ∈ d`

to all elements of `A`

.

`DomainSets.vectorized_in`

— MethodVectorized version of `in`

: apply `x ∈ d`

to all elements of `A`

.

## Types

`DomainSets.AbstractIndicatorFunction`

— TypeSupertype of domains that are defined by an indicator function.

An indicator function is a function `f : S -> [0,1]`

that indicates membership of `x`

to a domain `D`

with `D ⊂ S`

. The indicator function corresponds exactly to the `in`

function of a domain: `f(x) = x ∈ D`

.

Concrete subtypes of `AbstractIndicatorFunction`

store a representation of this indicator function and implement `in`

using that representation, rather than implementing `in`

directly.

`DomainSets.AbstractLevelSet`

— TypeSupertype of level set domains of the form `f(x)=C`

.

`DomainSets.AbstractMappedDomain`

— TypeA `MappedDomain`

represents the mapping of a domain.

The map of a domain `d`

under the mapping `y=f(x)`

consists of all points `f(x)`

with `x ∈ d`

. The characteristic function of a mapped domain is defined in terms of the inverse map `g = inverse(f)`

:

`x ∈ m ⟺ g(x) ∈ d`

`DomainSets.AbstractSublevelSet`

— TypeSupertype of sublevel set domains.

`DomainSets.AbstractSuperlevelSet`

— TypeSupertype of superlevel set domains.

`DomainSets.AbstractVectorDomain`

— TypeAn `AbstractVectorDomain`

is any domain whose eltype is `<:AbstractVector{T}`

.

`DomainSets.BoundedIndicatorFunction`

— TypeAn indicator function with a known bounding domain.

`DomainSets.CompositeDomain`

— TypeA composite lazy domain is defined in terms of multiple domains.

`DomainSets.Cube`

— TypeA `Cube`

is a hyperrectangle with equal side lengths in each dimension.

`DomainSets.DerivedDomain`

— TypeAbstract supertype for domains that wrap another domain.

`DomainSets.DomainPoint`

— TypeA `DomainPoint`

is a point which is an element of a domain by construction.

A domain point is just a point, not a domain. This is different from a `Point`

type.

The type is a wrapper: retrieve the underlying point using `point(p)`

.

`DomainSets.DomainSetStyle`

— TypeThe broadcast style associated with domains

`DomainSets.EuclideanBall`

— TypeA ball in a fixed N-dimensional Euclidean space.

`DomainSets.EuclideanCube`

— TypeA cube in a fixed N-dimensional Euclidean space.

`DomainSets.EuclideanSphere`

— TypeA hypersphere in a fixed N-dimensional Euclidean space.

`DomainSets.EuclideanSpherePoint`

— TypeA point on the unit sphere represented by a standard Euclidean vector.

`DomainSets.ExampleNamedDomain`

— TypeExample of a domain that wraps another domain and thus obtains its own type.

`DomainSets.FixedInterval`

— TypeThe abstract type `FixedInterval`

is the supertype of intervals with endpoints determined by the type, rather than field values. Examples include `UnitInterval`

and `ChebyshevInterval`

.

`DomainSets.FixedIntervalProduct`

— TypeThe N-fold cartesian product of a fixed interval.

`DomainSets.FunctionLevelSet`

— TypeA `FunctionLevelSet`

is a set that derives from the levels of a function.

`DomainSets.GenericBall`

— TypeA `GenericBall`

is a ball with a given radius and center.

`DomainSets.GenericSphere`

— TypeA `GenericSphere`

is a sphere with a given radius and center.

`DomainSets.HyperRectangle`

— TypeA `HyperRectangle`

is the cartesian product of intervals.

`DomainSets.Isomorphic`

— Type`Isomorphic <: CanonicalType`

An isomorphic canonical domain is a domain that is the same up to an isomorphism.

`DomainSets.LazyComposedMap`

— TypeSupertype of all compositions of a lazy domain. The composition determines how the point `x`

is distributed to the member domains of a lazy domain.

Three compositions implemented in the package are:

`NoComposedMap`

: the lazy domain encapsulates a single domain and`x`

is passed

`through unaltered`

`Combination`

: the lazy domain has several members and`x`

is passed to the`in`

`method of all members`

`Product`

: the lazy domain has several members and the components of`x`

are

`passed to the components of the lazy domain`

`DomainSets.LazyDomain`

— TypeA lazy domain evaluates its membership function on the fly in terms of that of other domains.

The `in(x, domain::LazyDomain)`

applies three types of transformations:

- Point mapping:
`y = tointernalpoint(domain, x)`

- Distribution of
`y`

over member domains given by`components(domain)`

- Combination of the outputs into a single boolean result.

The distribution step is determined by the result of `composition(domain)`

, see `composition`

. The combination is performed by `combine`

. Mapping between points of the lazy domain and points of its member domains is described by `y = tointernalpoint(domain, x)`

and `x = toexternalpoint(domain, y)`

.

`DomainSets.NaturalNumbers`

— TypeThe set of all natural numbers.

`DomainSets.NegativeRealLine`

— Type`NegativeRealLine{T=Float64}()`

The open negative halfline `(-∞,0)`

.

`DomainSets.NonnegativeRealLine`

— Type`NonnegativeRealLine{T=Float64}()`

The closed positive halfline `[0,∞)`

.

`DomainSets.NonpositiveRealLine`

— Type`NonpositiveRealLine{T=Float64}()`

The closed negative halfline `(-∞,0]`

.

`DomainSets.One`

— Type`One()`

Representation of the number 1.

`DomainSets.Origin`

— Type`Origin()`

Representation of the origin.

`DomainSets.Parameterization`

— Type`Parameterization <: CanonicalType`

A parametric canonical domain can be parameterized from a simpler domain.

`DomainSets.ParametricDomain`

— TypeA `ParametricDomain`

stores the forward map of a mapped domain.

`DomainSets.PositiveRealLine`

— Type`PositiveRealLine{T=Float64}()`

The open positive halfline `(0,∞)`

.

`DomainSets.SimpleLazyDomain`

— TypeA simple lazy domain is defined in terms of a single domain.

It has no composition and no combination of its `in`

function.

`DomainSets.Simplex`

— TypeSupertype of an N-dimensional simplex.

`DomainSets.SpherePoint`

— TypeA point on the unit sphere.

`DomainSets.SphericalCoordinate`

— TypeA point on the unit sphere represented in spherical coordinates.

`DomainSets.VectorBall`

— TypeA ball with vector elements of variable length.

`DomainSets.VectorCube`

— TypeA cube with vector elements of variable length.

`DomainSets.VectorSphere`

— TypeA sphere with vector elements of variable length.

`DomainSets.WrappedDomain`

— TypeA `WrappedDomain`

is a wrapper around an object that implements the domain interface, and that is itself a domain.