def test_product_name():
r = hd.Range(10)
p = hd.Product((r, r), name="TestProduct")
assert p.name == "TestProduct"
r = hd.Range(10)
p = hd.Product((r, r), name="TestUProduct", unordered=True)
assert p.name == "TestUProduct"
p = hd.NamedProduct([("a", r), ("b", r * r)], name="TestNamedProduct")
assert p.name == "TestNamedProduct"
def test_uproduct_steps():
items = (1, 2, 7, 8)
a = hd.Range(10).filter(lambda x: x in items)
p = hd.Product((a, a), unordered=True)
assert p.size == 45
for i in xrange(9):
assert list(p.iterate_steps(0, i)) == []
assert list(p.iterate_steps(0, 10)) == [(2, 1)]
assert list(p.iterate_steps(0, 14)) == [(2, 1)]
assert list(p.iterate_steps(0, 15)) == [(2, 1), (7, 1)]
assert list(p.iterate_steps(0, 16)) == [(2, 1), (7, 1), (8, 1)]
assert list(p.iterate_steps(0, 21)) == [(2, 1), (7, 1), (8, 1)]
assert list(p.iterate_steps(0, 22)) == [(2, 1), (7, 1), (8, 1), (7, 2)]
assert list(p.iterate_steps(0, 23)) == [(2, 1), (7, 1), (8, 1), (7, 2),
(8, 2)]
assert list(p.iterate_steps(0, 42)) == [(2, 1), (7, 1), (8, 1), (7, 2),
(8, 2)]
assert list(p.iterate_steps(0, 43)) == [(2, 1), (7, 1), (8, 1), (7, 2),
(8, 2), (8, 7)]
assert list(p.iterate_steps(0, 45)) == [(2, 1), (7, 1), (8, 1), (7, 2),
(8, 2), (8, 7)]
assert list(p.iterate_steps(6, 16)) == [(2, 1), (7, 1), (8, 1)]
assert list(p.iterate_steps(9, 16)) == [(2, 1), (7, 1), (8, 1)]
assert list(p.iterate_steps(10, 16)) == [(7, 1), (8, 1)]
assert list(p.iterate_steps(14, 16)) == [(7, 1), (8, 1)]
assert list(p.iterate_steps(15, 16)) == [(8, 1)]
def test_uproduct_iterate():
r1 = hd.Range(4)
p = hd.Product((r1, r1), unordered=True)
result = list(p)
assert set(result) == {(1, 0), (2, 0), (3, 0), (2, 1), (3, 1), (3, 2)}
assert len(result) == p.size
p = hd.Product((r1, r1, r1), unordered=True)
result = list(p)
assert set(result) == {(2, 1, 0), (3, 1, 0), (3, 2, 0), (3, 2, 1)}
assert len(result) == p.size
p = hd.Product((r1, r1, r1, r1), unordered=True)
result = list(p)
assert set(result) == {(3, 2, 1, 0)}
assert len(result) == p.size
def test_product_iterate():
r1 = hd.Range(4)
r2 = hd.Range(2)
p = hd.Product((r1, r1, r2))
expected = list(itertools.product(range(4), range(4), range(2)))
assert set(p) == set(expected)
assert len(list(p)) == len(expected)
assert p.size == len(expected)
def test_product_generate():
r1 = hd.Range(4)
r2 = hd.Range(2)
p = hd.Product((r1, r1, r2))
result = list(p.generate(200))
for r in result:
assert len(r) == 3
assert 0 <= r[0] < 4
assert 0 <= r[1] < 4
assert 0 <= r[2] < 2
def test_for_size(cache_size):
r = hd.Range(10000)
p = hd.Product((r, r), unordered=True, cache_size=cache_size)
result = list(p.generate(size))
cache_pairs = (cache_size * (cache_size - 1)) / 2
for i in xrange(size / cache_pairs):
values = set()
for a, b in result[i * cache_pairs:(i + 1) * cache_pairs]:
values.add(a)
values.add(b)
assert len(values) <= cache_pairs
def test_uproduct_iter_set():
r = hd.Range(10)
p = hd.Product((r, r), unordered=True)
a = list(p)
for i in xrange(p.size):
it = p.create_iter(i)
result = list(it)
assert a[i:] == result
r = hd.Range(899)
p = hd.Product((r, r), unordered=True)
a = list(p)
x = 43211
it = p.create_iter(x)
assert list(it) == a[x:]
x = 403388
it = p.create_iter(x)
assert list(it) == a[x:]
def test_for_size(cache_size):
r = hd.Range(10000)
p = hd.Product((r, r), cache_size=cache_size)
result = list(p.generate(size))
cache_pairs = cache_size * cache_size
for i in xrange(size / cache_pairs):
values1 = set()
values2 = set()
for a, b in result[i * cache_pairs:(i + 1) * cache_pairs]:
values1.add(a)
values2.add(b)
assert len(values1) <= cache_size and len(values2) <= cache_size
def test_domain_filter():
def fn(x):
return x > 2 and x < 5
r = hd.Range(6)
d = r.filter(fn)
result = list(d)
assert result == [3, 4]
result = list(d.generate(5))
assert len(result) == 5
for x in result:
assert x in [3, 4]
assert d.filtered
assert not r.filtered
assert d.size == 6
p = d * d
result = list(p)
assert set(result) == {(3, 3), (4, 3), (3, 4), (4, 4)}
assert p.filtered
assert not (r * r).filtered
assert hd.Sequences(d, 2).filtered
assert not hd.Sequences(r, 2).filtered
assert not hd.Mappings(d, r).filtered
assert hd.Mappings(r, d).filtered
assert not hd.Mappings(r, r).filtered
assert hd.Product((d, d), unordered=True).filtered
assert not hd.Product((r, r), unordered=True).filtered
result = list(hd.Product((d, d), unordered=True))
assert set(result) == {(4, 3)}
def test_domain_map():
def fn(x):
return (x + 1) * 10
d = hd.Range(5).map(fn)
result = list(d)
assert result == [10, 20, 30, 40, 50]
result = list(d.generate(10))
for x in result:
assert x in [10, 20, 30, 40, 50]
result = list(hd.Product((d, d), unordered=True))
assert set(result) == {(20, 10), (30, 10), (40, 10), (50, 10), (30, 20),
(40, 20), (50, 20), (40, 30), (50, 30), (50, 40)}
assert d.size == 5
assert not d.filtered
assert d.step_jumps
def test_uproduct_steps2():
a = hd.Range(3).filter(lambda x: x != 2)
b = (a * a).filter(lambda x: x[0] + x[1] > 0)
c = hd.Product((b, b), unordered=True)
assert list(b) == [(0, 1), (1, 0), (1, 1)]
assert list(c.iterate_steps(0, 9)) == []
assert list(c.iterate_steps(0, 10)) == [((1, 0), (0, 1))]
assert list(c.iterate_steps(0, 11)) == [((1, 0), (0, 1)), ((1, 1), (0, 1))]
assert set(c.iterate_steps(0, 36)) == \
set((((1, 0), (0, 1)), ((1, 1), (1, 0)), ((1, 1), (0, 1))))
assert list(c.iterate_steps(8, 9)) == []
assert list(c.iterate_steps(9, 10)) == [((1, 0), (0, 1))]
assert list(c.iterate_steps(0, 11)) == [((1, 0), (0, 1)), ((1, 1), (0, 1))]
assert list(c.iterate_steps(14, 20)) == []
assert list(c.iterate_steps(14, 26)) == [((1, 1), (1, 0))]
assert set(c.iterate_steps(8, 36)) == \
set((((1, 0), (0, 1)), ((1, 1), (1, 0)), ((1, 1), (0, 1))))
def test_canonical_product():
ax = USet(3, "a")
a0, a1, a2 = ax.all()
bx = USet(2, "b")
b0, b1 = bx.all()
result = list(hd.Product((ax, )).create_cn_iter())
assert result == [(a0, )]
result = list((ax * ax).create_cn_iter())
assert result == [(a0, a0), (a0, a1)]
result = list((ax * ax * ax).create_cn_iter())
assert result == [(a0, a0, a0), (a0, a0, a1), (a0, a1, a0), (a0, a1, a1),
(a0, a1, a2)]
result = list((bx * bx * bx).create_cn_iter())
assert result == [(b0, b0, b0), (b0, b0, b1), (b0, b1, b0), (b0, b1, b1)]
result = list((ax * bx * bx).create_cn_iter())
assert result == [(a0, b0, b0), (a0, b0, b1)]
def test_product_empty():
p = hd.Product(())
assert list(p) == [()]
