# Bloating

`LazySets.Bloating`

— Type`Bloating{N, S<:LazySet{N}} <: LazySet{N}`

Type that represents a uniform expansion of a set in a given norm (also known as *bloating*).

**Fields**

`X`

– set`ε`

– (usually positive) bloating factor`p`

– $p$-norm (should be $≥ 1$; default: $2$)

**Notes**

The `Bloating`

operation preserves convexity: if `X`

is convex, then any bloating of `X`

is convex as well.

If `ε`

is positive, then `Bloating(X, ε, p)`

is equivalent to the Minkowski sum of `X`

and a ball in the `p`

-norm of radius `ε`

centered in the origin `O`

(i.e., `X ⊕ Ballp(p, O, ε)`

).

Some operations require, or silently assume, that `ε`

is positive. Check the documentation for further information.

`LazySets.dim`

— Method`dim(B::Bloating)`

Return the dimension of a bloated set.

**Input**

`B`

– bloated set

**Output**

The ambient dimension of the bloated set.

`LazySets.σ`

— Method`σ(d::AbstractVector, B::Bloating)`

Return the support vector of a bloated set in a given direction.

**Input**

`d`

– direction`B`

– bloated set

**Output**

The support vector of the bloated set in the given direction.

`LazySets.ρ`

— Method`ρ(d::AbstractVector, B::Bloating)`

Return the support function of a bloated set in a given direction.

**Input**

`d`

– direction`B`

– bloated set

**Output**

The support function of the bloated set in the given direction.

`LazySets.isbounded`

— Method`isbounded(B::Bloating)`

Determine whether a bloated set is bounded.

**Input**

`B`

– bloated set

**Output**

`true`

iff the wrapped set is bounded.

`Base.isempty`

— Method`isempty(B::Bloating)`

Determine whether a bloated set is empty.

**Input**

`B`

– bloated set

**Output**

`true`

iff the wrapped set is empty.

**Notes**

This implementation disregards negative bloating, which could potentially turn a non-empty set into an empty set.

`LazySets.an_element`

— Method`an_element(B::Bloating)`

Return some element of a bloated set.

**Input**

`B`

– bloated set

**Output**

An element in the bloated set.

**Algorithm**

This implementation disregards negative bloating and returns the result of `an_element`

for the wrapped set.

`LazySets.constraints_list`

— Method`constraints_list(B::Bloating)`

Return the list of constraints of a bloated set.

**Input**

`B`

– bloated set

**Output**

The list of constraints of the bloated set.

**Notes**

The constraints list is only available for non-negative bloating in the `p`

-norm for $p = 1$ or $p = ∞$ and if `constraints_list`

is available for the unbloated set.

**Algorithm**

We call `constraints_list`

on the lazy Minkowski sum with the bloating ball.

`LazySets.center`

— Method`center(B::Bloating)`

Return the center of a bloated set.

**Input**

`B`

– bloated set

**Output**

The center of the wrapped set.

**Notes**

This implementation disregards negative bloating, which could potentially remove the center from the set.

`LazySets.is_polyhedral`

— Method`is_polyhedral(B::Bloating)`

Check whether a bloated set is polyhedral.

**Input**

`B`

– bloated set

**Output**

`true`

if the set is polyhedral.

**Algorithm**

We check the sufficient condition that the base set is polyhedral and that the norm for bloating is either 1-norm or the infinity norm.

Inherited from `LazySet`

: