def test_Dimension_definition():
assert dimsys_SI.get_dimensional_dependencies(length) == {"length": 1}
assert length.name == Symbol("length")
assert length.symbol == Symbol("L")
halflength = sqrt(length)
assert dimsys_SI.get_dimensional_dependencies(halflength) == {"length": S.Half}
def test_Dimension_add_sub():
assert length + length == length
assert length - length == length
assert -length == length
raises(TypeError, lambda: length + foot)
raises(TypeError, lambda: foot + length)
raises(TypeError, lambda: length - foot)
raises(TypeError, lambda: foot - length)
# issue 14547 - only raise error for dimensional args; allow
# others to pass
x = Symbol('x')
e = length + x
assert e == x + length and e.is_Add and set(e.args) == {length, x}
e = length + 1
assert e == 1 + length == 1 - length and e.is_Add and set(e.args) == {length, 1}
assert dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + force) == \
{'length': 1, 'mass': 1, 'time': -2}
assert dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + force -
pressure * length**2) == \
{'length': 1, 'mass': 1, 'time': -2}
raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + pressure))
def __new__(cls, name, parents, dct):
"""Build and register new variable."""
if '__registry__' not in dct:
unit = dct.pop('unit', S.One)
if unit == 1:
unit = S.One
definition = dct.pop('expr', None)
dct.setdefault('name', name)
dct.setdefault('assumptions', {'real': True})
dct.setdefault('latex_name', dct['name'])
dct.setdefault('unit', unit)
instance = super(VariableMeta,
cls).__new__(cls, name, parents, dct)
# Variable with definition expression.
if definition is not None:
definition = build_instance_expression(instance, definition)
derived_unit = derive_unit(definition, name=name)
if unit == S.One:
unit = derived_unit # only if unit is None
instance.expr, instance.unit = definition, unit
dim_derived = dimsys_SI.get_dimensional_dependencies(
Variable.get_dimensional_expr(derived_unit))
dim_unit = dimsys_SI.get_dimensional_dependencies(
Variable.get_dimensional_expr(unit))
if dim_derived != dim_unit:
raise ValueError(
'Invalid expression units {0} should be {1}'.format(
instance.unit, unit))
expr = BaseVariable(instance,
dct['name'],
abbrev=dct['latex_name'],
dimension=Dimension(
SI.get_dimensional_expr(unit)),
scale_factor=unit or S.One,
**dct['assumptions'])
instance[expr] = instance
# Store definition as variable expression.
if definition is not None:
instance.__expressions__[expr] = definition
# Store default variable only if it is defined.
if 'default' in dct:
instance.__defaults__[expr] = dct['default']
# Store unit for each variable:
instance.__units__[expr] = unit
return expr
return super(VariableMeta, cls).__new__(cls, name, parents, dct)
def derive_base_dimension(dim):
"""Derive base dimension of dimension."""
return functools.reduce(
operator.mul,
(Dimension(d)**p
for d, p in dimsys_SI.get_dimensional_dependencies(dim).items()),
Dimension(1))
def check_expression_dim(expression, dim_dict):
if 'E' in expression:
expression = expression.replace('E', 'exp(1)')
try:
expr_dim = eval(expression, dim_dict)
except NameError:
# sometimes the expressions contain faulty symbols
# in that case return different "dimension", investigate if the rewards of these expressions are very good
return (9, 9, 9, 9, 9, 9, 9)
try:
dims = dimsys_SI.get_dimensional_dependencies(expr_dim)
except TypeError:
return (10, 10, 10, 10, 10, 10, 10)
#process dims: [mass, lenght, time, temp, quantity, current, luminousintensity]
OF_dims = [0, 0, 0, 0, 0, 0, 0]
for key in dims:
# note only length and time implemented currently
if key == 'time':
OF_dims[2] = dims[key]
elif key == 'length':
OF_dims[1] = dims[key]
return tuple(OF_dims)
def _Quantity_constructor_postprocessor_Add(expr):
"""Construct postprocessor for the addition.
It checks for dimension mismatches of the addends, thus preventing
expressions like ``meter + second`` to be created.
"""
deset = {
tuple(
sorted(
dimsys_SI.get_dimensional_dependencies(
Dimension(
SI.get_dimensional_expr(i) if not i.is_number else 1)).
items()))
for i in expr.args
if i.free_symbols == set() # do not raise if there are symbols
# (free symbols could contain the units corrections)
}
# If `deset` has more than one element, then some dimensions do not
# match in the sum:
if len(deset) > 1:
raise ValueError("summation of quantities of incompatible dimensions")
return expr
def derive_baseunit(expr, name=None):
"""Derive SI base unit from an expression, omitting scale factors."""
from essm.variables import Variable
from essm.variables.utils import extract_variables
from sympy.physics.units import Dimension
from sympy.physics.units.systems.si import dimsys_SI
Variable.check_unit(expr) # check for dimensional consistency
variables = extract_variables(expr)
for var1 in variables:
q1 = Quantity('q_' + str(var1))
SI.set_quantity_dimension(
q1,
Dimension(
SI.get_dimensional_expr(derive_baseunit(
var1.definition.unit))))
SI.set_quantity_scale_factor(q1, var1.definition.unit)
expr = expr.xreplace({var1: q1})
dim = Dimension(Variable.get_dimensional_expr(expr))
return functools.reduce(
operator.mul,
(SI_BASE_DIMENSIONS[Symbol(d)]**p
for d, p in dimsys_SI.get_dimensional_dependencies(dim).items()), 1)
def test_Dimension_mul_div_exp():
assert 2*length == length*2 == length/2 == length
assert 2/length == 1/length
x = Symbol('x')
m = x*length
assert m == length*x and m.is_Mul and set(m.args) == {x, length}
d = x/length
assert d == x*length**-1 and d.is_Mul and set(d.args) == {x, 1/length}
d = length/x
assert d == length*x**-1 and d.is_Mul and set(d.args) == {1/x, length}
velo = length / time
assert (length * length) == length ** 2
assert dimsys_SI.get_dimensional_dependencies(length * length) == {"length": 2}
assert dimsys_SI.get_dimensional_dependencies(length ** 2) == {"length": 2}
assert dimsys_SI.get_dimensional_dependencies(length * time) == { "length": 1, "time": 1}
assert dimsys_SI.get_dimensional_dependencies(velo) == { "length": 1, "time": -1}
assert dimsys_SI.get_dimensional_dependencies(velo ** 2) == {"length": 2, "time": -2}
assert dimsys_SI.get_dimensional_dependencies(length / length) == {}
assert dimsys_SI.get_dimensional_dependencies(velo / length * time) == {}
assert dimsys_SI.get_dimensional_dependencies(length ** -1) == {"length": -1}
assert dimsys_SI.get_dimensional_dependencies(velo ** -1.5) == {"length": -1.5, "time": 1.5}
length_a = length**"a"
assert dimsys_SI.get_dimensional_dependencies(length_a) == {"length": Symbol("a")}
assert length != 1
assert length / length != 1
length_0 = length ** 0
assert dimsys_SI.get_dimensional_dependencies(length_0) == {}
# issue 18738
a = Symbol('a')
b = Symbol('b')
c = sqrt(a**2 + b**2)
c_dim = c.subs({a: length, b: length})
assert dimsys_SI.equivalent_dims(c_dim, length)
def base_dimensions(d):
dependencies = dimsys_SI.get_dimensional_dependencies(d)
return Mul.fromiter(
Pow(Dimension(base), exp_) for base, exp_ in dependencies.items())
def test_Dimension_mul_div_exp():
assert 2*length == length*2 == length/2 == length
assert 2/length == 1/length
x = Symbol('x')
m = x*length
assert m == length*x and m.is_Mul and set(m.args) == {x, length}
d = x/length
assert d == x*length**-1 and d.is_Mul and set(d.args) == {x, 1/length}
d = length/x
assert d == length*x**-1 and d.is_Mul and set(d.args) == {1/x, length}
velo = length / time
assert (length * length) == length ** 2
assert dimsys_SI.get_dimensional_dependencies(length * length) == {"length": 2}
assert dimsys_SI.get_dimensional_dependencies(length ** 2) == {"length": 2}
assert dimsys_SI.get_dimensional_dependencies(length * time) == { "length": 1, "time": 1}
assert dimsys_SI.get_dimensional_dependencies(velo) == { "length": 1, "time": -1}
assert dimsys_SI.get_dimensional_dependencies(velo ** 2) == {"length": 2, "time": -2}
assert dimsys_SI.get_dimensional_dependencies(length / length) == {}
assert dimsys_SI.get_dimensional_dependencies(velo / length * time) == {}
assert dimsys_SI.get_dimensional_dependencies(length ** -1) == {"length": -1}
assert dimsys_SI.get_dimensional_dependencies(velo ** -1.5) == {"length": -1.5, "time": 1.5}
length_a = length**"a"
assert dimsys_SI.get_dimensional_dependencies(length_a) == {"length": Symbol("a")}
assert length != 1
assert length / length != 1
length_0 = length ** 0
assert dimsys_SI.get_dimensional_dependencies(length_0) == {}
def test_Dimension_functions():
raises(TypeError,
lambda: dimsys_SI.get_dimensional_dependencies(cos(length)))
raises(TypeError,
lambda: dimsys_SI.get_dimensional_dependencies(acos(angle)))
raises(TypeError,
lambda: dimsys_SI.get_dimensional_dependencies(atan2(length, time)))
raises(TypeError,
lambda: dimsys_SI.get_dimensional_dependencies(log(length)))
raises(TypeError,
lambda: dimsys_SI.get_dimensional_dependencies(log(100, length)))
raises(TypeError,
lambda: dimsys_SI.get_dimensional_dependencies(log(length, 10)))
assert dimsys_SI.get_dimensional_dependencies(pi) == {}
assert dimsys_SI.get_dimensional_dependencies(cos(1)) == {}
assert dimsys_SI.get_dimensional_dependencies(cos(angle)) == {}
assert dimsys_SI.get_dimensional_dependencies(atan2(length, length)) == {}
assert dimsys_SI.get_dimensional_dependencies(
log(length / length, length / length)) == {}
assert dimsys_SI.get_dimensional_dependencies(Abs(length)) == {length: 1}
assert dimsys_SI.get_dimensional_dependencies(Abs(length / length)) == {}
assert dimsys_SI.get_dimensional_dependencies(sqrt(-1)) == {}
def test_issue_22819():
from sympy.physics.units import tonne, gram, Da
from sympy.physics.units.systems.si import dimsys_SI
assert tonne.convert_to(gram) == 1000000 * gram
assert dimsys_SI.get_dimensional_dependencies(area) == {length: 2}
assert Da.scale_factor == 1.66053906660000e-24
