Line
LazySets.Line
— TypeLine{N, VN<:AbstractVector{N}} <: AbstractPolyhedron{N}
Type that represents a line of the form
\[ \{y ∈ \mathbb{R}^n: y = p + λd, λ ∈ \mathbb{R}\}\]
where $p$ is a point on the line and $d$ is its direction vector (not necessarily normalized).
Fields
p
– point on the lined
– direction
Examples
The line passing through the point $[-1, 2, 3]$ and parallel to the vector $[3, 0, -1]$:
julia> Line([-1, 2, 3.], [3, 0, -1.])
Line{Float64, Vector{Float64}}([-1.0, 2.0, 3.0], [3.0, 0.0, -1.0])
LazySets.dim
— Methoddim(L::Line)
Return the ambient dimension of a line.
Input
L
– line
Output
The ambient dimension of the line.
LazySets.ρ
— Methodρ(d::AbstractVector, L::Line)
Evaluate the support function of a line in a given direction.
Input
d
– directionL
– line
Output
Evaluation of the support function in the given direction.
LazySets.σ
— Methodσ(d::AbstractVector, L::Line)
Return a support vector of a line in a given direction.
Input
d
– directionL
– line
Output
A support vector in the given direction.
Base.:∈
— Method∈(x::AbstractVector, L::Line)
Check whether a given point is contained in a line.
Input
x
– point/vectorL
– line
Output
true
iff x ∈ L
.
Algorithm
The point $x$ belongs to the line $L : p + λd$ if and only if $x - p$ is proportional to the direction $d$.
LazySets.an_element
— Methodan_element(L::Line)
Return some element of a line.
Input
L
– line
Output
An element on the line.
LazySets.direction
— Methoddirection(L::Line)
Return the direction of the line.
Input
L
– line
Output
The direction of the line.
Notes
The direction is not necessarily normalized. See normalize(::Line, ::Real)
/ normalize!(::Line, ::Real)
.
Base.rand
— Methodrand(::Type{Line}; [N]::Type{<:Real}=Float64, [dim]::Int=2,
[rng]::AbstractRNG=GLOBAL_RNG, [seed]::Union{Int, Nothing}=nothing)
Create a random line.
Input
Line
– type for dispatchN
– (optional, default:Float64
) numeric typedim
– (optional, default: 2) dimensionrng
– (optional, default:GLOBAL_RNG
) random number generatorseed
– (optional, default:nothing
) seed for reseeding
Output
A random line.
Algorithm
All numbers are normally distributed with mean 0 and standard deviation 1.
LazySets.isbounded
— Methodisbounded(L::Line)
Determine whether a line is bounded.
Input
L
– line
Output
false
.
LazySets.isuniversal
— Methodisuniversal(L::Line; [witness::Bool]=false)
Check whether a line is universal.
Input
P
– linewitness
– (optional, default:false
) compute a witness if activated
Output
- If
witness
isfalse
:true
if the ambient dimension is one,false
otherwise.
- If
witness
istrue
:(true, [])
if the ambient dimension is one,
(false, v)
where $v ∉ P$ otherwise.
Base.isempty
— Methodisempty(L::Line)
Check whether a line is empty or not.
Input
L
– line
Output
false
.
LazySets.constraints_list
— Methodconstraints_list(L::Line)
Return the list of constraints of a line.
Input
L
– line
Output
A list containing 2n-2
half-spaces whose intersection is L
, where n
is the ambient dimension of L
.
LazySets.translate
— Methodtranslate(L::Line, v::AbstractVector)
Translate (i.e., shift) a line by a given vector.
Input
L
– linev
– translation vector
Output
A translated line.
Notes
See also translate!
for the in-place version.
LazySets.translate!
— Methodtranslate!(L::Line, v::AbstractVector)
Translate (i.e., shift) a line by a given vector, in-place.
Input
L
– linev
– translation vector
Output
The line L
translated by v
.
LinearAlgebra.normalize
— Functionnormalize(L::Line, p::Real=2.0)
Normalize the direction of a line.
Input
L
– linep
– (optional, default:2.0
) vectorp
-norm used in the normalization
Output
A line whose direction has unit norm w.r.t. the given p
-norm.
Notes
See also normalize!(::Line, ::Real)
for the in-place version.
LinearAlgebra.normalize!
— Functionnormalize!(L::Line, p::Real=2.0)
Normalize the direction of a line storing the result in L
.
Input
L
– linep
– (optional, default:2.0
) vectorp
-norm used in the normalization
Output
A line whose direction has unit norm w.r.t. the given p
-norm.
ReachabilityBase.Arrays.distance
— Methoddistance(x::AbstractVector, L::Line; [p]::Real=2.0)
Compute the distance between point x
and the line with respect to the given p
-norm.
Input
x
– point/vectorL
– linep
– (optional, default:2.0
) thep
-norm used;p = 2.0
corresponds to the usual Euclidean norm
Output
A scalar representing the distance between x
and the line L
.
LazySets.linear_map
— Methodlinear_map(M::AbstractMatrix, L::Line)
Concrete linear map of a line.
Input
M
– matrixL
– line
Output
The line obtained by applying the linear map, if that still results in a line, or a Singleton
otherwise.
Algorithm
We apply the linear map to the point and direction of L
. If the resulting direction is zero, the result is a singleton.
Inherited from LazySet
: