Interval

Interval

LazySets.Interval — Type.
Interval{N<:Real, 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 simpler way is to pass a pair of numbers:

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

or a 2-vector:

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

Note that if the package IntervalArithmetic is loaded in the current scope, you have to prepend LazySets. to the Interval type since there is a name conflict otherwise.

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

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

julia> dim(x)
1

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

This type is such that the usual pairwise arithmetic operators +, -, * trigger the corresponding interval arithmetic backend method, and return a new Interval object. For the symbolic Minkowksi sum, use MinkowskiSum or ⊕.

Interval of other numeric types can be created as well, eg. a rational interval:

julia> Interval(0//1, 2//1)
Interval{Rational{Int64},AbstractInterval{Rational{Int64}}}([0//1, 2//1])
source
LazySets.dim — Method.
dim(x::Interval)

Return the ambient dimension of an interval.

Input

  • x – interval

Output

The integer 1.

source
LazySets.σ — Method.
σ(d::AbstractVector{N}, x::Interval{N}) where {N<:Real}

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

Input

  • d – direction
  • x – interval

Output

Support vector in the given direction.

source
LazySets.ρ — Method.
ρ(d::AbstractVector{N}, x::Interval{N}) where {N<:Real}

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{N}, x::Interval{N}) where {N<:Real})

Return whether a vector is contained in the interval.

Input

  • v – one-dimensional vector
  • x – interval

Output

true iff x contains v's first component.

source
Base.:∈ — Method.
∈(v::N, x::Interval{N}) where {N<:Real}

Return whether a number is contained in the interval.

Input

  • v – scalar
  • x – interval

Output

true iff x contains v.

source
LazySets.an_element — Method.
an_element(x::Interval{N}) where {N<:Real}

Return some element of an interval.

Input

  • x – interval

Output

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

source
LazySets.vertices_list — Method.
vertices_list(x::Interval{N}) where {N<:Real}

Return the list of vertices of this interval.

Input

  • x – interval

Output

The list of vertices of the interval represented as two one-dimensional vectors.

source
LazySets.translate — Method.
translate(x::Interval{N}, v::AbstractVector{N}) where {N<:Real}

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.

source
LazySets.center — Method.
center(x::Interval{N}) where {N<:Real}

Return the interval's center.

Input

  • x – interval

Output

The center, or midpoint, of $x$.

source
Base.min — Method.
min(x::Interval{N}) where {N<:Real}

Return the lower component of an interval.

Input

  • x – interval

Output

The lower (lo) component of the interval.

source
Base.max — Method.
max(x::Interval{N}) where {N<:Real}

Return the higher or upper component of an interval.

Input

  • x – interval

Output

The higher (hi) component of the interval.

source
LazySets.low — Method.
low(x::Interval{N}) where {N<:Real}

Return the lower coordinate of an interval set.

Input

  • x – interval

Output

A vector with the lower coordinate of the interval.

source
LazySets.high — Method.
high(x::Interval{N}) where {N<:Real}

Return the higher coordinate of an interval set.

Input

  • x – interval

Output

A vector with the higher coordinate of the interval.

source
LazySets.radius_hyperrectangle — Method.
radius_hyperrectangle(x::Interval{N}) where {N<:Real}

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_hyperrectangle — Method.
radius_hyperrectangle(x::Interval{N}, i::Int) where {N<:Real}

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{N}, y::Interval{N}) where {N<:Real}

Return the difference of the intervals.

Input

  • x – interval
  • y – interval

Output

The difference of the intervals as a new Interval set.

source
Base.:* — Method.
    *(x::Interval{N}, y::Interval{N}) where {N<:Real}

Return the product of the intervals.

Input

  • x – interval
  • y – interval

Output

The product of the intervals as a new Interval set.

source
Base.rand — Method.
rand(::Type{Interval}; [N]::Type{<:Real}=Float64, [dim]::Int=2,
     [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.isflat — Method.
isflat(I::Interval)

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

Input

  • I – interval

Output

A boolean which is 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. Hence, this function depends on the absolute zero tolerance ABSZTOL.

source
LazySets.plot_recipe — Method.
plot_recipe(I::Interval{N}, [ε]::N=zero(N)) where {N<:Real}

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

Input

  • I – 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_map — Method.
linear_map(M::AbstractMatrix{N}, x::Interval{N}) where {N<:Real}

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 whose center is M * center(x) and it has the single generator, M * g, where g = (high(x)-low(x))/2.
source
LazySets.scale — Method.
scale(α::N, x::Interval{N}) where {N<:Real}

Concrete scaling of an interval.

Input

  • α – scalar
  • x – interval

Output

The interval obtained by applying the numerical scale to the given interval.

source
LazySets.constraints_list — Method.
constraints_list(x::Interval{N}) where {N<:Real}

Return the list of constraints of the given interval.

Input

  • x – interval

Output

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

source

Inherited from LazySet:

Inherited from AbstractPolytope:

Inherited from AbstractCentrallySymmetricPolytope:

Inherited from AbstractZonotope:

Inherited from AbstractHyperrectangle: