# Hyperplane

LazySets.HyperplaneModule.HyperplaneType
Hyperplane{N, VN<:AbstractVector{N}} <: 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, Vector{Float64}}([0.0, 1.0], 0.0)
source

## Operations

LazySets.constrained_dimensionsMethod
constrained_dimensions(H::Hyperplane)

Return the dimensions in which a hyperplane is constrained.

Input

• H – hyperplane

Output

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

Examples

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

source
LazySets.API.dimMethod
dim(H::Hyperplane)

Return the dimension of a hyperplane.

Input

• H – hyperplane

Output

The ambient dimension of the hyperplane.

source
LazySets.API.isboundedMethod
isbounded(H::Hyperplane)

Check whether a hyperplane is bounded.

Input

• H – hyperplane

Output

true iff H is one-dimensional.

source
Base.isemptyMethod
isempty(H::Hyperplane)

Check whether a hyperplane is empty.

Input

• H – hyperplane

Output

false.

source
LazySets.API.isuniversalFunction
isuniversal(H::Hyperplane, [witness]::Bool=false)

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.

source
LinearAlgebra.normalizeMethod
normalize(H::Hyperplane{N}, p::Real=N(2)) where {N}

Normalize a hyperplane.

Input

• H – hyperplane
• p – (optional, default: 2) norm

Output

A new hyperplane whose normal direction $a$ is normalized, i.e., such that $‖a‖_p = 1$ holds.

source
Base.randMethod
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.

source
ReachabilityBase.Arrays.distanceMethod
distance(x::AbstractVector, H::Hyperplane{N}) where {N}

Compute the distance between point x and hyperplane H with respect to the Euclidean norm.

Input

• x – vector
• H – hyperplane

Output

A scalar representing the distance between point x and hyperplane H.

source
Base.:∈Method
∈(x::AbstractVector, H::Hyperplane)

Check whether a given point is contained in a hyperplane.

Input

• x – point/vector
• H – hyperplane

Output

true iff $x ∈ H$.

Algorithm

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

source
LazySets.API.projectMethod
project(x::AbstractVector, H::Hyperplane)

Project a point onto a hyperplane.

Input

• x – point
• H – hyperplane

Output

The projection of x onto H.

Algorithm

The projection of $x$ onto the hyperplane of the form $a⋅x = b$ is

$$$x - \dfrac{a (a⋅x - b)}{‖a‖²}$$$
source
LazySets.API.reflectMethod
reflect(x::AbstractVector, H::Hyperplane)

Reflect (mirror) a vector in a hyperplane.

Input

• x – point/vector
• H – hyperplane

Output

The reflection of x in H.

Algorithm

The reflection of a point $x$ in the hyperplane $a ⋅ x = b$ is

$$$x − 2 \frac{x ⋅ a − b}{a ⋅ a} a$$$

where $u · v$ denotes the dot product.

source
LazySets.API.ρMethod
ρ(d::AbstractVector, H::Hyperplane)

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

Input

• d – direction
• H – hyperplane

Output

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

source
LazySets.API.σMethod
σ(d::AbstractVector, H::Hyperplane)

Return a support vector of a hyperplane.

Input

• d – direction
• H – hyperplane

Output

A 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, any point on the hyperplane is a solution. Otherwise this function throws an error.

source
LazySets.API.translateMethod
translate(H::Hyperplane, v::AbstractVector; share::Bool=false)

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

Input

• H – 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 vector 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$.

source

Inherited from LazySet:

Inherited from AbstractPolyhedron: