def test_autocombinations(self):
# volA tests this in the CVRangeVolumes
assert volA | volA is volA
assert volA & volA is volA
assert volA ^ volA == volume.EmptyVolume()
assert volA - volA == volume.EmptyVolume()
# combo tests this with VolumeCombination of CVRangeVolumes
combo = (volD - volA)
assert combo | combo is combo
assert combo & combo is combo
assert combo ^ combo == volume.EmptyVolume()
assert combo - combo == volume.EmptyVolume()
def test_autocombinations(self):
# volA tests this in the CVRangeVolumes
assert_equal(volA | volA, volA)
assert_equal(volA & volA, volA)
assert_equal(volA ^ volA, volume.EmptyVolume())
assert_equal(volA - volA, volume.EmptyVolume())
# combo tests this with VolumeCombination of CVRangeVolumes
combo = (volD - volA)
assert_is(combo | combo, combo)
assert_is(combo & combo, combo)
assert_equal(combo ^ combo, volume.EmptyVolume())
assert_equal(combo - combo, volume.EmptyVolume())
def test_and_combinations(self):
assert (volA & volB) == volume.CVDefinedVolume(op_id, 0.25, 0.5)
assert (volA & volB)(0.45) is True
assert (volA & volB)(0.55) is False
assert (volB & volC) == volume.EmptyVolume()
# go to VolumeCombination if order parameter isn't the same
assert (volA & volA2) == volume.VolumeCombination(
volA, volA2, lambda a, b: a and b, '{0} and {1}')
def test_periodic_xor_combos(self):
assert self.pvolA ^ self.pvolA_ == volume.FullVolume()
assert self.pvolA ^ self.pvolA == volume.EmptyVolume()
assert (self.pvolE ^ self.pvolD == volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 100, 150)))
assert self.pvolB ^ self.pvolC == self.pvolB | self.pvolC
assert (self.pvolB ^ self.pvolD == volume.PeriodicCVDefinedVolume(
op_id, -100, 50))
def test_periodic_and_combos(self):
assert ((self.pvolA & self.pvolB) == volume.PeriodicCVDefinedVolume(
op_id, 50, 75))
assert (self.pvolA & self.pvolB)(60) is True
assert (self.pvolA & self.pvolB)(80) is False
assert (self.pvolB & self.pvolC) == volume.EmptyVolume()
assert (self.pvolC & self.pvolB) == volume.EmptyVolume()
assert (self.pvolA & self.pvolA) is self.pvolA
assert (self.pvolA & self.pvolA_) == volume.EmptyVolume()
assert (self.pvolE & self.pvolD) == self.pvolD
# go to special case for cyclic permutation
assert (self.pvolB & self.pvolD) == self.pvolB
# go to special case
assert ((self.pvolE & self.pvolA_) == volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 75, 150)))
# go to super if needed
assert type(self.pvolA & volA) is volume.IntersectionVolume
def test_sub_combinations(self):
assert (volA - volB) == volume.CVDefinedVolume(op_id, -0.5, 0.25)
assert (volB - volC) == volB
assert (volA - volD) == volume.EmptyVolume()
assert (volB - volA) == volume.CVDefinedVolume(op_id, 0.5, 0.75)
assert ((volD - volA) == volume.UnionVolume(
volume.CVDefinedVolume(op_id, -0.75, -0.5),
volume.CVDefinedVolume(op_id, 0.5, 0.75)))
assert (volA2 - volA) == volume.RelativeComplementVolume(volA2, volA)
def test_periodic_xor_combos(self):
assert_equal(self.pvolA ^ self.pvolA_, volume.FullVolume())
assert_equal(self.pvolA ^ self.pvolA, volume.EmptyVolume())
assert_equal(self.pvolE ^ self.pvolD,
volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 100, 150)))
assert_equal(self.pvolB ^ self.pvolC, self.pvolB | self.pvolC)
assert_equal(self.pvolB ^ self.pvolD,
volume.PeriodicCVDefinedVolume(op_id, -100, 50))
def test_and_combinations(self):
assert_equal((volA & volB), volume.CVDefinedVolume(op_id, 0.25, 0.5))
assert_equal((volA & volB)(0.45), True)
assert_equal((volA & volB)(0.55), False)
assert_equal((volB & volC), volume.EmptyVolume())
# go to VolumeCombination if order parameter isn't the same
assert_equal(
(volA & volA2),
volume.VolumeCombination(volA, volA2, lambda a, b: a and b,
'{0} and {1}'))
def test_periodic_and_combos(self):
assert_equal((self.pvolA & self.pvolB),
volume.PeriodicCVDefinedVolume(op_id, 50, 75))
assert_equal((self.pvolA & self.pvolB)(60), True)
assert_equal((self.pvolA & self.pvolB)(80), False)
assert_equal((self.pvolB & self.pvolC), volume.EmptyVolume())
assert_equal((self.pvolC & self.pvolB), volume.EmptyVolume())
assert_is((self.pvolA & self.pvolA), self.pvolA)
assert_equal((self.pvolA & self.pvolA_), volume.EmptyVolume())
assert_equal((self.pvolE & self.pvolD), self.pvolD)
# go to special case for cyclic permutation
assert_equal((self.pvolB & self.pvolD), self.pvolB)
# go to special case
assert_equal((self.pvolE & self.pvolA_),
volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 75, 150)))
# go to super if needed
assert_equal(type(self.pvolA & volA), volume.IntersectionVolume)
def test_sub_combinations(self):
assert_equal((volA - volB), volume.CVRangeVolume(op_id, -0.5, 0.25))
assert_equal((volB - volC), volB)
assert_equal((volA - volD), volume.EmptyVolume())
assert_equal((volB - volA), volume.CVRangeVolume(op_id, 0.5, 0.75))
assert_equal(
(volD - volA),
volume.UnionVolume(volume.CVRangeVolume(op_id, -0.75, -0.5),
volume.CVRangeVolume(op_id, 0.5, 0.75)))
assert_equal((volA2 - volA),
volume.RelativeComplementVolume(volA2, volA))
def test_periodic_sub_combos(self):
assert self.pvolA - self.pvolA_ is self.pvolA
assert self.pvolA_ - self.pvolA is self.pvolA_
assert (self.pvolD - self.pvolA == volume.PeriodicCVDefinedVolume(
op_id, 75, 100))
assert (self.pvolD - self.pvolA)(80) is True
assert (self.pvolD - self.pvolA)(50) is False
assert self.pvolB - self.pvolC is self.pvolB
assert self.pvolA - self.pvolA == volume.EmptyVolume()
assert (self.pvolE - self.pvolD == volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 100, 150)))
assert (self.pvolE - self.pvolA_ == volume.PeriodicCVDefinedVolume(
op_id, -100, 75))
def test_periodic_sub_combos(self):
assert_equal(self.pvolA - self.pvolA_, self.pvolA)
assert_equal(self.pvolA_ - self.pvolA, self.pvolA_)
assert_equal(self.pvolD - self.pvolA,
volume.PeriodicCVDefinedVolume(op_id, 75, 100))
assert_equal((self.pvolD - self.pvolA)(80), True)
assert_equal((self.pvolD - self.pvolA)(50), False)
assert_equal(self.pvolB - self.pvolC, self.pvolB)
assert_equal(self.pvolA - self.pvolA, volume.EmptyVolume())
assert_equal(self.pvolE - self.pvolD,
volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 100, 150)))
assert_equal(self.pvolE - self.pvolA_,
volume.PeriodicCVDefinedVolume(op_id, -100, 75))
def test_full_volume(self):
"""Full volume is well-behaved"""
full = volume.FullVolume()
test = 0.1
assert_equal(full(test), True)
assert_equal((full & volA)(test), True)
assert_equal((volA & full)(test), True)
assert_equal((full | volA)(test), True)
assert_equal((volA | full)(test), True)
# assert_is: logical combos with full should return same obj
assert_is((full & volA), volA)
assert_is((volA & full), volA)
assert_is((full | volA), full)
assert_is((volA | full), full)
assert_equal((volA - full), volume.EmptyVolume())
assert_equal((full - volA), ~volA)
assert_equal((full ^ volA), ~volA)
assert_equal((volA ^ full), ~volA)
assert_equal((volA | full).__str__(), "all")
assert_equal((~full).__str__(), "empty")
def test_empty_volume(self):
"""Empty volume is well-behaved"""
empty = volume.EmptyVolume()
test = 0.1
assert_equal(empty(test), False)
assert_equal((empty & volA)(test), False)
assert_equal((volA & empty)(test), False)
assert_equal((empty | volA)(test), True)
assert_equal((volA | empty)(test), True)
assert_equal((empty & volA).__str__(), "empty")
# assert_is: logical combos with empty should return same obj
assert_is((empty - volA), empty)
assert_is((volA - empty), volA)
assert_is((volA | empty), volA)
assert_is((empty | volA), volA)
assert_is((volA & empty), empty)
assert_is((empty & volA), empty)
assert_is((empty ^ volA), volA)
assert_is((volA ^ empty), volA)
assert_equal((~empty).__str__(), "all")
def test_empty_volume(self):
"""Empty volume is well-behaved"""
empty = volume.EmptyVolume()
test = 0.1
assert empty(test) is False
assert (empty & volA)(test) is False
assert (volA & empty)(test) is False
assert (empty | volA)(test) is True
assert (volA | empty)(test) is True
assert (empty & volA).__str__() == "empty"
# assert_is: logical combos with empty should return same obj
assert (empty - volA) is empty
assert (volA - empty) is volA
assert (volA | empty) is volA
assert (empty | volA) is volA
assert (volA & empty) is empty
assert (empty & volA) is empty
assert (empty ^ volA) is volA
assert (volA ^ empty) is volA
assert (~empty).__str__() == "all"
def test_full_volume(self):
"""Full volume is well-behaved"""
full = volume.FullVolume()
test = 0.1
assert full(test) is True
assert (full & volA)(test) is True
assert (volA & full)(test) is True
assert (full | volA)(test) is True
assert (volA | full)(test) is True
# assert_is: logical combos with full should return same obj
assert (full & volA) is volA
assert (volA & full) is volA
assert (full | volA) is full
assert (volA | full) is full
assert (volA - full) == volume.EmptyVolume()
assert (full - volA) == ~volA
assert (full ^ volA) == ~volA
assert (volA ^ full) == ~volA
assert (volA | full).__str__() == "all"
assert (~full).__str__() == "empty"
def test_empty_volume_equality(self):
empty1 = volume.EmptyVolume()
empty2 = volume.EmptyVolume()
assert_true(empty1 == empty2)
assert_false(empty1 != empty2)
def test_empty_volume_equality(self):
empty1 = volume.EmptyVolume()
empty2 = volume.EmptyVolume()
assert empty1 == empty2
assert not (empty1 != empty2)
