def test_compose(): f = restrict_arity(Mock(), 1) g = restrict_arity(Mock(), 3) h = compose(f, g) result = h(1, 2, 3) g.assert_called_once_with(1, 2, 3) f.assert_called_once_with(g.return_value) assert result is f.return_value
def test_simple_unit_conversion_system(): registry = initialize_unit_registry() unit = registry['unit'] inch_to_meter = registry['inch_to_meter'] psi_to_nsm = registry['psi_to_nsm'] celsius_to_kelvin = registry['celsius_to_kelvin'] fahrenheit_to_celsius = registry['fahrenheit_to_celsius'] radius_inch = unit.invert(inch_to_meter)(sphere_radius( gas_law_volume(psi_to_nsm(14.7), compose(celsius_to_kelvin, fahrenheit_to_celsius)(68), 1))) assert math.isclose(radius_inch, 7.04962, abs_tol=1e-5)
def test_compose_multiple_funcs(): def poly(*args): results = [] for x in args: results.extend([1, x, x * x]) return Values(*results) def sum(*args): r = 0 for x in args: r += x return r def square(x): return x * x h = compose(square, sum, poly) assert h(2) == 7 * 7
def initialize_unit_registry(): unit = ConversionRegistry() celsius_to_kelvin = unit.make_conversion(lambda c: c + 273.15, lambda k: k - 273.15) fahrenheit_to_celsius = unit.make_conversion(lambda f: (f - 32) * 5 / 9, lambda c: c * 9 / 5 + 32) pound_to_newton = unit.make_conversion(lambda p: p / 0.22480894387096, lambda n: n * 0.22480894387096) inch_to_meter = unit.make_conversion(lambda i: i / 39.37, lambda m: m * 39.37) psi_to_nsm = compose(pound_to_newton, unit.invert(inch_to_meter), unit.invert(inch_to_meter)) return locals()
value_exec = analyze(definition_value(expression)) def the_definition(environment): define_variable(var, value_exec(environment), environment) return var return the_definition define_generic_procedure_handler(x.analyze, match_args(is_definition), analyze_definition) # === derived syntax === define_generic_procedure_handler(x.analyze, match_args(is_cond), compose(analyze, cond_to_if)) define_generic_procedure_handler(x.analyze, match_args(is_let), compose(analyze, let_to_combination)) # === apply === define_generic_procedure_handler( x.apply, match_args(is_strict_primitive_procedure, is_executors, is_environment), lambda procedure, operand_execs, environment: apply_primitive_procedure( procedure, map(lambda operand_exec: x.advance(operand_exec(environment)), operand_execs), ), )
def test_composition_checks_arity(): f = restrict_arity(Mock(), 1) h = compose(f, lambda x, y: 0) with pytest.raises(TypeError, match="argument"): compose(f, h)()
def test_compose_zero_funcs(): h = compose() assert h(1) == Values(1)
def test_composition_arity_equals_arity_of_g(): f = restrict_arity(Mock(), 1) h = compose(f, lambda x, y: 0) assert get_arity(h) == Arity(2)
def pow(self, unit, n): assert self.is_unit_converter(unit) return self.make_conversion(compose(*[unit] * n), compose(*[self.invert(unit)] * n))
def div(self, u1, u2): assert self.is_unit_converter(u1) assert self.is_unit_converter(u2) return self.make_conversion(compose(self.invert(u2), u1), compose(self.invert(u1), u2))
def mul(self, *units): assert all(self.is_unit_converter(u) for u in units) return self.make_conversion(compose(*units[::-1]), compose(*(self.invert(u) for u in units)))