def test_reverse(self):
"""Check if it reverses `transform` properly, if possible."""
t = Quantize()
assert t.reverse(9) == 9.0
assert t.reverse(5) == 5.0
assert numpy.all(
t.reverse([9, 5]) == numpy.array([9.0, 5.0], dtype=float))
def test_transform(self):
"""Check if it transforms properly."""
t = Quantize()
assert t.transform(8.6) == 8
assert t.transform(5.3) == 5
assert numpy.all(
t.transform([8.6, 5.3]) == numpy.array([8, 5], dtype=int))
def test_domain_and_target_type(self):
"""Check if attribute-like `domain_type` and `target_type` do
what's expected.
"""
t = Reverse(Quantize())
assert t.domain_type == 'integer'
assert t.target_type == 'real'
def test_reverse(self):
"""Check if it reverses `transform` properly, if possible."""
t = Reverse(Quantize())
assert t.reverse(8.6) == 8
assert t.reverse(5.3) == 5
assert numpy.all(
t.reverse([8.6, 5.3]) == numpy.array([8, 5], dtype=int))
def test_transform(self):
"""Check if it transforms properly."""
t = Reverse(Quantize())
assert t.transform(9) == 9.0
assert t.transform(5) == 5.0
assert numpy.all(
t.transform([9, 5]) == numpy.array([9.0, 5.0], dtype=float))
def test_domain_and_target_type(self):
"""Check if attribute-like `domain_type` and `target_type` do
what's expected.
"""
t = Quantize()
assert t.domain_type == "real"
assert t.target_type == "integer"
def test_quantization_does_not_violate_bounds():
"""Regress on bug that converts valid float in tdim to non valid excl. upper bound."""
dim = Integer("yo", "uniform", 3, 7)
transformers = [Reverse(Quantize())]
tdim = TransformedDimension(Compose(transformers, dim.type), dim)
assert 11 not in dim
assert 10 in dim
# but be careful, because upper bound is inclusive
assert 11.5 not in tdim
assert 10.6 in tdim
assert tdim.reverse(9.6) in dim
# solution is to quantize with 'floor' instead of 'round'
assert tdim.reverse(9.6) == 9
def test_domain_and_target_type(self):
"""Check if attribute-like `domain_type` and `target_type` do
what's expected.
"""
t = Compose([])
assert t.domain_type is None
assert t.target_type is None
t = Compose([], 'real')
assert t.domain_type == 'real'
assert t.target_type == 'real'
t = Compose([Quantize()], 'real')
assert t.domain_type == 'real'
assert t.target_type == 'integer'
t = Compose([Enumerate([2, 'asfa', 'ipsi']), OneHotEncode(3)], 'categorical')
assert t.domain_type == 'categorical'
assert t.target_type == 'real'
def test_domain_and_target_type(self):
"""Check if attribute-like `domain_type` and `target_type` do
what's expected.
"""
t = Compose([])
assert t.domain_type is None
assert t.target_type is None
t = Compose([], "real")
assert t.domain_type == "real"
assert t.target_type == "real"
t = Compose([Quantize()], "real")
assert t.domain_type == "real"
assert t.target_type == "integer"
t = Compose([Enumerate([2, "asfa", "ipsi"]), OneHotEncode(3)], "categorical")
assert t.domain_type == "categorical"
assert t.target_type == "real"
def test_repr_format(self):
"""Check representation of a transformed dimension."""
t = Reverse(Quantize())
assert t.repr_format('asfa') == 'ReverseQuantize(asfa)'
def test_infer_target_shape(self):
"""Check if it infers the shape of a transformed `Dimension`."""
t = Reverse(Quantize())
assert t.infer_target_shape((5,)) == (5,)
def test_deepcopy(self):
"""Verify that the transformation object can be copied"""
t = Reverse(Quantize())
t.transform([2])
copy.deepcopy(t)
def tdim(dim):
"""Create an example of `TransformedDimension`."""
transformers = [Quantize()]
tdim = TransformedDimension(Compose(transformers, dim.type),
dim)
return tdim
def test_repr_format(self):
"""Check representation of a transformed dimension."""
t = Quantize()
assert t.repr_format("asfa") == "Quantize(asfa)"
