Interval
LazySets.Interval
— TypeInterval{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 Interval
s 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 Interval
s. 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])
LazySets.dim
— Methoddim(x::Interval)
Return the ambient dimension of an interval.
Input
x
– interval
Output
$1$.
LazySets.σ
— Methodσ(d::AbstractVector, x::Interval)
Return the support vector of an interval in a given direction.
Input
d
– directionx
– interval
Output
The support vector in the given direction.
LazySets.ρ
— Methodρ(d::AbstractVector, x::Interval)
Evaluate the support function of an interval in a given direction.
Input
d
– directionx
– interval
Output
Evaluation of the support function in the given direction.
Base.:∈
— Method∈(v::AbstractVector, x::Interval))
Check whether a given point is contained in an interval.
Input
v
– point/vectorx
– interval
Output
true
iff $v ∈ x$.
Base.:∈
— Method∈(v::Number, x::Interval)
Check whether a number is contained in an interval.
Input
v
– scalarx
– interval
Output
true
iff x
contains the singleton [v]
.
LazySets.an_element
— Methodan_element(x::Interval)
Return some element of an interval.
Input
x
– interval
Output
The left border (low(x)
) of the interval.
LazySets.vertices_list
— Methodvertices_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).
LazySets.translate
— Methodtranslate(x::Interval, v::AbstractVector)
Translate (i.e., shift) an interval by a given vector.
Input
x
– intervalv
– 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.
LazySets.center
— Methodcenter(x::Interval)
Return the center of an interval.
Input
x
– interval
Output
The center, or midpoint, of x
.
LazySets.center
— Methodcenter(H::Interval, i::Int)
Return the center along a given dimension of a interval.
Input
x
– intervali
– dimension of interest
Output
The center along a given dimension of the interval.
Base.min
— Methodmin(x::Interval)
Return the lower component of an interval.
Input
x
– interval
Output
The lower (lo
) component of the interval (a number).
Base.max
— Methodmax(x::Interval)
Return the higher or upper component of an interval.
Input
x
– interval
Output
The higher (hi
) component of the interval (a number).
LazySets.low
— Methodlow(x::Interval)
Return the lower coordinate of an interval set.
Input
x
– interval
Output
A vector with the lower coordinate of the interval.
LazySets.high
— Methodhigh(x::Interval)
Return the higher coordinate of an interval set.
Input
x
– interval
Output
A vector with the higher coordinate of the interval.
LazySets.radius_hyperrectangle
— Methodradius_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).
LazySets.radius_hyperrectangle
— Methodradius_hyperrectangle(x::Interval{N}, i::Int) where {N}
Return the box radius of an interval in a given dimension.
Input
x
– intervali
– dimension index (must be1
)
Output
The box radius in the given dimension.
Base.:-
— Method-(x::Interval, y::Interval)
Return the difference of two intervals (in the interval-arithmetic sense).
Input
x
– intervaly
– interval
Output
The difference of the intervals as a new Interval
set.
Base.:*
— Method *(x::Interval, y::Interval)
Return the product of two intervals (in the interval-arithmetic sense).
Input
x
– intervaly
– interval
Output
The product of the intervals as a new Interval
set.
Base.rand
— Methodrand(::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 dispatchN
– (optional, default:Float64
) numeric typedim
– (optional, default: 1) dimensionrng
– (optional, default:GLOBAL_RNG
) random number generatorseed
– (optional, default:nothing
) seed for reseeding
Output
A random interval.
Algorithm
All numbers are normally distributed with mean 0 and standard deviation 1.
LazySets.isflat
— Methodisflat(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
.
LazySets.plot_recipe
— Methodplot_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.
LazySets.linear_map
— Methodlinear_map(M::AbstractMatrix, x::Interval)
Concrete linear map of an interval.
Input
M
– matrixx
– 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 anInterval
obtained by scalingx
by the matrixM
. - If
size(M, 1) ≠ 1
, the output is aZonotope
with centerM * center(x)
and the single generatorM * g
, whereg = (high(x)-low(x))/2
.
LazySets.scale
— Methodscale(α::Real, x::Interval)
Concrete scaling of an interval.
Input
α
– scalarx
– interval
Output
The interval obtained by scaling the given interval.
LazySets.constraints_list
— Methodconstraints_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.
ReachabilityBase.Arrays.rectify
— Methodrectify(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).
LazySets.diameter
— Functiondiameter(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
– intervalp
– (optional, default:Inf
) norm (ignored)
Output
A real number representing the diameter.
Notes
In one dimension all p-norms are identical.
Base.split
— Methodsplit(x::Interval, k)
Partition an interval into k
uniform sub-intervals.
Input
x
– intervalk
– number of sub-intervals, possibly wrapped in a vector of length 1
Output
A list of k
Interval
s.
LazySets.chebyshev_center_radius
— Methodchebyshev_center_radius(x::Interval; [kwargs]...)
Compute the Chebyshev center and the corresponding radius of an interval.
Input
x
– intervalkwargs
– 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.
Inherited from LazySet
:
Inherited from AbstractPolytope
:
Inherited from AbstractCentrallySymmetricPolytope
:
Inherited from AbstractZonotope
:
Inherited from AbstractHyperrectangle
:
Some additional functionality is available for IntervalArithmetic.Interval
s:
LazySets.fast_interval_pow
— Methodfast_interval_pow(a::IntervalArithmetic.Interval, n::Int)
Compute the n
th power of an interval without using correct rounding.
Input
a
– interval (fromIntervalArithmetic.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
.