# Interval

LazySets.IntervalType
Interval{N, IN<:AbstractInterval{N}} <: AbstractHyperrectangle{N}

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

$$$[a, b] := \{ a ≤ x ≤ b \} ⊆ \mathbb{R}.$$$

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, IntervalArithmetic.Interval{Float64}}([0, 1])

A 2-vector is also possible:

julia> x = Interval([0.0, 1.0])
Interval{Float64, IntervalArithmetic.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, IntervalArithmetic.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}, IntervalArithmetic.Interval{Rational{Int64}}}([0//1, 2//1])
source
LazySets.dimMethod
dim(x::Interval)

Return the ambient dimension of an interval.

Input

• x – interval

Output

$1$.

source
LazySets.σMethod
σ(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.

source
LazySets.ρMethod
ρ(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.

source
Base.:∈Method
∈(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$.

source
Base.:∈Method
∈(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].

source
LazySets.an_elementMethod
an_element(x::Interval)

Return some element of an interval.

Input

• x – interval

Output

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

source
LazySets.vertices_listMethod
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).

source
LazySets.translateMethod
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.

source
LazySets.centerMethod
center(x::Interval)

Return the center of an interval.

Input

• x – interval

Output

The center, or midpoint, of x.

source
LazySets.centerMethod
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.

source
Base.minMethod
min(x::Interval)

Return the lower component of an interval.

Input

• x – interval

Output

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

source
Base.maxMethod
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).

source
LazySets.lowMethod
low(x::Interval)

Return the lower coordinate of an interval set.

Input

• x – interval

Output

A vector with the lower coordinate of the interval.

source
LazySets.highMethod
high(x::Interval)

Return the higher coordinate of an interval set.

Input

• x – interval

Output

A vector with the higher coordinate of the interval.

source
LazySets.radius_hyperrectangleMethod
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).

source
LazySets.radius_hyperrectangleMethod
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.

source
Base.:-Method
-(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.

source
Base.:*Method
    *(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.

source
Base.randMethod
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.

source
LazySets.isflatMethod
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.

source
LazySets.plot_recipeMethod
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.

source
LazySets.linear_mapMethod
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.
source
LazySets.scaleMethod
scale(α::Real, x::Interval)

Concrete scaling of an interval.

Input

• α – scalar
• x – interval

Output

The interval obtained by scaling the given interval.

source
LazySets.constraints_listMethod
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.

source
ReachabilityBase.Arrays.rectifyMethod
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).

source
LazySets.diameterFunction
diameter(x::Interval, [p]::Real=Inf)

Compute the diameter of an interval, defined as $\Vert b - a\Vert$ 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.

source
Base.splitMethod
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.

source
LazySets.chebyshev_center_radiusMethod
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.

source

Inherited from LazySet:

Inherited from AbstractPolytope:

Inherited from AbstractCentrallySymmetricPolytope:

Inherited from AbstractZonotope:

Inherited from AbstractHyperrectangle:

Some additional functionality is available for IntervalArithmetic.Intervals:

LazySets.fast_interval_powMethod
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`.

source