Merge pull request #99 from JuliaPolyhedra/bl/lpsolver

Remove lpsolver

Author: blegat

test/board.jl

@@ -48,11 +48,11 @@ function boardtest(lib::Lib) where Lib<:PolyhedraLibrary
     bcut = [cutb; b]
     inecut = hrep(Acut, bcut)
     polycut = polyhedron(inecut, lib)
-    @test !isempty(polycut, Polyhedra.solver(polycut, lpsolver...))
+    @test !isempty(polycut)
     #(isredundant, certificate) = isredundantinequality(polycut, 1)
     #@test !isredundant
     #@test certificate == target
-    @test !isredundant(polycut, first(eachindex(halfspaces(polycut))), solver=Polyhedra.solver(polycut, lpsolver...))
+    @test !isredundant(polycut, first(eachindex(halfspaces(polycut))))
     # @test IntSet() == gethredundantindices(polycut) # TODO reactivate it when I figure out why it makes LRS tests fail
     #(issredundant, scertificate) = isstronglyredundantinequality(polycut, 1)
     #@test !issredundant

test/docexample.jl

@@ -4,10 +4,9 @@ function doctest(lib::PolyhedraLibrary)
     V = [1//2 1//2; 0 1; 0 0]
     hr = hrep(A, b)
     p = polyhedron(hr, lib)
-    solver = Polyhedra.solver(p, lpsolver...)
-    @test issubset(p, HalfSpace([1, -1], 0), solver)
-    @test !(issubset(p, HalfSpace([1, 1], 0), solver))
-    @test !(issubset(p, HyperPlane([-1, 0], 0), solver))
+    @test p ⊆ HalfSpace([1, -1], 0)
+    @test !(p ⊆ HalfSpace([1, 1], 0))
+    @test !(p ⊆ HyperPlane([-1, 0], 0))
     inequality_fulltest(p, A, b, IntSet())
     generator_fulltest(p, V)
     @test hrepiscomputed(p)

test/permutahedron.jl

@@ -5,7 +5,7 @@ function permutahedrontest(lib::Lib) where Lib<:PolyhedraLibrary
     V = [2 3 1; 1 3 2; 3 1 2; 3 2 1; 2 1 3; 1 2 3]
     ine = hrep(A, b, linset)
     poly = polyhedron(ine, lib)
-    @test !isempty(poly, Polyhedra.solver(poly, lpsolver...))
+    @test !isempty(poly)
     inequality_fulltest(poly, A, b, linset)
     generator_fulltest(poly, V, Array{Int}(0, 3))
 

test/runtests.jl

@@ -9,7 +9,6 @@ using StaticArrays
 include("utils.jl")
 
 include("solvers.jl")
-lpsolver = tuple() # TODO remove in v0.3.2
 
 include("elements.jl")
 include("comp.jl")

test/simplex.jl

@@ -2,8 +2,8 @@ function simplextest(lib::PolyhedraLibrary)
     hsim = HalfSpace([-1, 0], 0) ∩ HalfSpace([0, -1], 0) ∩ HyperPlane([1, 1], 1)
     vsim = convexhull([0, 1], [1, 0])
     poly1 = polyhedron(hsim, lib)
-    @test !isempty(poly1, Polyhedra.solver(poly1, lpsolver...))
-    center, radius = chebyshevcenter(poly1, Polyhedra.solver(poly1, lpsolver...))
+    @test !isempty(poly1)
+    center, radius = chebyshevcenter(poly1)
     @test center ≈ [1/2, 1/2]
     @test radius ≈ 1/2
     @test dim(poly1) == 1 # FIXME doing dim earlier makes chebyshevcenter fail
@@ -56,7 +56,7 @@ function simplextest(lib::PolyhedraLibrary)
     # x_1 cannot be 2
     hempty = hsim ∩ HyperPlane([1, 0], 2)
     poly = polyhedron(hempty, lib)
-    @test isempty(poly, Polyhedra.solver(poly, lpsolver...))
+    @test isempty(poly)
 
     # We now add the vertex (0, 0)
     ext0 = convexhull([0, 0])

test/solvers.jl

@@ -46,4 +46,3 @@ if lp_solver === nothing
     scs && (lp_solver = SCS.SCSSolver(eps=1e-6,verbose=0))
     @assert lp_solver !== nothing
 end
-lpsolver = tuple(lp_solver) # TODO remove in v0.3.2

test/sparse.jl

@@ -18,9 +18,9 @@ function sparsetest(lib::PolyhedraLibrary)
                    [0,    -1,  1])
     p = polyhedron(h, lib)
     @test !vrepiscomputed(p)
-    @test ⊆(p, HalfSpace([3, 2, 0], 2), lpsolver...)
+    @test p ⊆ HalfSpace([3, 2, 0], 2)
     @test !vrepiscomputed(p)
-    @test !⊆(p, HalfSpace([3, 2, 0], 1), lpsolver...)
+    @test !(p ⊆ HalfSpace([3, 2, 0], 1))
     @test !vrepiscomputed(p)
     inequality_fulltest(p, h)
     generator_fulltest(p, v)
@@ -30,9 +30,9 @@ function sparsetest(lib::PolyhedraLibrary)
     # If lib supported sparse, hvectortype(q) should be sparse hence hvectortype(p) should also be sparse
     @test Polyhedra.hvectortype(typeof(p)) == Polyhedra.hvectortype(typeof(q))
     @test !vrepiscomputed(q)
-    @test ⊆(q, HalfSpace([2, -3], 0), lpsolver...) # This also checks that the solver was ot dropped during fixandeliminate
+    @test q ⊆ HalfSpace([2, -3], 0) # This also checks that the solver was ot dropped during fixandeliminate
     @test !vrepiscomputed(q)
-    @test !⊆(q, HalfSpace([2, -3], -1), lpsolver...)
+    @test !(q ⊆ HalfSpace([2, -3], -1))
     @test !vrepiscomputed(q)
     hfix = HalfSpace([ 2,  0], -1) ∩
            HalfSpace([ 0, -3],  1) ∩