Hyperplane

Hyperplane{N<:Real} <: AbstractPolyhedron{N}

Type that represents a hyperplane of the form $a⋅x = b$.

Fields

• a – normal direction (non-zero)
• b – constraint

Examples

The plane $y = 0$:

julia> Hyperplane([0, 1.], 0.)
Hyperplane{Float64}([0.0, 1.0], 0.0)

dim(hp::Hyperplane)

Return the dimension of a hyperplane.

Input

• hp – hyperplane

Output

The ambient dimension of the hyperplane.

ρ(d::AbstractVector{N}, hp::Hyperplane{N}) where {N<:Real}

Evaluate the support function of a hyperplane in a given direction.

Input

• d – direction
• hp – hyperplane

Output

The support function of the hyperplane. If the set is unbounded in the given direction, the result is Inf.

σ(d::AbstractVector{N}, hp::Hyperplane{N}) where {N<:Real}

Return the support vector of a hyperplane.

Input

• d – direction
• hp – hyperplane

Output

The support vector in the given direction, which is only defined in the following two cases:

1. The direction has norm zero.
2. The direction is the hyperplane's normal direction or its opposite direction.

In all cases, the result is any point on the hyperplane. Otherwise this function throws an error.

∈(x::AbstractVector{N}, hp::Hyperplane{N}) where {N<:Real}

Check whether a given point is contained in a hyperplane.

Input

• x – point/vector
• hp – hyperplane

Output

true iff $x ∈ hp$.

Algorithm

We just check if $x$ satisfies $a⋅x = b$.

an_element(hp::Hyperplane{N}) where {N<:Real}

Return some element of a hyperplane.

Input

• hp – hyperplane

Output

An element on the hyperplane.

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

Create a random hyperplane.

Input

• Hyperplane – 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 hyperplane.

Algorithm

All numbers are normally distributed with mean 0 and standard deviation 1. Additionally, the constraint a is nonzero.

isbounded(hp::Hyperplane)

Determine whether a hyperplane is bounded.

Input

• hp – hyperplane

Output

false.

isuniversal(hp::Hyperplane{N}, [witness]::Bool=false) where {N<:Real}

Check whether a hyperplane is universal.

Input

• P – hyperplane
• witness – (optional, default: false) compute a witness if activated

Output

• If witness option is deactivated: false
• If witness option is activated: (false, v) where $v ∉ P$

Algorithm

A witness is produced by adding the normal vector to an element on the hyperplane.

isempty(hp::Hyperplane)

Return if a hyperplane is empty or not.

Input

• hp – hyperplane

Output

false.

constrained_dimensions(hp::Hyperplane{N}) where {N<:Real}

Return the indices in which a hyperplane is constrained.

Input

• hp – hyperplane

Output

A vector of ascending indices i such that the hyperplane is constrained in dimension i.

Examples

A 2D hyperplane with constraint $x1 = 0$ is constrained in dimension 1 only.

constraints_list(hp::Hyperplane{N}) where {N<:Real}

Return the list of constraints of a hyperplane.

Input

• hp – hyperplane

Output

A list containing two half-spaces.

translate(hp::Hyperplane{N}, v::AbstractVector{N}; share::Bool=false
         ) where {N<:Real}

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

Input

• hp – hyperplane
• v – translation vector
• share – (optional, default: false) flag for sharing unmodified parts of the original set representation

Output

A translated hyperplane.

Notes

The normal vectors of the hyperplane (vector a in a⋅x = b) is shared with the original hyperplane if share == true.

Algorithm

A hyperplane $a⋅x = b$ is transformed to the hyperplane $a⋅x = b + a⋅v$. In other words, we add the dot product $a⋅v$ to $b$.