Interval

Interval{N} <: AbstractHyperrectangle{N}

Type representing an interval on the real line. Mathematically, it is of the form

\[[a, b] := \{ a ≤ x ≤ b \} ⊆ ℝ.\]

Fields

• dat – data container for the given interval

Notes

This type relies on the IntervalArithmetic.jl library for representation of intervals and arithmetic operations.

Examples

Unidimensional intervals are symbolic representations of a real closed interval.

We can create intervals in different ways. The simplest way is to pass a pair of numbers:

julia> x = Interval(0.0, 1.0)
Interval{Float64}([0, 1])

A 2-vector is also possible:

julia> x = Interval([0.0, 1.0])
Interval{Float64}([0, 1])

An interval can also be constructed from an IntervalArithmetic.Interval. Note that if the package IntervalArithmetic is loaded in the current scope, you have to prepend the package names to Intervals since there is a name conflict otherwise.

julia> using IntervalArithmetic
WARNING: using IntervalArithmetic.Interval in module Main conflicts with an existing identifier.

julia> x = LazySets.Interval(IntervalArithmetic.Interval(0.0, 1.0))
Interval{Float64}([0, 1])

julia> dim(x)
1

julia> center(x)
1-element Vector{Float64}:
 0.5

The usual pairwise arithmetic operators - and * are interpreted in the standard way known in interval arithmetic, so the results are Intervals. Note that + is generally used for the lazy Minkowksi sum in this library.

Intervals of other numeric types can be created as well, e.g., a rational interval:

julia> Interval(0//1, 2//1)
Interval{Rational{Int64}}([0//1, 2//1])

dim(x::Interval)

Return the ambient dimension of an interval.

Input

• x – interval

Output

$1$.

σ(d::AbstractVector, x::Interval)

Return the support vector of an interval in a given direction.

Input

• d – direction
• x – interval

Output

The support vector in the given direction.

ρ(d::AbstractVector, x::Interval)

Evaluate the support function of an interval in a given direction.

Input

• d – direction
• x – interval

Output

Evaluation of the support function in the given direction.

∈(v::AbstractVector, x::Interval))

Check whether a given point is contained in an interval.

Input

• v – point/vector
• x – interval

Output

true iff $v ∈ x$.

∈(v::Number, x::Interval)

Check whether a number is contained in an interval.

Input

• v – scalar
• x – interval

Output

true iff x contains the singleton [v].

an_element(x::Interval)

Return some element of an interval.

Input

• x – interval

Output

The left border (low(x)) of the interval.

vertices_list(x::Interval; kwargs...)

Return the list of vertices of an interval.

Input

• x – interval

Output

The list of vertices of the interval, which are two one-dimensional vectors, or just one if the interval is degenerate (the endpoints match within the working tolerance).

translate(x::Interval, v::AbstractVector)

Translate (i.e., shift) an interval by a given vector.

Input

• x – interval
• v – translation vector

Output

A translated interval.

Algorithm

We add the vector to the left and right of the interval.

Notes

An in-place version is not available because the IntervalArithmetic.Interval type is immutable.

center(x::Interval)

Return the center of an interval.

Input

• x – interval

Output

The center, or midpoint, of x.

center(H::Interval, i::Int)

Return the center along a given dimension of a interval.

Input

• x – interval
• i – dimension of interest

Output

The center along a given dimension of the interval.

min(x::Interval)

Return the lower component of an interval.

Input

• x – interval

Output

The lower (lo) component of the interval (a number).

max(x::Interval)

Return the higher or upper component of an interval.

Input

• x – interval

Output

The higher (hi) component of the interval (a number).

low(x::Interval)

Return the lower coordinate of an interval set.

Input

• x – interval

Output

A vector with the lower coordinate of the interval.

high(x::Interval)

Return the higher coordinate of an interval set.

Input

• x – interval

Output

A vector with the higher coordinate of the interval.

radius_hyperrectangle(x::Interval)

Return the box radius of an interval in every dimension.

Input

• x – interval

Output

The box radius of the interval (a one-dimensional vector).

radius_hyperrectangle(x::Interval{N}, i::Int) where {N}

Return the box radius of an interval in a given dimension.

Input

• x – interval
• i – dimension index (must be 1)

Output

The box radius in the given dimension.

-(x::Interval, y::Interval)

Return the difference of two intervals (in the interval-arithmetic sense).

Input

• x – interval
• y – interval

Output

The difference of the intervals as a new Interval set.

    *(x::Interval, y::Interval)

Return the product of two intervals (in the interval-arithmetic sense).

Input

• x – interval
• y – interval

Output

The product of the intervals as a new Interval set.

rand(::Type{Interval}; [N]::Type{<:Real}=Float64, [dim]::Int=1,
     [rng]::AbstractRNG=GLOBAL_RNG, [seed]::Union{Int, Nothing}=nothing)

Create a random interval.

Input

• Interval – type for dispatch
• N – (optional, default: Float64) numeric type
• dim – (optional, default: 1) dimension
• rng – (optional, default: GLOBAL_RNG) random number generator
• seed – (optional, default: nothing) seed for reseeding

Output

A random interval.

Algorithm

All numbers are normally distributed with mean 0 and standard deviation 1.

isflat(x::Interval)

Check whether an interval is flat, i.e., whether its extreme values coincide.

Input

• x – interval

Output

true if the interval is flat and false otherwise.

Notes

For robustness with respect to floating-point inputs, this function relies on the result of isapproxzero when applied to the diameter of the interval. In other words, this function depends on the absolute zero tolerance ABSZTOL.

plot_recipe(x::Interval{N}, [ε]=zero(N)) where {N}

Convert an interval to a pair (x, y) of points for plotting.

Input

• x – interval
• ε – (optional, default: 0) ignored, used for dispatch

Output

A pair (x, y) of two points that can be plotted.

Notes

We consider the interval as a line segment with y coordinate equal to zero.

linear_map(M::AbstractMatrix, x::Interval)

Concrete linear map of an interval.

Input

• M – matrix
• x – interval

Output

Either an interval or a zonotope, depending on the leading dimension (i.e., the number of rows) of M:

• If size(M, 1) == 1, the output is an Interval obtained by scaling x by the matrix M.
• If size(M, 1) ≠ 1, the output is a Zonotope with center M * center(x) and the single generator M * g, where g = (high(x)-low(x))/2.

scale(α::Real, x::Interval)

Concrete scaling of an interval.

Input

• α – scalar
• x – interval

Output

The interval obtained by scaling the given interval.

constraints_list(x::Interval)

Return the list of constraints of an interval.

Input

• x – interval

Output

The list of constraints of the interval represented as two one-dimensional half-spaces.

rectify(x::Interval{N}) where {N}

Concrete rectification of an interval.

Input

• x – interval

Output

The Interval that corresponds to the rectification of x.

Notes

Note that the result is an Interval even if the set becomes a singleton (which is the case if the original interval was nonpositive).

diameter(x::Interval, [p]::Real=Inf)

Compute the diameter of an interval, defined as $‖b - a‖$ in the $p`-norm, where$a$(resp.$b``) are the minimum (resp. maximum) value of the interval.

Input

• x – interval
• p – (optional, default: Inf) norm (ignored)

Output

A real number representing the diameter.

Notes

In one dimension all p-norms are identical.

split(x::Interval, k)

Partition an interval into k uniform sub-intervals.

Input

• x – interval
• k – number of sub-intervals, possibly wrapped in a vector of length 1

Output

A list of k Intervals.

ngens(x::Interval)

Return the number of generators of an interval.

Input

• x – interval

Output

The number of generators.

Algorithm

An interval has either one generator, or zero generators if it is a degenerated interval of diameter zero.

chebyshev_center_radius(x::Interval; [kwargs]...)

Compute the Chebyshev center and the corresponding radius of an interval.

Input

• x – interval
• kwargs – further keyword arguments (ignored)

Output

The pair (c, r) where c is the Chebyshev center of x and r is the radius of the largest ball with center c enclosed by x.

Notes

The Chebyshev center of an interval is just the center of the interval.

reflect(x::Interval)

Concrete reflection of a interval x, resulting in the reflected set -x.

Input

• x – interval

Output

The Interval representing -x.

Algorithm

If $x = [a, b]$, then $-x = [-b, -a]$.

fast_interval_pow(a::IntervalArithmetic.Interval, n::Int)

Compute the nth power of an interval without using correct rounding.

Input

• a – interval (from IntervalArithmetic.jl)
• n – integer

Output

A non-rigorous approximation of a^n.

Notes

For a rigorous approximation with correct rounding, use a^n from IntervalArithmetic.jl.