# Line segment (LineSegment)

`LazySets.LineSegment`

— Type`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, Vector{Float64}}([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. If it is desired to remove the endpoints, pass the options `markershape=:none`

and `seriestype=:shape`

.

Membership is checked 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, Vector{Float64}}([1.0, 0.0], [0.0, 1.0])
julia> isempty(s ∩ sn)
false
julia> isdisjoint(s, sn, true)
(false, [0.5, 0.5])
```

`LazySets.dim`

— Method`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.

`LazySets.σ`

— Method`σ(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$.

`Base.:∈`

— Method`∈(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.

- A necessary condition for $x ∈ (p, q)$ is that the three points are aligned, thus their cross product should be zero.
- 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.

`LazySets.center`

— Method`center(L::LineSegment)`

Return the center of a line segment.

**Input**

`L`

– line segment

**Output**

The center of the line segment.

`LazySets.an_element`

— Method`an_element(L::LineSegment)`

Return some element of a line segment.

**Input**

`L`

– line segment

**Output**

The first vertex of the line segment.

`Base.rand`

— Method```
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.

`LazySets.halfspace_left`

— Method`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`

.

`LazySets.halfspace_right`

— Method`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`

.

`LazySets.vertices_list`

— Method`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.

`LazySets.constraints_list`

— Method`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.

`LazySets.translate`

— Method`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.

`LazySets.generators`

— Method`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`

.

`LazySets.genmat`

— Methodgenmat(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`

.

Inherited from `ConvexSet`

:

Inherited from `AbstractPolytope`

:

Inherited from `AbstractCentrallySymmetricPolytope`

:

Inherited from `AbstractZonotope`

: