Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Activity
    Mathieu Besançon
    @matbesancon
    if it's not a monster to implement, I might give it a try, I'll need it for a paper
    Benoît Legat
    @blegat
    It should be easy to adapt from a pure Julia implementation of the double description algo
    It's the double description algo adds the hyperplanes one at a time anyway
    You could adapt ConvexHull.jl
    Or the one in Polyhedra.jl
    But currently the double description algo in Polyhedra.jl is a naive implementation
    I have implemented one similar to the one in CDD last summer but I still need to clean it up
    Benoît Legat
    @blegat
    Mathieu Besançon
    @matbesancon
    I think I almost have a BinaryBuilder working for lrslib, it should be much simpler to use than BinDeps, and handles the GMP dependency
    Benoît Legat
    @blegat
    Oh nice!
    Yes, we should transition from BinDeps to BB
    Would it work on Windows too ?
    Mathieu Besançon
    @matbesancon
    for the moment it doesn't seem to work
    I think some hardcoded things in the makefile make it fail for now
    Mathieu Besançon
    @matbesancon
    We need to figure out how to disable int128 when not available on the platform
    Mathieu Besançon
    @matbesancon
    linearity not supported by ConvexHull means one can only have cones Ax = 0 as in the original paper right?
    Benoît Legat
    @blegat
    Not even Ax = 0
    Only Ax <= b
    It wouldn't be too hard to add support for equalities
    At the beginning you start with rays spanning R^n
    If you have equlalities Ax = 0
    You need to start with rays spanning the linear subspace {x : Ax = 0} instead
    That is, you need to first solve the double description for the affine hull
    Then the rest of the algo is the same
    Mathieu Besançon
    @matbesancon

    Only Ax <= b

    you mean Ax <= 0 no?

    Benoît Legat
    @blegat
    Yes :)
    Mathieu Besançon
    @matbesancon
    :tada: for ConvexHull, I haven't digged into the incremental resolution yet
    Marcelo Forets
    @mforets
    Hi! We were discussing in the JuliaReach room whether we can do "something" to help fix 3d plotting with Makie. There is JuliaPolyhedra/Polyhedra.jl#212 for some reason that wasn't fully working.
    Does it make sense to ask help from someone from JuliaPlots?
    Benoît Legat
    @blegat
    Yes, I wasn't abl
    e to make it work with Makie with this PR either
    Marcelo Forets
    @mforets
    ok. hmm we could try approaching folks from Plots / Makie. it's a pity that JuliaCon has already ended, that would have been a good venue.
    Joey Huchette
    @joehuchette
    Quick Q: What's the simplest way to take the Minkowski sum of two Polyhedra.jl polyhedra?
    Marcelo Forets
    @mforets
    P + Q should do it? if the polyhedra are in h-rep then this will compute the vrep and this can be costly (depends on your ambient dimension).
    LazySets.jl implements a lazy minkowski sum to handle higher dimensional cases efficiently (and also specializes over the 2d case) and a concrete minkowski sum that uses Polyhedra+CDDLib but doesn't convert to vrep, using variable elimination, see LazySets.minkowski_sum.
    Joey Huchette
    @joehuchette
    Got it--thanks
    I was looking for a function named something like minkowski_sum, didn't even think to check the operators...
    Marcelo Forets
    @mforets
    :thumbsup:
    Benoît Legat
    @blegat
    In fact searching "minkowski" in the doc doesn't work as we don't include + in the doc
    Joey Huchette
    @joehuchette
    Yeah, searching "+" in the docs doesn't yield anything useful, unfortunately
    I also tried searching "+" on github but the results aren't very useful because it's so overloaded
    Benoît Legat
    @blegat
    Should be resolved by JuliaPolyhedra/Polyhedra.jl@91c3ef3
    Joey Huchette
    @joehuchette
    Thanks, Benoit
    lgtm
    Joey Huchette
    @joehuchette
    I have a polyhedron of type T <: Polyhedron, and want to create an empty polyhedron in the same ambient dimension. What's the best way to do this in a generic way? I.e. I only know that T <: Polyhedron
    Benoît Legat
    @blegat
    julia> h = HalfSpace([1], 1) ∩ HalfSpace([-1], 0)
    H-representation Polyhedra.Intersection{Int64,Array{Int64,1},Int64}:
    2-element iterator of HalfSpace{Int64,Array{Int64,1}}:
     HalfSpace([1], 1)
     HalfSpace([-1], 0)
    
    julia> p = polyhedron(h)
    Polyhedron Interval{Int64,StaticArrays.SArray{Tuple{1},Int64,1,1},StaticArrays.Size{(1,)}}:
    2-element iterator of HalfSpace{Int64,StaticArrays.SArray{Tuple{1},Int64,1,1}}:
     HalfSpace([1], 1)
     HalfSpace([-1], 0):
    2-element iterator of StaticArrays.SArray{Tuple{1},Int64,1,1}:
     [1]
     [0]
    
    julia> similar(p, Polyhedra.FullDim(p), Polyhedra.coefficient_type(p), hyperplanetype(p)[], halfspacetype(p)[])
    Polyhedron Interval{Int64,StaticArrays.SArray{Tuple{1},Int64,1,1},StaticArrays.Size{(1,)}}:
    1-element iterator of StaticArrays.SArray{Tuple{1},Int64,1,1}:
     [0],
    1-element iterator of Line{Int64,StaticArrays.SArray{Tuple{1},Int64,1,1}}:
     Line([1])
    Benoît Legat
    @blegat
    But that doesn't give you an empty polyhedron, rather a full-dimensional one that span the whole space ^^
    To have an empty one, you need n + 1 equalities, e.g. https://github.com/JuliaPolyhedra/Polyhedra.jl/blob/master/src/aff.jl#L66-L75
    Joey Huchette
    @joehuchette
    thank you!