- Join over
**1.5M+ people** - Join over
**100K+ communities** - Free
**without limits** - Create
**your own community**

- 22:16schillic commented #1983
- 22:14mforets labeled #1983
- 22:14mforets opened #1983
- 22:12schillic labeled #1982
- 22:12schillic opened #1982
- 22:09
schillic on 1779

HPolyhedron's support vector reβ¦ define support function of emptβ¦ (compare)

- 20:32schillic labeled #1895
- 20:32schillic edited #1895
- 20:29schillic opened #1981
- 20:25
schillic on 1911

type stable genmat_fallback (compare)

- 20:25schillic assigned #1911
- 20:18schillic edited #1911
- 19:59schillic synchronize #1979
- 19:59
schillic on 1926

define isboundedtype trait (compare)

- 19:57schillic synchronize #1979
- 19:57
schillic on 1926

define isboundedtype trait (compare)

- 19:53schillic edited #1884
- 19:52schillic review_requested #1884
- 19:48schillic commented #1968
- 19:42schillic opened #1980

so do you call this code in a loop while

`S`

is it always the same matrix?
i think currently there is no way to pass the inverted matrix, but yes, this could save some time indeed

I can "speed up" the code by omitting to remove the redundant constraints

by adding the constraints like this.

there is an optional kwarg for this: `prune=false`

perhaps my question is: what is the result (set type) of

`minkowski_difference(P, W)`

using LazySets

```
function maximal_RPI_set(S, π²::LazySet, π::LazySet)
S_inv = inv(S)
π« = π
k = 0
while true
k +=1
# concrete set operations (S_invβ
π« β π²) β© π
π«βΊ = intersection(linear_map(S_inv, minkowski_difference(π«,π²)), π)
if (π«βΊ β π« && π« β π«βΊ)
break
end
π« = π«βΊ
end
return π«, k
end
n = 2
W = BallInf(zeros(n), 0.25)
D = BallInf(zeros(n), 5.0)
# Schur Matrix S
S = [0.755 0.7; 0.0 0.75]
@time maximal_RPI_set(S, W, D)
```

where $X$ is the minkowski difference

And also, I'd like to figure out, how the computational complexity of

And to do that, I first wanted to have a really performant code.

`linear_map`

growths with the number of constraints?And to do that, I first wanted to have a really performant code.

can't we use the information to quickly compute the action of the linear map to the HPOlytope

i think we had an open issue for this

@schillic this was your idea ?

For example, for the

Or does it make totally sense, that the

`minkowski_difference`

I know that I solve #constraint linear programs (therefore, it is linear in the number of constraints) and I was surprised, that the `linear_map`

does take significantly more time than the `minkowski_differnence`

and now, I try to figure out why exactly.Or does it make totally sense, that the

`linear_map`

takes more time?
they are very fast if the sets are zonotopic

since then linear maps are just the action over the generators

yes, to have an option to pass the inverted matrix

if the matrix is invertible then the linear map can be computed *without* passing to the vrep

it is easy, just see how it transforms each constraints

in the general case (the matrix is not invertible) you have to pass to the vertex representation and this can be expensive

`linear_map`

inverts again
there should be an option to pass

`S`

directly
and still

if we pass

`S`

to `linear_map`

there should be an option to pass S directly

maybe our messages crossed