-
Notifications
You must be signed in to change notification settings - Fork 27
/
representation.jl
331 lines (318 loc) · 16.9 KB
/
representation.jl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
using LinearAlgebra # for I
include("inconsistentvrep.jl")
function change_fulldim_test(Rep)
T = Int
RepT = Rep{T, Matrix{T}}
@testset "Change Polyhedra.FullDim with $RepT" begin
@test fulldim(RepT) == -1
@test Polyhedra.coefficient_type(RepT) == T
changedrep = Polyhedra.similar_type(RepT, 10)
@test fulldim(changedrep) == -1
@test Polyhedra.FullDim(changedrep) == -1
#@test (@inferred Polyhedra.FullDim(changedrep)) == 10
@test Polyhedra.coefficient_type(changedrep) == T
end
end
function isempty_vtest(vr::VRepresentation, nr, np)
@testset "isempty not working correctly for iterators #17 with V-rep" begin
hasr = nr > 0
hasp = np > 0
@test npoints(vr) == length(points(vr)) == np
@test nallrays(vr) == length(allrays(vr)) == nr
@test nlines(vr) == length(lines(vr)) == 0
@test nrays(vr) == length(rays(vr)) == nr
@test haspoints(vr) == !isempty(points(vr)) == hasp
@test hasallrays(vr) == !isempty(allrays(vr)) == hasr
@test haslines(vr) == !isempty(lines(vr)) == false
@test hasrays(vr) == !isempty(rays(vr)) == hasr
end
end
function isempty_htest(hr::HRepresentation, ne, ni)
@testset "isempty not working correctly for iterators #17 with H-rep" begin
hase = ne > 0
hasi = ni > 0
@test nallhalfspaces(hr) == length(allhalfspaces(hr)) == 2ne + ni
@test nhyperplanes(hr) == length(hyperplanes(hr)) == ne
@test nhalfspaces(hr) == length(halfspaces(hr)) == ni
@test hasallhalfspaces(hr) == !isempty(allhalfspaces(hr)) == hase || hasi
@test hashyperplanes(hr) == !isempty(hyperplanes(hr)) == hase
@test hashalfspaces(hr) == !isempty(halfspaces(hr)) == hasi
end
end
@testset "Representation tests" begin
include("vecrep.jl")
include("matrep.jl")
include("liftedrep.jl")
@testset "eltype for some iterators is incorrect #7" begin
function collecttest(it, exp_type)
@test Polyhedra.coefficient_type(it) == exp_type
a = collect(it)
@test typeof(a) = Vector{exp_type}
end
hps = [HyperPlane([1, 2, 3], 7.)]
shps = [@inferred HyperPlane((@SVector [1, 2, 3]), 7.)]
@test eltype(shps) == HyperPlane{Float64, SVector{3, Float64}}
hss = [HalfSpace([4, 5, 6.], 8)]
shss = [@inferred HalfSpace((@SVector [4., 5., 6.]), 8)]
@test eltype(shss) == HalfSpace{Float64, SVector{3, Float64}}
function htest(hr::Polyhedra.HRepresentation, AT::Type{<:AbstractVector})
@test (@inferred Polyhedra.coefficient_type(hr)) == Float64
@test (@inferred eltype(allhalfspaces(hr))) == HalfSpace{Float64, AT}
@test (@inferred collect(allhalfspaces(hr))) isa Vector{HalfSpace{Float64, AT}}
@test isempty(allhalfspaces(hr)) == iszero(nallhalfspaces(hr))
@test (@inferred Polyhedra.halfspacetype(hr)) == (@inferred eltype(halfspaces(hr))) == HalfSpace{Float64, AT}
@test (@inferred collect(halfspaces(hr))) isa Vector{HalfSpace{Float64, AT}}
@test isempty(halfspaces(hr)) == iszero(nhalfspaces(hr))
@test (@inferred Polyhedra.hyperplanetype(hr)) == (@inferred eltype(hyperplanes(hr))) == HyperPlane{Float64, AT}
@test (@inferred collect(hyperplanes(hr))) isa Vector{HyperPlane{Float64, AT}}
@test isempty(hyperplanes(hr)) == iszero(nhyperplanes(hr))
@test_throws DimensionMismatch ones(2, 3) \ hr
end
#htest((@inferred hrep(hps)), Vector{Float64})
htest(hrep(hps), Vector{Float64})
#htest((@inferred hrep(shps)), SVector{3, Float64})
htest((hrep(shps)), SVector{3, Float64})
#htest((@inferred hrep(hss)), Vector{Float64})
htest(hrep(hss), Vector{Float64})
#htest((@inferred hrep(shss)), SVector{3, Float64})
htest(hrep(shss), SVector{3, Float64})
#htest((@inferred hrep(hps, hss)), Vector{Float64})
htest(hrep(hps, hss), Vector{Float64})
#htest((@inferred hrep(shps, shss)), SVector{3, Float64})
htest(hrep(shps, shss), SVector{3, Float64})
htest(hrep([1 2 3; 4 5 6], [7., 8], BitSet([1])), Vector{Float64})
htest(hrep(spzeros(2, 3), [7., 8], BitSet([1])), SparseVector{Float64, Int})
htest(hrep([1 2 3; 4 5 6], [7., 8]), Vector{Float64})
ps = [[1, 2], [3, 4]]
sps = [(@SVector [1, 2]), (@SVector [3, 4])]
rs = [Ray([0, 1])]
srs = [Ray(@SVector [0, 1])]
ls = [Line([0, 1])]
sls = [Line(@SVector [0, 1])]
@test eltype(sps) == SVector{2, Int}
function vtest(vr::VRepresentation, AT::Type{<:AbstractVector})
@test (@inferred Polyhedra.coefficient_type(vr)) == Int
@test (@inferred Polyhedra.pointtype(vr)) == (@inferred eltype(points(vr))) == AT
@test (@inferred collect(points(vr))) isa Vector{AT}
@test isempty(points(vr)) == iszero(npoints(vr))
@test (@inferred eltype(allrays(vr))) == Ray{Int, AT}
@test (@inferred collect(allrays(vr))) isa Vector{Ray{Int, AT}}
@test isempty(allrays(vr)) == iszero(nallrays(vr))
@test (@inferred Polyhedra.linetype(vr)) == (@inferred eltype(lines(vr))) == Line{Int, AT}
@test (@inferred collect(lines(vr))) isa Vector{Line{Int, AT}}
@test isempty(lines(vr)) == iszero(nlines(vr))
@test (@inferred Polyhedra.raytype(vr)) == (@inferred eltype(rays(vr))) == Ray{Int, AT}
@test (@inferred collect(rays(vr))) isa Vector{Ray{Int, AT}}
@test isempty(rays(vr)) == iszero(nrays(vr))
@test_throws DimensionMismatch ones(2, 1) * vr
end
vtest(vrep(ps), Vector{Int})
#vtest((@inferred vrep(sps)), SVector{2, Int})
vtest(vrep(sps), SVector{2, Int})
vtest(convexhull(ps...), Vector{Int})
#vtest((@inferred convexhull(sps...)), SVector{2, Int})
vtest(convexhull(sps...), SVector{2, Int})
#vtest((@inferred vrep(ls)), Vector{Int})
vtest(vrep(ls), Vector{Int})
# vtest((@inferred vrep(sls)), SVector{2, Int})
# vtest((@inferred vrep(rs)), Vector{Int})
# vtest((@inferred vrep(srs)), SVector{2, Int})
# vtest((@inferred vrep(ls, rs)), Vector{Int})
# vtest((@inferred vrep(sls, srs)), SVector{2, Int})
# vtest((@inferred vrep(ps, ls, rs)), Vector{Int})
# vtest((@inferred vrep(sps, sls, srs)), SVector{2, Int})
vtest(vrep(sls), SVector{2, Int})
vtest(vrep(rs), Vector{Int})
vtest(vrep(srs), SVector{2, Int})
vtest(vrep(ls, rs), Vector{Int})
vtest(vrep(sls, srs), SVector{2, Int})
vtest(vrep(ps, ls, rs), Vector{Int})
vtest(vrep(sps, sls, srs), SVector{2, Int})
vtest(vrep([1 2; 3 4]), Vector{Int})
vtest(vrep(spzeros(Int, 2, 2)), SparseVector{Int, Int})
vtest(vrep([1 2; 3 4], zeros(Int, 0, 0), BitSet()), Vector{Int})
vtest(vrep([1 2; 3 4], zeros(Int, 0, 0)), Vector{Int})
vtest(vrep([1 2; 3 4]), Vector{Int})
end
@testset "Iterating over halfspaces of a MixedMatHRep broken #9" begin
A = [1 2; 3 4; 5 6]
b = [1, 2, 3]
halfspace = [1, 3]
hyperplane = [2]
linset = BitSet(2)
hr = hrep(A, b, linset)
Aall = [3 4; -3 -4; 1 2; 5 6]
ball = [2, -2, 1, 3]
for (i, h) in enumerate(allhalfspaces(hr))
@test h.a == Aall[i, :]
@test h.β == ball[i]
@test isa(h, HalfSpace{Int})
end
for (i, h) in enumerate(halfspaces(hr))
@test h.a == A[halfspace[i], :]
@test h.β == b[halfspace[i]]
@test isa(h, HalfSpace{Int})
end
for (i, h) in enumerate(hyperplanes(hr))
@test h.a == A[hyperplane[i], :]
@test h.β == b[hyperplane[i]]
@test isa(h, HyperPlane{Int})
end
end
@testset "Building rep with different type" begin
@test Polyhedra.coefficient_type(MixedMatHRep{Float64}([1 2; 3 4], [1, 2], BitSet())) == Float64
@test Polyhedra.coefficient_type(MixedMatVRep{Float64}([1 2; 3 4], [1 2; 3 4], BitSet())) == Float64
@test Polyhedra.coefficient_type(LiftedHRepresentation{Float64}([1 2; 3 4])) == Float64
@test Polyhedra.coefficient_type(LiftedVRepresentation{Float64}([1 2; 3 4])) == Float64
end
@testset "Chebyshev center" begin
p = hrep(Matrix(1I, 2, 2), zeros(2))
@test_throws ErrorException chebyshevcenter(p, lp_solver) # unbounded
p = hrep([1 1; -1 -1], [0, -1])
@test_throws ErrorException chebyshevcenter(p, lp_solver) # empty
# examples/chebyshevcenter.ipynb
A = [ 2 1
2 -1
-1 2
-1 -2]
b = ones(4)
p = hrep(A, b)
c, r = chebyshevcenter(p, lp_solver)
@test c ≈ [0, 0] atol=1e-6
@test r ≈ 0.4472135955 atol=1e-6
p = convexhull([0, 0], [0, 1], [1, 0])
@test_throws ErrorException chebyshevcenter(p) # Not yet implemented
end
@testset "V-consistency with iterator constructor" begin
T = Int
AT = Vector{Int}
for VRepType in (Polyhedra.LiftedVRepresentation{T, Matrix{T}},
Polyhedra.MixedMatVRep{T, Matrix{T}},
Polyhedra.Hull{T, AT, Int})
@test_throws ErrorException VRepType(2, AT[], [Line([1, 2])])
@test_throws ErrorException VRepType(2, AT[], Line{T, AT}[], [Ray([1, 2])])
@test_throws ErrorException VRepType(2, AT[], [Line([1, 2])], [Ray([1, 2])])
v = VRepType(2, [Line([1, 2])])
@test collect(points(v)) == [[0, 0]]
@test collect(lines(v)) == [Line([1, 2])]
@test !hasrays(v)
end
for vinc in (InconsistentVRep{T, AT, Int}(2, AT[], Line{T, AT}[], [Ray([1, 2])]),
InconsistentVRep{T, AT, Int}(2, AT[], [Line([1, 2])], Ray{T, AT}[]),
InconsistentVRep{T, AT, Int}(2, AT[], [Line([1, 2])], [Ray([1, 2])]))
@test_throws ErrorException Polyhedra.checkvconsistency(vinc)
pinc = polyhedron(vinc)
@test_throws ErrorException Polyhedra.checkvconsistency(pinc)
end
let
AT = StaticArrays.SVector{1, Int}
VRepType = Polyhedra.Hull{T, AT, Int}
@test isempty(VRepType(2, AT[], Line{T, AT}[], Ray{T, AT}[]))
@test isempty(VRepType(2, Line{T, AT}[], Ray{T, AT}[]))
end
end
@testset "Combination of different coefficient type" begin
@testset "V-representation" begin
generator_fulltest(convexhull([1, 0], Line([0, 1.])), convexhull(Line([0, 1]), [1, 0.]))
@test conichull(convexhull([1, 0.]), conichull([0, 1])) isa Polyhedra.RaysHull{Float64}
@test convexhull(convexhull([1, 0]), Line([0, 1.])) isa Polyhedra.Hull{Float64}
@test convexhull(Line([0, 1.]), convexhull([1, 0])) isa Polyhedra.Hull{Float64}
@test convexhull(convexhull(Line([0, 1.])), [1, 0]) isa Polyhedra.Hull{Float64}
@test convexhull(convexhull(Line([1, 0])), Line([0, 1.])) isa Polyhedra.LinesHull{Float64}
@test convexhull(conichull([1, 0.]), Line([0, 1])) isa Polyhedra.RaysHull{Float64}
@test convexhull(conichull([1, 0.]), [0, 1]) isa Polyhedra.Hull{Float64}
end
@testset "H-representation" begin
#FIXME inference fails @test (@inferred (HyperPlane([1, 1], 0) ∩ HyperPlane([1, 0], 1)) ∩ (HyperPlane([1, 1], 0) ∩ HyperPlane([1., 0.], 1))) isa Polyhedra.HyperPlanesIntersection{Float64}
@test ((HyperPlane([1, 1], 0) ∩ HyperPlane([1, 0], 1)) ∩ (HyperPlane([1, 1], 0) ∩ HyperPlane([1., 0.], 1))) isa Polyhedra.HyperPlanesIntersection{Float64}
@test HyperPlane([1, 1], 0) ∩ HalfSpace([1., 0.], 1.) isa Polyhedra.Intersection{Float64}
#FIXME inference fails @test (@inferred (HalfSpace([1., 0.], 1.) ∩ (HyperPlane([1, 1], 0) ∩ HyperPlane([1, 0], 1)))) isa Polyhedra.Intersection{Float64}
@test ((HalfSpace([1., 0.], 1.) ∩ (HyperPlane([1, 1], 0) ∩ HyperPlane([1, 0], 1)))) isa Polyhedra.Intersection{Float64}
end
end
@testset "Conversion with different array type" begin
@testset "V-representation" begin
vv = convexhull(@SVector [0, 1]) + conichull((@SVector [1, 1]), Line(@SVector [1, 0]))
mv = vrep([0 1], [1 1; 1 0], BitSet([2]))
generator_fulltest(vv, mv)
mvv = @inferred convert(typeof(mv), vv)
vmv = @inferred convert(typeof(vv), mv)
generator_fulltest(vv, mvv)
generator_fulltest(vmv, vv)
end
@testset "H-representation" begin
vh = HalfSpace((@SVector [1, 0]), 0) ∩ HyperPlane((@SVector [0, 1]), 1)
mh = hrep([0 1; 1 0], [1, 0], BitSet(1))
inequality_fulltest(vh, mh)
mvh = @inferred convert(typeof(mh), vh)
vmh = @inferred convert(typeof(vh), mh)
inequality_fulltest(vh, mvh)
inequality_fulltest(vmh, vh)
end
end
@testset "Copy test" begin
@testset "V-representation" begin
vr = convexhull(@SVector [0, 1])
vc = copy(vr)
@test vc !== vr
@test vc.points !== vr.points
generator_fulltest(vc, vr)
vr = conichull(Line(@SVector [1, 1]), Line(@SVector [1, 0]))
vc = copy(vr)
@test vc !== vr
@test vc.lines !== vr.lines
generator_fulltest(vc, vr)
vr = conichull(Line(@SVector [1, 1]), Line(@SVector [1, 0]), @SVector [1, 1])
vc = copy(vr)
@test vc !== vr
@test vc.rays !== vr.rays
@test vc.lines !== vr.lines
@test vc.lines.lines !== vr.lines.lines
generator_fulltest(vc, vr)
vr = convexhull(@SVector [0, 1]) + conichull(Line(@SVector [1, 1]), (@SVector [1, 1]), Line(@SVector [1, 0]))
vc = copy(vr)
@test vc !== vr
@test vc.points !== vr.points
@test vc.points.points !== vr.points.points
@test vc.rays !== vr.rays
@test vc.rays.lines !== vr.rays.lines
@test vc.rays.lines.lines !== vr.rays.lines.lines
@test vc.rays.rays !== vr.rays.rays
generator_fulltest(vc, vr)
end
@testset "H-representation" begin
hr = HyperPlane([1, 0], 1) ∩ HyperPlane([0, 1], -1)
hc = copy(hr)
@test hc !== hr
@test hc.hyperplanes !== hr.hyperplanes
inequality_fulltest(hc, hr)
hr = HyperPlane([1, 0], 1) ∩ HyperPlane([1, 1], 0) ∩ HalfSpace([0, 1], -1)
hc = copy(hr)
@test hc !== hr
@test hc.hyperplanes !== hr.hyperplanes
@test hc.hyperplanes.hyperplanes !== hr.hyperplanes.hyperplanes
@test hc.halfspaces !== hr.halfspaces
inequality_fulltest(hc, hr)
end
end
@testset "Preserving sparsity" begin
for h in (HalfSpace(sparsevec([1], [1], 2), 1) ∩ HyperPlane(sparsevec([2], [-1]), 3), hrep(sparse([1, 2], [1, 2], [1, -1]), [1, 3]))
@test Polyhedra.Intersection(h) isa Polyhedra.Intersection{Int, SparseVector{Int, Int}}
@test LPHRep(h) isa LPHRep{Int}
@test MixedMatHRep(h) isa MixedMatHRep{Int, SparseMatrixCSC{Int, Int}}
@test LiftedHRepresentation(h) isa LiftedHRepresentation{Int, SparseMatrixCSC{Int, Int}}
@test Polyhedra.Intersection{Float64}(h) isa Polyhedra.Intersection{Float64, SparseVector{Float64, Int}}
@test LPHRep{Float64}(h) isa LPHRep{Float64}
@test MixedMatHRep{Float64}(h) isa MixedMatHRep{Float64, SparseMatrixCSC{Float64, Int}}
@test LiftedHRepresentation{Float64}(h) isa LiftedHRepresentation{Float64, SparseMatrixCSC{Float64, Int}}
end
for v in (convexhull(sparsevec([1], [1], 2), sparsevec([2], [-1])), vrep(sparse([1, 2], [1, 2], [1, -1])))
@test Polyhedra.Hull(v) isa Polyhedra.Hull{Int, SparseVector{Int, Int}}
@test MixedMatVRep(v) isa MixedMatVRep{Int, SparseMatrixCSC{Int, Int}}
@test LiftedVRepresentation(v) isa LiftedVRepresentation{Int, SparseMatrixCSC{Int, Int}}
@test Polyhedra.Hull{Float64}(v) isa Polyhedra.Hull{Float64, SparseVector{Float64, Int}}
@test MixedMatVRep{Float64}(v) isa MixedMatVRep{Float64, SparseMatrixCSC{Float64, Int}}
@test LiftedVRepresentation{Float64}(v) isa LiftedVRepresentation{Float64, SparseMatrixCSC{Float64, Int}}
end
end
end