def get_unit(expr, only_base_units=False, evaluate=True, cache=None):
res = None
if expr.is_symbol:
# if only_base_units:
if expr in base_units:
res = expr
# else:
# if pc.Type(expr).evaluate(cache = cache) == pc.Types.Unit:
# res = expr
elif expr.function == pc.multiplication:
units = []
for arg in expr.args:
u = get_unit(arg, only_base_units, False, cache)
if u is not None:
units.append(u)
if len(units) != 0:
res = pc.multiplication(*units)
elif pc.negative == expr.function:
res = get_unit(expr.args[0], only_base_units, False, cache)
elif pc.fraction == expr.function:
inner_unit = get_unit(expr.args[0], only_base_units, False, cache)
if inner_unit is not None:
res = pc.fraction(inner_unit)
elif pc.exponentiation == expr.function:
inner_unit = get_unit(expr.args[0], only_base_units, False, cache)
if inner_unit is not None:
res = pc.exponentiation(inner_unit, expr.args[1])
if res is not None and evaluate:
res = res.evaluate(cache=cache)
return res
def get_unit(expr, only_base_units=False, evaluate=True, cache=None):
res = None
if expr.is_symbol:
#if only_base_units:
if expr in base_units:
res = expr
#else:
# if pc.Type(expr).evaluate(cache = cache) == pc.Types.Unit:
# res = expr
elif expr.function == pc.multiplication:
units = []
for arg in expr.args:
u = get_unit(arg, only_base_units, False, cache)
if u is not None:
units.append(u)
if len(units) != 0:
res = pc.multiplication(*units)
elif pc.negative == expr.function:
res = get_unit(expr.args[0], only_base_units, False, cache)
elif pc.fraction == expr.function:
inner_unit = get_unit(expr.args[0], only_base_units, False, cache)
if inner_unit is not None:
res = pc.fraction(inner_unit)
elif pc.exponentiation == expr.function:
inner_unit = get_unit(expr.args[0], only_base_units, False, cache)
if inner_unit is not None:
res = pc.exponentiation(inner_unit, expr.args[1])
if res is not None and evaluate:
res = res.evaluate(cache=cache)
return res
if len(candidates) == 0:
return False
e = m[s.y]
exponents = [(arg.args[0]**arg.args[1])**e for arg in f.args if arg.function == pc.exponentiation]
exponents += [arg ** e for arg in f.args if isinstance(arg.value, pc.Number) or arg == pc.I]
if len(candidates) != len(f.args):
exponents += [pc.multiplication(*[arg for arg in f.args if arg not in candidates])**e]
m[s.z] = pc.multiplication(*exponents)
canonical_form.add_rule(pc.multiplication(s.x),s.x)
canonical_form.add_rule(pc.addition(s.x),s.x)
canonical_form.add_rule(pc.exponentiation(s.x),s.x)
canonical_form.add_rule(1/s.x, s.x**-1)
canonical_form.add_rule(pc.exp(s.x), pc.e**s.x)
canonical_form.add_rule(s.x**s.y, s.z, normalize_exponentiation,condition=pc.equal(pc.DominantType(pc.Type(s.y),pc.Types.Real),pc.Types.Real))
canonical_form.add_rule(pc.exp(s.x),pc.e**s.x)
canonical_form.add_rule(pc.sqrt(s.x),s.x**(1/pc.S(2)))
canonical_form.add_rule(s.x>s.y,s.y<s.x)
canonical_form.add_rule(s.x>=s.y,s.y<=s.x)
canonical_form.add_rule(s.x<=s.y,pc.Or(s.x<s.y,pc.equal(s.x,s.y)))
canonical_form.add_rule(pc.unequal(s.x,s.y),pc.Not(pc.equal(s.x,s.y)));
arg**e for arg in f.args
if isinstance(arg.value, pc.Number) or arg == pc.I
]
if len(candidates) != len(f.args):
exponents += [
pc.multiplication(
*[arg for arg in f.args if arg not in candidates])**e
]
m[s.z] = pc.multiplication(*exponents)
canonical_form.add_rule(pc.multiplication(s.x), s.x)
canonical_form.add_rule(pc.addition(s.x), s.x)
canonical_form.add_rule(pc.exponentiation(s.x), s.x)
canonical_form.add_rule(1 / s.x, s.x**-1)
canonical_form.add_rule(pc.exp(s.x), pc.e**s.x)
canonical_form.add_rule(s.x**s.y,
s.z,
normalize_exponentiation,
condition=pc.equal(
pc.DominantType(pc.Type(s.y), pc.Types.Real),
pc.Types.Real))
canonical_form.add_rule(pc.exp(s.x), pc.e**s.x)
canonical_form.add_rule(pc.sqrt(s.x), s.x**(1 / pc.S(2)))
canonical_form.add_rule(s.x > s.y, s.y < s.x)
canonical_form.add_rule(s.x >= s.y, s.y <= s.x)
