Line segment (LineSegment)

LineSegment{N, VN<:AbstractVector{N}} <: AbstractZonotope{N}

Type that represents a line segment in 2D between two points $p$ and $q$.

Fields

• p – first point
• q – second point

Examples

A line segment along the $x = y$ diagonal:

julia> s = LineSegment([0., 0], [1., 1.])
LineSegment{Float64,Array{Float64,1}}([0.0, 0.0], [1.0, 1.0])

julia> dim(s)
2

Use plot(s) to plot the extreme points of s and the line segment joining them. Membership test is computed with ∈ (in):

julia> [0., 0] ∈ s && [.25, .25] ∈ s && [1., 1] ∈ s && [.5, .25] ∉ s
true

We can check the intersection with another line segment, and optionally compute a witness (which is just the common point in this case):

julia> sn = LineSegment([1., 0], [0., 1.])
LineSegment{Float64,Array{Float64,1}}([1.0, 0.0], [0.0, 1.0])

julia> isempty(s ∩ sn)
false

julia> is_intersection_empty(s, sn, true)
(false, [0.5, 0.5])

dim(L::LineSegment)

Return the ambient dimension of a line segment.

Input

• L – line segment

Output

The ambient dimension of the line segment, which is 2.

σ(d::AbstractVector, L::LineSegment)

Return the support vector of a line segment in a given direction.

Input

• d – direction
• L – line segment

Output

The support vector in the given direction.

Algorithm

If the angle between the vector $q - p$ and $d$ is bigger than 90° and less than 270° (measured in counter-clockwise order), the result is $p$, otherwise it is $q$. If the angle is exactly 90° or 270°, or if the direction has norm zero, this implementation returns $q$.

∈(x::AbstractVector, L::LineSegment)

Check whether a given point is contained in a line segment.

Input

• x – point/vector
• L – line segment

Output

true iff $x ∈ L$.

Algorithm

Let $L = (p, q)$ be the line segment with extremes $p$ and $q$, and let $x$ be the given point.

1. A necessary condition for $x ∈ (p, q)$ is that the three points are aligned, thus their cross product should be zero.
2. It remains to check that $x$ belongs to the box approximation of $L$. This amounts to comparing each coordinate with those of the extremes $p$ and $q$.

Notes

The algorithm is inspired from here.

center(L::LineSegment)

Return the center of a line segment.

Input

• L – line segment

Output

The center of the line segment.

an_element(L::LineSegment)

Return some element of a line segment.

Input

• L – line segment

Output

The first vertex of the line segment.

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

Create a random line segment.

Input

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

Output

A random line segment.

Algorithm

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

halfspace_left(L::LineSegment)

Return a half-space describing the 'left' of a two-dimensional line segment through two points.

Input

• L – line segment

Output

The half-space whose boundary goes through the two points p and q and which describes the left-hand side of the directed line segment pq.

halfspace_right(L::LineSegment)

Return a half-space describing the 'right' of a two-dimensional line segment through two points.

Input

• L – line segment

Output

The half-space whose boundary goes through the two points p and q and which describes the right-hand side of the directed line segment pq.

vertices_list(L::LineSegment)

Return the list of vertices of a line segment.

Input

• L – line segment

Output

The list of end points of the line segment.

constraints_list(L::LineSegment)

Return the list of constraints defining a line segment in 2D.

Input

• L – line segment

Output

A vector of constraints that define the line segment.

Algorithm

$L$ is defined by 4 constraints. In this algorithm, the first two constraints are returned by $halfspace_right$ and $halfspace_left$, and the other two are obtained by considering the vector normal to the line segment that passes through each opposite vertex.

Notes

This function returns a vector of halfspaces. It does not return equality constraints.

translate(L::LineSegment, v::AbstractVector)

Translate (i.e., shift) a line segment by a given vector.

Input

• L – line segment
• v – translation vector

Output

A translated line segment.

Algorithm

We add the vector to both defining points of the line segment.

generators(S::AbstractSingleton{N}) where {N}

Return an (empty) iterator over the generators of a set with a single value.

Input

• S – set with a single value

Output

An empty iterator.

generators(L::LineSegment{N}) where {N}

Return an iterator over the (single) generator of a line segment.

Input

• L – line segment

Output

A one-element iterator over the generator of L.

genmat(L::LineSegment)

Return the generator matrix of a line segment.

Input

• L – line segment

Output

A matrix with a single column representing the generator of L.